@sdeverywhere/runtime 0.2.0 → 0.2.2

package/dist/index.d.ts

@@ -1,9 +1,19 @@
 import { Result } from 'neverthrow';
 
 /** An input variable identifier string, as used in SDEverywhere. */
-declare type InputVarId = string;
+type InputVarId = string;
 /** An output variable identifier string, as used in SDEverywhere. */
-declare type OutputVarId = string;
+type OutputVarId = string;
+/**
+ * The variable index values for use with the optional output indices buffer.
+ * @hidden This is not yet part of the public API; it is exposed here for use in testing tools.
+ */
+interface OutputVarSpec {
+    /** The variable index as used in the generated C code. */
+    varIndex: number;
+    /** The subscript index values as used in the generated C code. */
+    subscriptIndices?: number[];
+}
 
 /**
  * Type declaration for a WebAssembly module wrapper produced
@@ -18,6 +28,8 @@ interface WasmModule {
     /** @hidden */
     _free: (byteOffset: number) => void;
     /** @hidden */
+    HEAP32: Int32Array;
+    /** @hidden */
     HEAPF64: Float64Array;
 }
 
@@ -33,19 +45,20 @@ interface WasmModule {
  * in the browser's normal JS thread, and then use `getArrayView` to copy into and
  * out of the wasm buffer.
  */
-declare class WasmBuffer {
+declare class WasmBuffer<ArrType> {
     private readonly wasmModule;
     private byteOffset;
     private heapArray;
     /**
      * @param wasmModule The `WasmModule` used to initialize the memory.
-     * @param numElements The number of 64-bit `double` elements in the buffer.
+     * @param byteOffset The byte offset within the wasm heap.
+     * @param heapArray The array view on the underlying heap buffer.
      */
-    constructor(wasmModule: WasmModule, numElements: number);
+    constructor(wasmModule: WasmModule, byteOffset: number, heapArray: ArrType);
     /**
-     * @return A new `Float64Array` view on the underlying heap buffer.
+     * @return An `ArrType` view on the underlying heap buffer.
      */
-    getArrayView(): Float64Array;
+    getArrayView(): ArrType;
     /**
      * @return The raw address of the underlying heap buffer.
      * @hidden This is intended for use by `WasmModel` only.
@@ -56,6 +69,24 @@ declare class WasmBuffer {
      */
     dispose(): void;
 }
+/**
+ * Return a `WasmBuffer` that holds int32 elements.
+ *
+ * @hidden For internal use only.
+ *
+ * @param wasmModule The `WasmModule` used to initialize the memory.
+ * @param numElements The number of elements in the buffer.
+ */
+declare function createInt32WasmBuffer(wasmModule: WasmModule, numElements: number): WasmBuffer<Int32Array>;
+/**
+ * Return a `WasmBuffer` that holds float64 elements.
+ *
+ * @hidden For internal use only.
+ *
+ * @param wasmModule The `WasmModule` used to initialize the memory.
+ * @param numElements The number of elements in the buffer.
+ */
+declare function createFloat64WasmBuffer(wasmModule: WasmModule, numElements: number): WasmBuffer<Float64Array>;
 
 /**
  * An interface to the generated WebAssembly model.  Allows for running the model with
@@ -70,6 +101,12 @@ declare class WasmModel {
     readonly saveFreq: number;
     /** The number of save points for each output. */
     readonly numSavePoints: number;
+    /**
+     * The maximum number of output indices that can be passed for each run.
+     * @hidden This is not yet part of the public API; it is exposed here for use
+     * in experimental testing tools.
+     */
+    readonly maxOutputIndices: number;
     private readonly wasmRunModel;
     /**
      * @param wasmModule The `WasmModule` that provides access to the native functions.
@@ -81,8 +118,9 @@ declare class WasmModel {
      *
      * @param inputs The buffer containing inputs in the order expected by the model.
      * @param outputs The buffer into which the model will store output values.
+     * @param outputIndices The buffer used to control which variables are written to `outputs`.
      */
-    runModel(inputs: WasmBuffer, outputs: WasmBuffer): void;
+    runModel(inputs: WasmBuffer<Float64Array>, outputs: WasmBuffer<Float64Array>, outputIndices?: WasmBuffer<Int32Array>): void;
 }
 /**
  * The result of model initialization.
@@ -91,9 +129,15 @@ interface WasmModelInitResult {
     /** The wasm model. */
     model: WasmModel;
     /** The buffer used to pass input values to the model. */
-    inputsBuffer: WasmBuffer;
+    inputsBuffer: WasmBuffer<Float64Array>;
     /** The buffer used to receive output values from the model. */
-    outputsBuffer: WasmBuffer;
+    outputsBuffer: WasmBuffer<Float64Array>;
+    /**
+     * The buffer used to control which variables are written to `outputsBuffer`.
+     * @hidden This is not yet part of the public API; it is exposed here for use
+     * in experimental testing tools.
+     */
+    outputIndicesBuffer?: WasmBuffer<Int32Array>;
     /** The output variable IDs. */
     outputVarIds: OutputVarId[];
 }
