@sdeverywhere/runtime 0.2.7 → 0.2.9

package/README.md

@@ -150,7 +150,7 @@ The `emcc` command line options should be similar to the following:
 
 ```
 $ emcc \
-build/<mymodel>.c build/macros.c build/model.c build/vensim.c \
+build/<mymodel>.c build/macros.c build/model.c build/vensim.c build/allocation.c \
 -Ibuild -o ./output/<mymodel>.js -Wall -Os \
 -s STRICT=1 -s MALLOC=emmalloc -s FILESYSTEM=0 -s MODULARIZE=1 \
 -s EXPORTED_FUNCTIONS="['_malloc','_free','_getInitialTime','_getFinalTime','_getSaveper','_setLookup','_runModelWithBuffers']" \

package/dist/index.cjs

@@ -51,8 +51,8 @@ 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,
@@ -62,14 +62,18 @@ __export(src_exports, {
   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,
@@ -78,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) {
@@ -251,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;
@@ -332,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;
@@ -502,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() {
@@ -547,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. */
@@ -614,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;
@@ -658,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) {
@@ -685,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;
@@ -703,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;
@@ -711,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;
@@ -725,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);
     }
@@ -753,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++];
@@ -761,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");
     }
@@ -771,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);
   }
@@ -847,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;
@@ -876,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");
@@ -1116,6 +1245,8 @@ function getJsModelFunctions() {
   let ctx;
   const cachedVectors = /* @__PURE__ */ new Map();
   const cachedSortVectors = /* @__PURE__ */ new Map();
+  const cachedInvertWorkMatrices = /* @__PURE__ */ new Map();
+  const cachedInvertResultMatrices = /* @__PURE__ */ new Map();
   return {
     setContext(context) {
       ctx = context;
@@ -1150,6 +1281,74 @@ function getJsModelFunctions() {
     INTEGER(x) {
       return Math.trunc(x);
     },
+    INVERT_MATRIX(matrix, n) {
+      let work = cachedInvertWorkMatrices.get(n);
+      if (work === void 0) {
+        work = Array(n);
+        for (let i = 0; i < n; i++) {
+          work[i] = Array(2 * n);
+        }
+        cachedInvertWorkMatrices.set(n, work);
+      }
+      let result = cachedInvertResultMatrices.get(n);
+      if (result === void 0) {
+        result = Array(n);
+        for (let i = 0; i < n; i++) {
+          result[i] = Array(n);
+        }
+        cachedInvertResultMatrices.set(n, result);
+      }
+      for (let i = 0; i < n; i++) {
+        for (let j = 0; j < n; j++) {
+          work[i][j] = matrix[i][j];
+          work[i][n + j] = i === j ? 1 : 0;
+        }
+      }
+      for (let k = 0; k < n; k++) {
+        let pivot = k;
+        let max = Math.abs(work[k][k]);
+        for (let i = k + 1; i < n; i++) {
+          const v = Math.abs(work[i][k]);
+          if (v > max) {
+            max = v;
+            pivot = i;
+          }
+        }
+        if (max === 0) {
+          for (let i = 0; i < n; i++) {
+            for (let j = 0; j < n; j++) {
+              result[i][j] = _NA_;
+            }
+          }
+          return result;
+        }
+        if (pivot !== k) {
+          const tmpRow = work[k];
+          work[k] = work[pivot];
+          work[pivot] = tmpRow;
+        }
+        const p = work[k][k];
+        for (let j = 0; j < 2 * n; j++) {
+          work[k][j] /= p;
+        }
+        for (let i = 0; i < n; i++) {
+          if (i !== k) {
+            const f = work[i][k];
+            if (f !== 0) {
+              for (let j = 0; j < 2 * n; j++) {
+                work[i][j] -= f * work[k][j];
+              }
+            }
+          }
+        }
+      }
+      for (let i = 0; i < n; i++) {
+        for (let j = 0; j < n; j++) {
+          result[i][j] = work[i][n + j];
+        }
+      }
+      return result;
+    },
     LN(x) {
       return Math.log(x);
     },
@@ -1356,6 +1555,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);
@@ -1397,13 +1597,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 = {
@@ -1412,6 +1613,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);
@@ -1498,6 +1704,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;
@@ -1550,6 +1757,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) {
@@ -1574,6 +1789,7 @@ var MockJsModel = class {
   }
   // from JsModel interface
   initConstants() {
+    this.constants.clear();
   }
   // from JsModel interface
   initLevels() {
@@ -1581,7 +1797,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() {
@@ -1664,11 +1880,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) {
@@ -1704,7 +1927,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);
@@ -1712,7 +1976,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);
@@ -1724,14 +1988,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());
@@ -1739,13 +2008,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) {
@@ -1761,6 +2034,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;
@@ -1800,11 +2074,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}'`);
@@ -1882,7 +2180,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;
@@ -2169,14 +2467,18 @@ var ModelContextImpl = class {
   Outputs,
   ReferencedRunModelParams,
   Series,
+  createConstantDef,
   createInputValue,
   createLookupDef,
   createRunnableModel,
   createSynchronousModelRunner,
+  decodeConstants,
   decodeLookups,
+  encodeConstants,
   encodeLookups,
   encodeVarIndices,
   execJsModel,
+  getEncodedConstantBufferLengths,
   getEncodedLookupBufferLengths,
   getEncodedVarIndicesLength,
   getJsModelFunctions,