@sdeverywhere/runtime 0.2.6 → 0.2.8

package/dist/index.cjs

@@ -51,24 +51,29 @@ var __async = (__this, __arguments, generator) => {
 };
 
 // src/index.ts
-var src_exports = {};
-__export(src_exports, {
+var index_exports = {};
+__export(index_exports, {
   BufferedRunModelParams: () => BufferedRunModelParams,
   MockJsModel: () => MockJsModel,
   MockWasmModule: () => MockWasmModule,
   ModelListing: () => ModelListing,
   ModelScheduler: () => ModelScheduler,
+  MultiContextModelScheduler: () => MultiContextModelScheduler,
   Outputs: () => Outputs,
   ReferencedRunModelParams: () => ReferencedRunModelParams,
   Series: () => Series,
+  createConstantDef: () => createConstantDef,
   createInputValue: () => createInputValue,
   createLookupDef: () => createLookupDef,
   createRunnableModel: () => createRunnableModel,
   createSynchronousModelRunner: () => createSynchronousModelRunner,
+  decodeConstants: () => decodeConstants,
   decodeLookups: () => decodeLookups,
+  encodeConstants: () => encodeConstants,
   encodeLookups: () => encodeLookups,
   encodeVarIndices: () => encodeVarIndices,
   execJsModel: () => execJsModel,
+  getEncodedConstantBufferLengths: () => getEncodedConstantBufferLengths,
   getEncodedLookupBufferLengths: () => getEncodedLookupBufferLengths,
   getEncodedVarIndicesLength: () => getEncodedVarIndicesLength,
   getJsModelFunctions: () => getJsModelFunctions,
@@ -77,7 +82,7 @@ __export(src_exports, {
   perfElapsed: () => perfElapsed,
   perfNow: () => perfNow
 });
-module.exports = __toCommonJS(src_exports);
+module.exports = __toCommonJS(index_exports);
 
 // src/_shared/inputs.ts
 function createInputValue(varId, defaultValue, initialValue) {
@@ -250,6 +255,66 @@ function encodeVarIndices(varSpecs, indicesArray) {
     }
   }
 }
+function getEncodedConstantBufferLengths(constantDefs) {
+  var _a;
+  let constantIndicesLength = 1;
+  let constantsLength = 0;
+  for (const constantDef of constantDefs) {
+    const varSpec = constantDef.varRef.varSpec;
+    if (varSpec === void 0) {
+      throw new Error("Cannot compute constant buffer lengths until all constant var specs are defined");
+    }
+    constantIndicesLength += 2;
+    const subCount = ((_a = varSpec.subscriptIndices) == null ? void 0 : _a.length) || 0;
+    constantIndicesLength += subCount;
+    constantsLength += 1;
+  }
+  return {
+    constantIndicesLength,
+    constantsLength
+  };
+}
+function encodeConstants(constantDefs, constantIndicesArray, constantsArray) {
+  let ci = 0;
+  constantIndicesArray[ci++] = constantDefs.length;
+  let constantDataOffset = 0;
+  for (const constantDef of constantDefs) {
+    const varSpec = constantDef.varRef.varSpec;
+    constantIndicesArray[ci++] = varSpec.varIndex;
+    const subs = varSpec.subscriptIndices;
+    const subCount = (subs == null ? void 0 : subs.length) || 0;
+    constantIndicesArray[ci++] = subCount;
+    for (let i = 0; i < subCount; i++) {
+      constantIndicesArray[ci++] = subs[i];
+    }
+    constantsArray[constantDataOffset++] = constantDef.value;
+  }
+}
+function decodeConstants(constantIndicesArray, constantsArray) {
+  const constantDefs = [];
+  let ci = 0;
+  const constantCount = constantIndicesArray[ci++];
+  for (let i = 0; i < constantCount; i++) {
+    const varIndex = constantIndicesArray[ci++];
+    const subCount = constantIndicesArray[ci++];
+    const subscriptIndices = subCount > 0 ? Array(subCount) : void 0;
+    for (let subIndex = 0; subIndex < subCount; subIndex++) {
+      subscriptIndices[subIndex] = constantIndicesArray[ci++];
+    }
+    const varSpec = {
+      varIndex,
+      subscriptIndices
+    };
+    const value = constantsArray[i];
+    constantDefs.push({
+      varRef: {
+        varSpec
+      },
+      value
+    });
+  }
+  return constantDefs;
+}
 function getEncodedLookupBufferLengths(lookupDefs) {
   var _a, _b;
   let lookupIndicesLength = 1;
@@ -331,6 +396,14 @@ function decodeLookups(lookupIndicesArray, lookupsArray) {
   return lookupDefs;
 }
 
+// src/_shared/constant-def.ts
+function createConstantDef(varRef, value) {
+  return {
+    varRef,
+    value
+  };
+}
+
 // src/_shared/lookup-def.ts
 function createLookupDef(varRef, points) {
   let flatPoints;
@@ -501,7 +574,7 @@ function resolveVarRef(listing, varRef, varKind) {
 }
 
 // src/runnable-model/buffered-run-model-params.ts
-var headerLengthInElements = 16;
+var headerLengthInElements = 20;
 var extrasLengthInElements = 1;
 var Int32Section = class {
   constructor() {
@@ -546,6 +619,10 @@ var BufferedRunModelParams = class {
     this.outputs = new Float64Section();
     /** The output indices section of the `encoded` buffer. */
     this.outputIndices = new Int32Section();
+    /** The constant values section of the `encoded` buffer. */
+    this.constants = new Float64Section();
+    /** The constant indices section of the `encoded` buffer. */
+    this.constantIndices = new Int32Section();
     /** The lookup data section of the `encoded` buffer. */
     this.lookups = new Float64Section();
     /** The lookup indices section of the `encoded` buffer. */
@@ -613,6 +690,13 @@ var BufferedRunModelParams = class {
     }
   }
   // from RunModelParams interface
+  getConstants() {
+    if (this.constantIndices.lengthInElements === 0) {
+      return void 0;
+    }
+    return decodeConstants(this.constantIndices.view, this.constants.view);
+  }
+  // from RunModelParams interface
   getLookups() {
     if (this.lookupIndices.lengthInElements === 0) {
       return void 0;
@@ -657,6 +741,19 @@ var BufferedRunModelParams = class {
     } else {
       outputIndicesLengthInElements = 0;
     }
+    let constantsLengthInElements;
+    let constantIndicesLengthInElements;
+    if ((options == null ? void 0 : options.constants) !== void 0 && options.constants.length > 0) {
+      for (const constantDef of options.constants) {
+        resolveVarRef(this.listing, constantDef.varRef, "constant");
+      }
+      const encodedLengths = getEncodedConstantBufferLengths(options.constants);
+      constantsLengthInElements = encodedLengths.constantsLength;
+      constantIndicesLengthInElements = encodedLengths.constantIndicesLength;
+    } else {
+      constantsLengthInElements = 0;
+      constantIndicesLengthInElements = 0;
+    }
     let lookupsLengthInElements;
     let lookupIndicesLengthInElements;
     if ((options == null ? void 0 : options.lookups) !== void 0 && options.lookups.length > 0) {
@@ -684,6 +781,8 @@ var BufferedRunModelParams = class {
     const inputsOffsetInBytes = section("float64", inputsLengthInElements);
     const outputsOffsetInBytes = section("float64", outputsLengthInElements);
     const outputIndicesOffsetInBytes = section("int32", outputIndicesLengthInElements);
+    const constantsOffsetInBytes = section("float64", constantsLengthInElements);
+    const constantIndicesOffsetInBytes = section("int32", constantIndicesLengthInElements);
     const lookupsOffsetInBytes = section("float64", lookupsLengthInElements);
     const lookupIndicesOffsetInBytes = section("int32", lookupIndicesLengthInElements);
     const requiredLengthInBytes = byteOffset;
@@ -702,6 +801,10 @@ var BufferedRunModelParams = class {
     headerView[headerIndex++] = outputsLengthInElements;
     headerView[headerIndex++] = outputIndicesOffsetInBytes;
     headerView[headerIndex++] = outputIndicesLengthInElements;
+    headerView[headerIndex++] = constantsOffsetInBytes;
+    headerView[headerIndex++] = constantsLengthInElements;
+    headerView[headerIndex++] = constantIndicesOffsetInBytes;
+    headerView[headerIndex++] = constantIndicesLengthInElements;
     headerView[headerIndex++] = lookupsOffsetInBytes;
     headerView[headerIndex++] = lookupsLengthInElements;
     headerView[headerIndex++] = lookupIndicesOffsetInBytes;
@@ -710,6 +813,8 @@ var BufferedRunModelParams = class {
     this.extras.update(this.encoded, extrasOffsetInBytes, extrasLengthInElements);
     this.outputs.update(this.encoded, outputsOffsetInBytes, outputsLengthInElements);
     this.outputIndices.update(this.encoded, outputIndicesOffsetInBytes, outputIndicesLengthInElements);
+    this.constants.update(this.encoded, constantsOffsetInBytes, constantsLengthInElements);
+    this.constantIndices.update(this.encoded, constantIndicesOffsetInBytes, constantIndicesLengthInElements);
     this.lookups.update(this.encoded, lookupsOffsetInBytes, lookupsLengthInElements);
     this.lookupIndices.update(this.encoded, lookupIndicesOffsetInBytes, lookupIndicesLengthInElements);
     const inputsView = this.inputs.view;
@@ -724,6 +829,9 @@ var BufferedRunModelParams = class {
     if (this.outputIndices.view) {
       encodeVarIndices(outputVarSpecs, this.outputIndices.view);
     }
+    if (constantIndicesLengthInElements > 0) {
+      encodeConstants(options.constants, this.constantIndices.view, this.constants.view);
+    }
     if (lookupIndicesLengthInElements > 0) {
       encodeLookups(options.lookups, this.lookupIndices.view, this.lookups.view);
     }
@@ -752,6 +860,10 @@ var BufferedRunModelParams = class {
     const outputsLengthInElements = headerView[headerIndex++];
     const outputIndicesOffsetInBytes = headerView[headerIndex++];
     const outputIndicesLengthInElements = headerView[headerIndex++];
+    const constantsOffsetInBytes = headerView[headerIndex++];
+    const constantsLengthInElements = headerView[headerIndex++];
+    const constantIndicesOffsetInBytes = headerView[headerIndex++];
+    const constantIndicesLengthInElements = headerView[headerIndex++];
     const lookupsOffsetInBytes = headerView[headerIndex++];
     const lookupsLengthInElements = headerView[headerIndex++];
     const lookupIndicesOffsetInBytes = headerView[headerIndex++];
@@ -760,9 +872,11 @@ var BufferedRunModelParams = class {
     const inputsLengthInBytes = inputsLengthInElements * Float64Array.BYTES_PER_ELEMENT;
     const outputsLengthInBytes = outputsLengthInElements * Float64Array.BYTES_PER_ELEMENT;
     const outputIndicesLengthInBytes = outputIndicesLengthInElements * Int32Array.BYTES_PER_ELEMENT;
+    const constantsLengthInBytes = constantsLengthInElements * Float64Array.BYTES_PER_ELEMENT;
+    const constantIndicesLengthInBytes = constantIndicesLengthInElements * Int32Array.BYTES_PER_ELEMENT;
     const lookupsLengthInBytes = lookupsLengthInElements * Float64Array.BYTES_PER_ELEMENT;
     const lookupIndicesLengthInBytes = lookupIndicesLengthInElements * Int32Array.BYTES_PER_ELEMENT;
-    const requiredLengthInBytes = headerLengthInBytes + extrasLengthInBytes + inputsLengthInBytes + outputsLengthInBytes + outputIndicesLengthInBytes + lookupsLengthInBytes + lookupIndicesLengthInBytes;
+    const requiredLengthInBytes = headerLengthInBytes + extrasLengthInBytes + inputsLengthInBytes + outputsLengthInBytes + outputIndicesLengthInBytes + constantsLengthInBytes + constantIndicesLengthInBytes + lookupsLengthInBytes + lookupIndicesLengthInBytes;
     if (buffer.byteLength < requiredLengthInBytes) {
       throw new Error("Buffer must be long enough to contain sections declared in header");
     }
@@ -770,6 +884,8 @@ var BufferedRunModelParams = class {
     this.inputs.update(this.encoded, inputsOffsetInBytes, inputsLengthInElements);
     this.outputs.update(this.encoded, outputsOffsetInBytes, outputsLengthInElements);
     this.outputIndices.update(this.encoded, outputIndicesOffsetInBytes, outputIndicesLengthInElements);
+    this.constants.update(this.encoded, constantsOffsetInBytes, constantsLengthInElements);
+    this.constantIndices.update(this.encoded, constantIndicesOffsetInBytes, constantIndicesLengthInElements);
     this.lookups.update(this.encoded, lookupsOffsetInBytes, lookupsLengthInElements);
     this.lookupIndices.update(this.encoded, lookupIndicesOffsetInBytes, lookupIndicesLengthInElements);
   }
@@ -846,6 +962,14 @@ var ReferencedRunModelParams = class {
     }
   }
   // from RunModelParams interface
+  getConstants() {
+    if (this.constants !== void 0 && this.constants.length > 0) {
+      return this.constants;
+    } else {
+      return void 0;
+    }
+  }
+  // from RunModelParams interface
   getLookups() {
     if (this.lookups !== void 0 && this.lookups.length > 0) {
       return this.lookups;
@@ -875,7 +999,13 @@ var ReferencedRunModelParams = class {
     this.inputs = inputs;
     this.outputs = outputs;
     this.outputsLengthInElements = outputs.varIds.length * outputs.seriesLength;
+    this.constants = options == null ? void 0 : options.constants;
     this.lookups = options == null ? void 0 : options.lookups;
+    if (this.constants) {
+      for (const constantDef of this.constants) {
+        resolveVarRef(this.listing, constantDef.varRef, "constant");
+      }
+    }
     if (this.lookups) {
       for (const lookupDef of this.lookups) {
         resolveVarRef(this.listing, lookupDef.varRef, "lookup");
@@ -1355,6 +1485,7 @@ var BaseRunnableModel = class {
     const t0 = perfNow();
     (_a = this.onRunModel) == null ? void 0 : _a.call(this, inputsArray, outputsArray, {
       outputIndices: outputIndicesArray,
+      constants: params.getConstants(),
       lookups: params.getLookups()
     });
     const elapsed = perfElapsed(t0);
@@ -1396,13 +1527,14 @@ function initJsModel(model) {
         inputs,
         outputs,
         options == null ? void 0 : options.outputIndices,
+        options == null ? void 0 : options.constants,
         options == null ? void 0 : options.lookups,
         void 0
       );
     }
   });
 }
-function runJsModel(model, initialTime, finalTime, timeStep, saveFreq, numSavePoints, inputs, outputs, outputIndices, lookups, stopAfterTime) {
+function runJsModel(model, initialTime, finalTime, timeStep, saveFreq, numSavePoints, inputs, outputs, outputIndices, constants, lookups, stopAfterTime) {
   let time = initialTime;
   model.setTime(time);
   const fnContext = {
@@ -1411,6 +1543,11 @@ function runJsModel(model, initialTime, finalTime, timeStep, saveFreq, numSavePo
   };
   model.getModelFunctions().setContext(fnContext);
   model.initConstants();
+  if (constants !== void 0) {
+    for (const constantDef of constants) {
+      model.setConstant(constantDef.varRef.varSpec, constantDef.value);
+    }
+  }
   if (lookups !== void 0) {
     for (const lookupDef of lookups) {
       model.setLookup(lookupDef.varRef.varSpec, lookupDef.points);
@@ -1497,6 +1634,7 @@ var MockJsModel = class {
     // from JsModel interface
     this.kind = "js";
     this.vars = /* @__PURE__ */ new Map();
+    this.constants = /* @__PURE__ */ new Map();
     this.lookups = /* @__PURE__ */ new Map();
     this.outputVarIds = options.outputVarIds;
     this.outputVarNames = options.outputVarIds;
@@ -1549,6 +1687,14 @@ var MockJsModel = class {
   setInputs() {
   }
   // from JsModel interface
+  setConstant(varSpec, value) {
+    const varId = this.varIdForSpec(varSpec);
+    if (varId === void 0) {
+      throw new Error(`No constant variable found for spec ${varSpec}`);
+    }
+    this.constants.set(varId, value);
+  }
+  // from JsModel interface
   setLookup(varSpec, points) {
     const varId = this.varIdForSpec(varSpec);
     if (varId === void 0) {
@@ -1573,6 +1719,7 @@ var MockJsModel = class {
   }
   // from JsModel interface
   initConstants() {
+    this.constants.clear();
   }
   // from JsModel interface
   initLevels() {
@@ -1580,7 +1727,7 @@ var MockJsModel = class {
   // from JsModel interface
   evalAux() {
     var _a;
-    (_a = this.onEvalAux) == null ? void 0 : _a.call(this, this.vars, this.lookups);
+    (_a = this.onEvalAux) == null ? void 0 : _a.call(this, this.vars, this.constants.size > 0 ? this.constants : void 0, this.lookups);
   }
   // from JsModel interface
   evalLevels() {
@@ -1663,11 +1810,18 @@ var WasmModel = class {
     this.outputVarIds = wasmModule.outputVarIds;
     this.modelListing = wasmModule.modelListing;
     this.wasmSetLookup = wasmModule.cwrap("setLookup", null, ["number", "number", "number", "number"]);
-    this.wasmRunModel = wasmModule.cwrap("runModelWithBuffers", null, ["number", "number", "number"]);
+    this.wasmRunModel = wasmModule.cwrap("runModelWithBuffers", null, [
+      "number",
+      "number",
+      "number",
+      "number",
+      "number",
+      "number"
+    ]);
   }
   // from RunnableModel interface
   runModel(params) {
-    var _a, _b, _c, _d, _e, _f, _g;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
     const lookups = params.getLookups();
     if (lookups !== void 0) {
       for (const lookupDef of lookups) {
@@ -1703,7 +1857,48 @@ var WasmModel = class {
         this.wasmSetLookup(varIndex, subIndicesAddress, pointsAddress, numPoints);
       }
     }
-    params.copyInputs((_d = this.inputsBuffer) == null ? void 0 : _d.getArrayView(), (numElements) => {
+    let constantIndicesBuffer;
+    let constantValuesBuffer;
+    const constants = params.getConstants();
+    if (constants !== void 0 && constants.length > 0) {
+      let totalIndicesSize = 1;
+      for (const constantDef of constants) {
+        const numSubElements = ((_d = constantDef.varRef.varSpec.subscriptIndices) == null ? void 0 : _d.length) || 0;
+        totalIndicesSize += 2 + numSubElements;
+      }
+      if (this.constantIndicesBuffer === void 0 || this.constantIndicesBuffer.numElements < totalIndicesSize) {
+        (_e = this.constantIndicesBuffer) == null ? void 0 : _e.dispose();
+        this.constantIndicesBuffer = createInt32WasmBuffer(this.wasmModule, totalIndicesSize);
+      }
+      const numConstants = constants.length;
+      if (this.constantValuesBuffer === void 0 || this.constantValuesBuffer.numElements < numConstants) {
+        (_f = this.constantValuesBuffer) == null ? void 0 : _f.dispose();
+        this.constantValuesBuffer = createFloat64WasmBuffer(this.wasmModule, numConstants);
+      }
+      const indicesView = this.constantIndicesBuffer.getArrayView();
+      const valuesView = this.constantValuesBuffer.getArrayView();
+      let indicesOffset = 0;
+      let valuesOffset = 0;
+      indicesView[indicesOffset++] = numConstants;
+      for (const constantDef of constants) {
+        const varSpec = constantDef.varRef.varSpec;
+        const numSubElements = ((_g = varSpec.subscriptIndices) == null ? void 0 : _g.length) || 0;
+        indicesView[indicesOffset++] = varSpec.varIndex;
+        indicesView[indicesOffset++] = numSubElements;
+        if (numSubElements > 0) {
+          for (let i = 0; i < numSubElements; i++) {
+            indicesView[indicesOffset++] = varSpec.subscriptIndices[i];
+          }
+        }
+        valuesView[valuesOffset++] = constantDef.value;
+      }
+      constantIndicesBuffer = this.constantIndicesBuffer;
+      constantValuesBuffer = this.constantValuesBuffer;
+    } else {
+      constantIndicesBuffer = void 0;
+      constantValuesBuffer = void 0;
+    }
+    params.copyInputs((_h = this.inputsBuffer) == null ? void 0 : _h.getArrayView(), (numElements) => {
       var _a2;
       (_a2 = this.inputsBuffer) == null ? void 0 : _a2.dispose();
       this.inputsBuffer = createFloat64WasmBuffer(this.wasmModule, numElements);
@@ -1711,7 +1906,7 @@ var WasmModel = class {
     });
     let outputIndicesBuffer;
     if (params.getOutputIndicesLength() > 0) {
-      params.copyOutputIndices((_e = this.outputIndicesBuffer) == null ? void 0 : _e.getArrayView(), (numElements) => {
+      params.copyOutputIndices((_i = this.outputIndicesBuffer) == null ? void 0 : _i.getArrayView(), (numElements) => {
         var _a2;
         (_a2 = this.outputIndicesBuffer) == null ? void 0 : _a2.dispose();
         this.outputIndicesBuffer = createInt32WasmBuffer(this.wasmModule, numElements);
@@ -1723,14 +1918,19 @@ var WasmModel = class {
     }
     const outputsLengthInElements = params.getOutputsLength();
     if (this.outputsBuffer === void 0 || this.outputsBuffer.numElements < outputsLengthInElements) {
-      (_f = this.outputsBuffer) == null ? void 0 : _f.dispose();
+      (_j = this.outputsBuffer) == null ? void 0 : _j.dispose();
       this.outputsBuffer = createFloat64WasmBuffer(this.wasmModule, outputsLengthInElements);
     }
     const t0 = perfNow();
     this.wasmRunModel(
-      ((_g = this.inputsBuffer) == null ? void 0 : _g.getAddress()) || 0,
+      ((_k = this.inputsBuffer) == null ? void 0 : _k.getAddress()) || 0,
+      // Always pass 0 (NULL) for input indices, since we assume that all input values are
+      // provided and are in the same order as the input variables defined in the model spec
+      0,
       this.outputsBuffer.getAddress(),
-      (outputIndicesBuffer == null ? void 0 : outputIndicesBuffer.getAddress()) || 0
+      (outputIndicesBuffer == null ? void 0 : outputIndicesBuffer.getAddress()) || 0,
+      (constantValuesBuffer == null ? void 0 : constantValuesBuffer.getAddress()) || 0,
+      (constantIndicesBuffer == null ? void 0 : constantIndicesBuffer.getAddress()) || 0
     );
     const elapsed = perfElapsed(t0);
     params.storeOutputs(this.outputsBuffer.getArrayView());
@@ -1738,13 +1938,17 @@ var WasmModel = class {
   }
   // from RunnableModel interface
   terminate() {
-    var _a, _b, _c;
+    var _a, _b, _c, _d, _e;
     (_a = this.inputsBuffer) == null ? void 0 : _a.dispose();
     this.inputsBuffer = void 0;
     (_b = this.outputsBuffer) == null ? void 0 : _b.dispose();
     this.outputsBuffer = void 0;
     (_c = this.outputIndicesBuffer) == null ? void 0 : _c.dispose();
     this.outputIndicesBuffer = void 0;
+    (_d = this.constantValuesBuffer) == null ? void 0 : _d.dispose();
+    this.constantValuesBuffer = void 0;
+    (_e = this.constantIndicesBuffer) == null ? void 0 : _e.dispose();
+    this.constantIndicesBuffer = void 0;
   }
 };
 function initWasmModel(wasmModule) {
@@ -1760,6 +1964,7 @@ var MockWasmModule = class {
     this.mallocOffset = 8;
     this.allocs = /* @__PURE__ */ new Map();
     this.lookups = /* @__PURE__ */ new Map();
+    this.constants = /* @__PURE__ */ new Map();
     this.initialTime = options.initialTime;
     this.finalTime = options.finalTime;
     this.outputVarIds = options.outputVarIds;
@@ -1799,11 +2004,35 @@ var MockWasmModule = class {
           this.lookups.set(varId, new JsModelLookup(numPoints, points));
         };
       case "runModelWithBuffers":
-        return (inputsAddress, outputsAddress, outputIndicesAddress) => {
+        return (inputsAddress, _inputIndicesAddress, outputsAddress, outputIndicesAddress, constantValuesAddress, constantIndicesAddress) => {
           const inputs = this.getHeapView("float64", inputsAddress);
           const outputs = this.getHeapView("float64", outputsAddress);
           const outputIndices = this.getHeapView("int32", outputIndicesAddress);
-          this.onRunModel(inputs, outputs, this.lookups, outputIndices);
+          this.constants.clear();
+          if (constantValuesAddress !== 0 && constantIndicesAddress !== 0) {
+            const constantValues = this.getHeapView("float64", constantValuesAddress);
+            const constantIndices = this.getHeapView("int32", constantIndicesAddress);
+            const numConstants = constantIndices[0];
+            let indicesOffset = 1;
+            let valuesOffset = 0;
+            for (let i = 0; i < numConstants; i++) {
+              const varIndex = constantIndices[indicesOffset++];
+              const subCount = constantIndices[indicesOffset++];
+              indicesOffset += subCount;
+              const varId = this.varIdForSpec({ varIndex });
+              if (varId) {
+                this.constants.set(varId, constantValues[valuesOffset++]);
+              }
+            }
+          }
+          this.onRunModel(
+            inputs,
+            outputs,
+            this.constants.size > 0 ? this.constants : void 0,
+            this.lookups,
+            outputIndices
+          );
+          this.constants.clear();
         };
       default:
         throw new Error(`Unhandled call to cwrap with function name '${fname}'`);
@@ -1881,7 +2110,7 @@ function createRunnerFromRunnableModel(model) {
       }
       return runModelSync(inputs, outputs, options);
     },
-    terminate: () => __async(this, null, function* () {
+    terminate: () => __async(null, null, function* () {
       if (!terminated) {
         model.terminate();
         terminated = true;
@@ -1906,7 +2135,7 @@ var ModelScheduler = class {
     /** Whether a model run is in progress. */
     this.runInProgress = false;
     const afterSet = () => {
-      this.runWasmModelIfNeeded();
+      this.runModelIfNeeded();
     };
     for (const userInput of userInputs) {
       userInput.callbacks.onSet = afterSet;
@@ -1917,24 +2146,24 @@ var ModelScheduler = class {
     }
   }
   /**
-   * Schedule a wasm model run (if not already pending).  When the run is
+   * Schedule a model run (if not already pending).  When the run is
    * complete, save the outputs and call the `onOutputsChanged` callback.
    */
-  runWasmModelIfNeeded() {
+  runModelIfNeeded() {
     this.runNeeded = true;
     if (this.runInProgress) {
       return;
     } else {
       this.runInProgress = true;
       setTimeout(() => {
-        this.runWasmModelNow();
+        this.runModelNow();
       }, 0);
     }
   }
   /**
-   * Run the wasm model asynchronously using the current set of input values.
+   * Run the model asynchronously using the current set of input values.
    */
-  runWasmModelNow() {
+  runModelNow() {
     return __async(this, null, function* () {
       var _a;
       for (let i = 0; i < this.userInputs.length; i++) {
@@ -1949,7 +2178,7 @@ var ModelScheduler = class {
       if (this.runNeeded) {
         this.runNeeded = false;
         setTimeout(() => {
-          this.runWasmModelNow();
+          this.runModelNow();
         }, 0);
       } else {
         this.runNeeded = false;
@@ -1971,6 +2200,192 @@ function createSimpleInputValue(varId) {
   };
   return { varId, get, set, reset, callbacks: {} };
 }
+
+// src/model-scheduler/multi-context-model-scheduler.ts
+var MultiContextModelScheduler = class {
+  /**
+   * @param runner The model runner.
+   * @param options Additional options for the scheduler.
+   * @param options.initialOutputs An optional `Outputs` instance that will be reused
+   * for the initial context.  This is useful for saving memory when an `Outputs`
+   * instance was already created for, e.g., a initial baseline/reference run.
+   */
+  constructor(runner, options) {
+    this.runner = runner;
+    /** The contexts that hold distinct sets of inputs and outputs. */
+    this.contexts = [];
+    /** Whether a model run has been scheduled. */
+    this.runNeeded = false;
+    /** Whether a model run is in progress. */
+    this.runInProgress = false;
+    this.initialOutputs = options == null ? void 0 : options.initialOutputs;
+  }
+  /**
+   * Return true if the scheduler has started any model runs.
+   */
+  isStarted() {
+    return this.initialOutputs === void 0;
+  }
+  /**
+   * Add a new context that holds a distinct set of model inputs and outputs.
+   * These inputs and outputs are kept separate from those in other contexts,
+   * which allows an application to use the same underlying model to run with
+   * multiple I/O contexts.
+   *
+   * Note that the contexts created before the first scheduled model run
+   * will inherit the data from `initialOutputs` passed to the constructor,
+   * but contexts created after that will initially have output values set
+   * to zero.
+   *
+   * @param inputs The input values, in the same order as in the spec file passed to `sde`.
+   * @param options Additional options for the context.
+   * @param options.externalData Additional data that is external to the model outputs.
+   * For example, this can contain data that was captured from an initial reference
+   * run, or other static data that is displayed in graphs alongside the model
+   * output data in graphs.
+   */
+  addContext(inputs, options) {
+    let outputs;
+    if (this.initialOutputs !== void 0) {
+      if (this.contexts.length === 0) {
+        outputs = this.initialOutputs;
+      } else {
+        outputs = this.runner.createOutputs();
+        for (const varId of outputs.varIds) {
+          const series0 = this.initialOutputs.getSeriesForVar(varId);
+          const series1 = outputs.getSeriesForVar(varId);
+          for (let i = 0; i < series0.points.length; i++) {
+            series1.points[i].y = series0.points[i].y;
+          }
+        }
+      }
+    } else {
+      outputs = this.runner.createOutputs();
+    }
+    const context = new ModelContextImpl(inputs, outputs, options == null ? void 0 : options.externalData);
+    const afterSet = () => {
+      context.runNeeded = true;
+      this.runModelIfNeeded();
+    };
+    for (const input of inputs) {
+      input.callbacks.onSet = afterSet;
+    }
+    this.contexts.push(context);
+    return context;
+  }
+  /**
+   * Remove the given context from the set of contexts managed by the scheduler.
+   *
+   * @param context The context to remove.
+   */
+  removeContext(context) {
+    const index = this.contexts.findIndex((c) => c === context);
+    if (index >= 0) {
+      this.contexts.splice(index, 1);
+    }
+  }
+  /**
+   * Schedule a model run (if not already pending).  When the run is
+   * complete, save the outputs and call the `onOutputsChanged` callback.
+   */
+  runModelIfNeeded() {
+    this.runNeeded = true;
+    if (this.runInProgress) {
+      return;
+    } else {
+      this.runInProgress = true;
+      setTimeout(() => {
+        this.runModelNow();
+      }, 0);
+    }
+  }
+  /**
+   * Run the model asynchronously for all relevant contexts.
+   */
+  runModelNow() {
+    return __async(this, null, function* () {
+      this.initialOutputs = void 0;
+      for (const context of this.contexts) {
+        if (context.runNeeded) {
+          context.runNeeded = false;
+          yield this.runModelNowForContext(context);
+        }
+      }
+      if (this.runNeeded) {
+        this.runNeeded = false;
+        setTimeout(() => {
+          this.runModelNow();
+        }, 0);
+      } else {
+        this.runNeeded = false;
+        this.runInProgress = false;
+      }
+    });
+  }
+  /**
+   * Run the model asynchronously using the current set of input values in the given context.
+   *
+   * @param context The context to use for the model run.
+   */
+  runModelNowForContext(context) {
+    return __async(this, null, function* () {
+      var _a;
+      if (this.currentInputs === void 0) {
+        this.currentInputs = Array(context.inputsArray.length);
+      }
+      for (let i = 0; i < context.inputsArray.length; i++) {
+        this.currentInputs[i] = context.inputsArray[i].get();
+      }
+      try {
+        yield this.runner.runModel(this.currentInputs, context.outputs);
+        (_a = context.onOutputsChanged) == null ? void 0 : _a.call(context);
+      } catch (e) {
+        console.error("ERROR: The scheduler encountered an error when running the model:", e);
+      }
+    });
+  }
+};
+var ModelContextImpl = class {
+  /**
+   * @hidden This is intended for use by `MultiContextModelScheduler` only.
+   *
+   * @param inputs 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.
+   * @param externalData Additional data that is external to the model outputs.  For example, this can contain
+   * data that was captured from an initial reference run, or other static data that is displayed in graphs
+   * alongside the model output data in graphs.
+   */
+  constructor(inputs, outputs, externalData) {
+    this.externalData = externalData;
+    /**
+     * Whether a model run is needed for this context.
+     * @hidden This is intended for use by `MultiContextModelScheduler` only.
+     */
+    this.runNeeded = false;
+    this.inputsArray = Array.from(inputs);
+    this.outputs = outputs;
+  }
+  /**
+   * Return the series data for the given model output variable or external
+   * dataset.
+   *
+   * @param varId The ID of the output variable associated with the data.
+   * @param sourceName The external data source name (e.g. "Ref"), or
+   * undefined to use the latest model output data from this context.
+   */
+  getSeriesForVar(varId, sourceName) {
+    if (sourceName === void 0) {
+      return this.outputs.getSeriesForVar(varId);
+    } else {
+      const dataForSource = this.externalData.get(sourceName);
+      if (dataForSource !== void 0) {
+        return dataForSource.get(varId);
+      } else {
+        return void 0;
+      }
+    }
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BufferedRunModelParams,
@@ -1978,17 +2393,22 @@ function createSimpleInputValue(varId) {
   MockWasmModule,
   ModelListing,
   ModelScheduler,
+  MultiContextModelScheduler,
   Outputs,
   ReferencedRunModelParams,
   Series,
+  createConstantDef,
   createInputValue,
   createLookupDef,
   createRunnableModel,
   createSynchronousModelRunner,
+  decodeConstants,
   decodeLookups,
+  encodeConstants,
   encodeLookups,
   encodeVarIndices,
   execJsModel,
+  getEncodedConstantBufferLengths,
   getEncodedLookupBufferLengths,
   getEncodedVarIndicesLength,
   getJsModelFunctions,