@@ -105,6 +149,11 @@ interface WasmModelInitResult {
  * @param outputVarIds The output variable IDs, per the spec file passed to `sde`.
  */
 declare function initWasmModelAndBuffers(wasmModule: WasmModule, numInputs: number, outputVarIds: OutputVarId[]): WasmModelInitResult;
+/**
+ * @hidden This is not part of the public API; it is exposed here for use by
+ * the synchronous and asynchronous model runner implementations.
+ */
+declare function updateOutputIndices(indicesArray: Int32Array, outputVarSpecs: OutputVarSpec[]): void;
 
 /** Callback functions that are called when the input value is changed. */
 interface InputCallbacks {
@@ -136,7 +185,7 @@ interface InputValue {
 declare function createInputValue(varId: InputVarId, defaultValue: number, initialValue?: number): InputValue;
 
 /** Indicates the type of error encountered when parsing an outputs buffer. */
-declare type ParseError = 'invalid-point-count';
+type ParseError = 'invalid-point-count';
 /** A data point. */
 interface Point {
     /** The x value (typically a time value). */
@@ -186,6 +235,14 @@ declare class Outputs {
      * in performance testing tools.
      */
     runTimeInMillis: number;
+    /**
+     * The optional set of specs that dictate which variables from the model will be
+     * stored in this `Outputs` instance.  If undefined, the default set of outputs
+     * will be stored (as configured in `varIds`).
+     * @hidden This is not yet part of the public API; it is exposed here for use
+     * in experimental testing tools.
+     */
+    varSpecs?: OutputVarSpec[];
     /**
      * @param varIds The output variable identifiers.
      * @param startTime The start time for the model.
@@ -193,6 +250,14 @@ declare class Outputs {
      * @param saveFreq The frequency with which output values are saved (aka `SAVEPER`).
      */
     constructor(varIds: OutputVarId[], startTime: number, endTime: number, saveFreq?: number);
+    /**
+     * The optional set of specs that dictate which variables from the model will be
+     * stored in this `Outputs` instance.  If undefined, the default set of outputs
+     * will be stored (as configured in `varIds`).
+     * @hidden This is not yet part of the public API; it is exposed here for use
+     * in experimental testing tools.
+     */
+    setVarSpecs(varSpecs: OutputVarSpec[]): void;
     /**
      * Parse the given raw float buffer (produced by the model) and store the values
      * into this `Outputs` instance.
@@ -259,6 +324,23 @@ interface ModelRunner {
  */
 declare function createWasmModelRunner(wasmResult: WasmModelInitResult): ModelRunner;
 
+/**
+ * @hidden This is not yet part of the public API; it is exposed here for use
+ * in experimental testing tools.
+ */
+declare class ModelListing {
+    readonly varSpecs: Map<OutputVarId, OutputVarSpec>;
+    constructor(modelJsonString: string);
+    /**
+     * Create a new `Outputs` instance that uses the same start/end years as the given "normal"
+     * `Outputs` instance but is prepared for reading the specified internal variables from the model.
+     *
+     * @param normalOutputs The `Outputs` that is used to access normal output variables from the model.
+     * @param varIds The variable IDs to include with the new `Outputs` instance.
+     */
+    deriveOutputs(normalOutputs: Outputs, varIds: OutputVarId[]): Outputs;
+}
+
 /**
  * Return a timestamp that can be passed to `perfElapsed` for calculating the elapsed
  * time of an operation.
@@ -313,4 +395,4 @@ declare class ModelScheduler {
     private runWasmModelNow;
 }
 
-export { InputCallbacks, InputValue, InputVarId, ModelRunner, ModelScheduler, OutputVarId, Outputs, ParseError, Point, Series, WasmBuffer, WasmModel, WasmModelInitResult, WasmModule, createInputValue, createWasmModelRunner, initWasmModelAndBuffers, perfElapsed, perfNow };
+export { InputCallbacks, InputValue, InputVarId, ModelListing, ModelRunner, ModelScheduler, OutputVarId, OutputVarSpec, Outputs, ParseError, Point, Series, WasmBuffer, WasmModel, WasmModelInitResult, WasmModule, createFloat64WasmBuffer, createInputValue, createInt32WasmBuffer, createWasmModelRunner, initWasmModelAndBuffers, perfElapsed, perfNow, updateOutputIndices };

package/dist/index.js

@@ -1,19 +1,68 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+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 __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/wasm-model/wasm-buffer.ts
 var WasmBuffer = class {
-  constructor(wasmModule, numElements) {
+  /**
+   * @param wasmModule The `WasmModule` used to initialize the memory.
+   * @param byteOffset The byte offset within the wasm heap.
+   * @param heapArray The array view on the underlying heap buffer.
+   */
+  constructor(wasmModule, byteOffset, heapArray) {
     this.wasmModule = wasmModule;
-    const sizeOfFloat64 = 8;
-    const lengthInBytes = numElements * sizeOfFloat64;
-    this.byteOffset = wasmModule._malloc(lengthInBytes);
-    const float64Offset = this.byteOffset / sizeOfFloat64;
-    this.heapArray = wasmModule.HEAPF64.subarray(float64Offset, float64Offset + numElements);
+    this.byteOffset = byteOffset;
+    this.heapArray = heapArray;
   }
+  /**
+   * @return An `ArrType` view on the underlying heap buffer.
+   */
   getArrayView() {
     return this.heapArray;
   }
+  /**
+   * @return The raw address of the underlying heap buffer.
+   * @hidden This is intended for use by `WasmModel` only.
+   */
   getAddress() {
     return this.byteOffset;
   }
+  /**
+   * Dispose the buffer by freeing the allocated heap memory.
+   */
   dispose() {
     if (this.heapArray) {
       this.wasmModule._free(this.byteOffset);
@@ -22,9 +71,29 @@ var WasmBuffer = class {
     }
   }
 };
+function createInt32WasmBuffer(wasmModule, numElements) {
+  const elemSizeInBytes = 4;
+  const lengthInBytes = numElements * elemSizeInBytes;
+  const byteOffset = wasmModule._malloc(lengthInBytes);
+  const elemOffset = byteOffset / elemSizeInBytes;
+  const heapArray = wasmModule.HEAP32.subarray(elemOffset, elemOffset + numElements);
+  return new WasmBuffer(wasmModule, byteOffset, heapArray);
+}
+function createFloat64WasmBuffer(wasmModule, numElements) {
+  const elemSizeInBytes = 8;
+  const lengthInBytes = numElements * elemSizeInBytes;
+  const byteOffset = wasmModule._malloc(lengthInBytes);
+  const elemOffset = byteOffset / elemSizeInBytes;
+  const heapArray = wasmModule.HEAPF64.subarray(elemOffset, elemOffset + numElements);
+  return new WasmBuffer(wasmModule, byteOffset, heapArray);
+}
 
 // src/wasm-model/wasm-model.ts
+var indicesPerOutput = 4;
 var WasmModel = class {
+  /**
+   * @param wasmModule The `WasmModule` that provides access to the native functions.
+   */
   constructor(wasmModule) {
     function getNumberValue(funcName) {
       const wasmGetValue = wasmModule.cwrap(funcName, "number", []);
@@ -33,24 +102,59 @@ var WasmModel = class {
     this.startTime = getNumberValue("getInitialTime");
     this.endTime = getNumberValue("getFinalTime");
     this.saveFreq = getNumberValue("getSaveper");
+    try {
+      this.maxOutputIndices = getNumberValue("getMaxOutputIndices");
+    } catch (e) {
+      this.maxOutputIndices = 0;
+    }
     this.numSavePoints = Math.round((this.endTime - this.startTime) / this.saveFreq) + 1;
-    this.wasmRunModel = wasmModule.cwrap("runModelWithBuffers", null, ["number", "number"]);
+    this.wasmRunModel = wasmModule.cwrap("runModelWithBuffers", null, ["number", "number", "number"]);
   }
-  runModel(inputs, outputs) {
-    this.wasmRunModel(inputs.getAddress(), outputs.getAddress());
+  /**
+   * Run the model, using inputs from the `inputs` buffer, and writing outputs into
+   * the `outputs` buffer.
+   *
+   * @param inputs The buffer containing inputs in the order expected by the model.
+   * @param outputs The buffer into which the model will store output values.
+   * @param outputIndices The buffer used to control which variables are written to `outputs`.
+   */
+  runModel(inputs, outputs, outputIndices) {
+    this.wasmRunModel(inputs.getAddress(), outputs.getAddress(), (outputIndices == null ? void 0 : outputIndices.getAddress()) || 0);
   }
 };
 function initWasmModelAndBuffers(wasmModule, numInputs, outputVarIds) {
   const model = new WasmModel(wasmModule);
-  const inputsBuffer = new WasmBuffer(wasmModule, numInputs);
-  const outputsBuffer = new WasmBuffer(wasmModule, outputVarIds.length * model.numSavePoints);
+  const inputsBuffer = createFloat64WasmBuffer(wasmModule, numInputs);
+  const outputVarCount = Math.max(outputVarIds.length, model.maxOutputIndices);
+  const outputsBuffer = createFloat64WasmBuffer(wasmModule, outputVarCount * model.numSavePoints);
+  let outputIndicesBuffer;
+  if (model.maxOutputIndices > 0) {
+    outputIndicesBuffer = createInt32WasmBuffer(wasmModule, model.maxOutputIndices * indicesPerOutput);
+  }
   return {
     model,
     inputsBuffer,
     outputsBuffer,
+    outputIndicesBuffer,
     outputVarIds
   };
 }
+function updateOutputIndices(indicesArray, outputVarSpecs) {
+  var _a;
+  if (indicesArray.length < outputVarSpecs.length * indicesPerOutput) {
+    throw new Error("Length of indicesArray must be large enough to accommodate the given outputVarSpecs");
+  }
+  let offset = 0;
+  for (const outputVarSpec of outputVarSpecs) {
+    const subCount = ((_a = outputVarSpec.subscriptIndices) == null ? void 0 : _a.length) || 0;
+    indicesArray[offset + 0] = outputVarSpec.varIndex;
+    indicesArray[offset + 1] = subCount > 0 ? outputVarSpec.subscriptIndices[0] : 0;
+    indicesArray[offset + 2] = subCount > 1 ? outputVarSpec.subscriptIndices[1] : 0;
+    indicesArray[offset + 3] = subCount > 2 ? outputVarSpec.subscriptIndices[2] : 0;
+    offset += indicesPerOutput;
+  }
+  indicesArray.fill(0, offset);
+}
 
 // src/model-runner/inputs.ts
 function createInputValue(varId, defaultValue, initialValue) {
@@ -74,21 +178,43 @@ function createInputValue(varId, defaultValue, initialValue) {
 
 // src/model-runner/outputs.ts
 import { ok, err } from "neverthrow";
-var Series = class {
+var Series = class _Series {
+  /**
+   * @param varId The ID for the output variable (as used by SDEverywhere).
+   * @param points The data points for the variable, one point per time increment.
+   */
   constructor(varId, points) {
     this.varId = varId;
     this.points = points;
   }
+  /**
+   * Return the Y value at the given time.  Note that this does not attempt to interpolate
+   * if there is no data point defined for the given time and will return undefined in
+   * that case.
+   *
+   * @param time The x (time) value.
+   * @return The y value for the given time, or undefined if there is no data point defined
+   * for the given time.
+   */
   getValueAtTime(time) {
     var _a;
     return (_a = this.points.find((p) => p.x === time)) == null ? void 0 : _a.y;
   }
+  /**
+   * Create a new `Series` instance that is a copy of this one.
+   */
   copy() {
-    const pointsCopy = this.points.map((p) => ({ ...p }));
-    return new Series(this.varId, pointsCopy);
+    const pointsCopy = this.points.map((p) => __spreadValues({}, p));
+    return new _Series(this.varId, pointsCopy);
   }
 };
 var Outputs = class {
+  /**
+   * @param varIds The output variable identifiers.
+   * @param startTime The start time for the model.
+   * @param endTime The end time for the model.
+   * @param saveFreq The frequency with which output values are saved (aka `SAVEPER`).
+   */
   constructor(varIds, startTime, endTime, saveFreq = 1) {
     this.varIds = varIds;
     this.startTime = startTime;
@@ -105,6 +231,32 @@ var Outputs = class {
       this.varSeries[i] = new Series(varId, points);
     }
   }
+  /**
+   * The optional set of specs that dictate which variables from the model will be
+   * stored in this `Outputs` instance.  If undefined, the default set of outputs
+   * will be stored (as configured in `varIds`).
+   * @hidden This is not yet part of the public API; it is exposed here for use
+   * in experimental testing tools.
+   */
+  setVarSpecs(varSpecs) {
+    if (varSpecs.length !== this.varIds.length) {
+      throw new Error("Length of output varSpecs must match that of varIds");
+    }
+    this.varSpecs = varSpecs;
+  }
+  /**
+   * Parse the given raw float buffer (produced by the model) and store the values
+   * into this `Outputs` instance.
+   *
+   * Note that the length of `outputsBuffer` must be greater than or equal to
+   * the capacity of this `Outputs` instance.  The `Outputs` instance is allowed
+   * to be smaller to support the case where you want to extract a subset of
+   * the time range in the buffer produced by the model.
+   *
+   * @param outputsBuffer The raw outputs buffer produced by the model.
+   * @param rowLength The number of elements per row (one element per save point).
+   * @return An `ok` result if the buffer is valid, otherwise an `err` result.
+   */
   updateFromBuffer(outputsBuffer, rowLength) {
     const result = parseOutputsBuffer(outputsBuffer, rowLength, this);
     if (result.isOk()) {
@@ -113,6 +265,11 @@ var Outputs = class {
       return err(result.error);
     }
   }
+  /**
+   * Return the series for the given output variable.
+   *
+   * @param varId The ID of the output variable (as used by SDEverywhere).
+   */
   getSeriesForVar(varId) {
     const seriesIndex = this.varIds.indexOf(varId);
     if (seriesIndex >= 0) {
@@ -175,6 +332,8 @@ function createWasmModelRunner(wasmResult) {
   const inputsArray = inputsBuffer.getArrayView();
   const outputsBuffer = wasmResult.outputsBuffer;
   const outputsArray = outputsBuffer.getArrayView();
+  const outputIndicesBuffer = wasmResult.outputIndicesBuffer;
+  const outputIndicesArray = outputIndicesBuffer == null ? void 0 : outputIndicesBuffer.getArrayView();
   const rowLength = wasmModel.numSavePoints;
   let terminated = false;
   const runModelSync = (inputs, outputs) => {
@@ -182,8 +341,16 @@ function createWasmModelRunner(wasmResult) {
     for (const input of inputs) {
       inputsArray[i++] = input.get();
     }
+    const outputSpecs = outputs.varSpecs;
+    let useIndices;
+    if (outputIndicesArray && outputSpecs !== void 0 && outputSpecs.length > 0) {
+      updateOutputIndices(outputIndicesArray, outputSpecs);
+      useIndices = true;
+    } else {
+      useIndices = false;
+    }
     const t0 = perfNow();
-    wasmModel.runModel(inputsBuffer, outputsBuffer);
+    wasmModel.runModel(inputsBuffer, outputsBuffer, useIndices ? outputIndicesBuffer : void 0);
     outputs.runTimeInMillis = perfElapsed(t0);
     outputs.updateFromBuffer(outputsArray, rowLength);
     return outputs;
@@ -213,13 +380,121 @@ function createWasmModelRunner(wasmResult) {
   };
 }
 
+// src/model-runner/model-listing.ts
+var ModelListing = class {
+  constructor(modelJsonString) {
+    this.varSpecs = /* @__PURE__ */ new Map();
+    const modelJson = JSON.parse(modelJsonString);
+    const dimensions = /* @__PURE__ */ new Map();
+    for (const dimInfo of modelJson.dimensions) {
+      const dimId = dimInfo.name;
+      const subscripts = [];
+      for (let i = 0; i < dimInfo.value.length; i++) {
+        subscripts.push({
+          id: dimInfo.value[i],
+          // name: dimInfo.modelValue[i]
+          index: i
+        });
+      }
+      dimensions.set(dimId, {
+        id: dimId,
+        // name: dimInfo.modelName,
+        subscripts
+      });
+    }
+    function dimensionForId(dimId) {
+      const dim = dimensions.get(dimId);
+      if (dim === void 0) {
+        throw new Error(`No dimension info found for id=${dimId}`);
+      }
+      return dim;
+    }
+    const baseVarIds = /* @__PURE__ */ new Set();
+    for (const v of modelJson.variables) {
+      const baseVarId = varIdWithoutSubscripts(v.varName);
+      if (!baseVarIds.has(baseVarId)) {
+        const dimIds = v.families || [];
+        const dimensions2 = dimIds.map(dimensionForId);
+        if (dimensions2.length > 0) {
+          if (dimensions2.length > 3) {
+            throw new Error("Variables with more than 3 dimensions not currently supported");
+          }
+          const dimSubs = [];
+          for (const dim of dimensions2) {
+            dimSubs.push(dim.subscripts);
+          }
+          const combos = cartesianProductOf(dimSubs);
+          for (const combo of combos) {
+            const subs = combo.map((sub) => sub.id).join(",");
+            const subIndices = combo.map((sub) => sub.index);
+            const fullVarId = `${baseVarId}[${subs}]`;
+            this.varSpecs.set(fullVarId, {
+              varIndex: v.varIndex,
+              subscriptIndices: subIndices
+            });
+          }
+        } else {
+          this.varSpecs.set(baseVarId, {
+            varIndex: v.varIndex
+          });
+        }
+        baseVarIds.add(baseVarId);
+      }
+    }
+  }
+  /**
+   * Create a new `Outputs` instance that uses the same start/end years as the given "normal"
+   * `Outputs` instance but is prepared for reading the specified internal variables from the model.
+   *
+   * @param normalOutputs The `Outputs` that is used to access normal output variables from the model.
+   * @param varIds The variable IDs to include with the new `Outputs` instance.
+   */
+  deriveOutputs(normalOutputs, varIds) {
+    const varSpecs = [];
+    for (const varId of varIds) {
+      const varSpec = this.varSpecs.get(varId);
+      if (varSpec !== void 0) {
+        varSpecs.push(varSpec);
+      } else {
+        console.warn(`WARNING: No output var spec found for id=${varId}`);
+      }
+    }
+    const newOutputs = new Outputs(varIds, normalOutputs.startTime, normalOutputs.endTime, normalOutputs.saveFreq);
+    newOutputs.varSpecs = varSpecs;
+    return newOutputs;
+  }
+};
+function varIdWithoutSubscripts(fullVarId) {
+  const bracketIndex = fullVarId.indexOf("[");
+  if (bracketIndex >= 0) {
+    return fullVarId.substring(0, bracketIndex);
+  } else {
+    return fullVarId;
+  }
+}
+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/model-scheduler/model-scheduler.ts
 var ModelScheduler = class {
+  /**
+   * @param runner The model runner.
+   * @param userInputs The input values, in the same order as in the spec file passed to `sde`.
+   * @param outputs The structure into which the model outputs will be stored.
+   */
   constructor(runner, userInputs, outputs) {
     this.runner = runner;
     this.userInputs = userInputs;
     this.outputs = outputs;
+    /** Whether a model run has been scheduled. */
     this.runNeeded = false;
+    /** Whether a model run is in progress. */
     this.runInProgress = false;
     const afterSet = () => {
       this.runWasmModelIfNeeded();
@@ -232,6 +507,10 @@ var ModelScheduler = class {
       this.currentInputs.push(createSimpleInputValue(userInput.varId));
     }
   }
+  /**
+   * Schedule a wasm model run (if not already pending).  When the run is
+   * complete, save the outputs and call the `onOutputsChanged` callback.
+   */
   runWasmModelIfNeeded() {
     this.runNeeded = true;
     if (this.runInProgress) {
@@ -243,26 +522,31 @@ var ModelScheduler = class {
       }, 0);
     }
   }
-  async runWasmModelNow() {
-    var _a;
-    for (let i = 0; i < this.userInputs.length; i++) {
-      this.currentInputs[i].set(this.userInputs[i].get());
-    }
-    try {
-      this.outputs = await this.runner.runModel(this.currentInputs, this.outputs);
-      (_a = this.onOutputsChanged) == null ? void 0 : _a.call(this, this.outputs);
-    } catch (e) {
-      console.error(`ERROR: Failed to run model: ${e.message}`);
-    }
-    if (this.runNeeded) {
-      this.runNeeded = false;
-      setTimeout(() => {
-        this.runWasmModelNow();
-      }, 0);
-    } else {
-      this.runNeeded = false;
-      this.runInProgress = false;
-    }
+  /**
+   * Run the wasm model asynchronously using the current set of input values.
+   */
+  runWasmModelNow() {
+    return __async(this, null, function* () {
+      var _a;
+      for (let i = 0; i < this.userInputs.length; i++) {
+        this.currentInputs[i].set(this.userInputs[i].get());
+      }
+      try {
+        this.outputs = yield this.runner.runModel(this.currentInputs, this.outputs);
+        (_a = this.onOutputsChanged) == null ? void 0 : _a.call(this, this.outputs);
+      } catch (e) {
+        console.error(`ERROR: Failed to run model: ${e.message}`);
+      }
+      if (this.runNeeded) {
+        this.runNeeded = false;
+        setTimeout(() => {
+          this.runWasmModelNow();
+        }, 0);
+      } else {
+        this.runNeeded = false;
+        this.runInProgress = false;
+      }
+    });
   }
 };
 function createSimpleInputValue(varId) {
@@ -279,15 +563,19 @@ function createSimpleInputValue(varId) {
   return { varId, get, set, reset, callbacks: {} };
 }
 export {
+  ModelListing,
   ModelScheduler,
   Outputs,
   Series,
   WasmBuffer,
   WasmModel,
+  createFloat64WasmBuffer,
   createInputValue,
+  createInt32WasmBuffer,
   createWasmModelRunner,
   initWasmModelAndBuffers,
   perfElapsed,
-  perfNow
+  perfNow,
+  updateOutputIndices
 };
 //# sourceMappingURL=index.js.map