@sdeverywhere/runtime 0.2.9 → 0.2.11

package/dist/index.js

@@ -1,2440 +1,2248 @@
-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/_shared/inputs.ts
+import { err, ok } from "neverthrow";
+//#region src/_shared/inputs.ts
+/**
+* Create a basic `InputValue` instance that notifies when a new value is set.
+*
+* @param varId The input variable ID, as used in SDEverywhere.
+* @param defaultValue The default value of the input.
+* @param initialValue The inital value of the input; if undefined, will use `defaultValue`.
+*/
 function createInputValue(varId, defaultValue, initialValue) {
-  let currentValue = initialValue !== void 0 ? initialValue : defaultValue;
-  const callbacks = {};
-  const get = () => {
-    return currentValue;
-  };
-  const set = (newValue) => {
-    var _a;
-    if (newValue !== currentValue) {
-      currentValue = newValue;
-      (_a = callbacks.onSet) == null ? void 0 : _a.call(callbacks);
-    }
-  };
-  const reset = () => {
-    set(defaultValue);
-  };
-  return { varId, get, set, reset, callbacks };
+	let currentValue = initialValue !== void 0 ? initialValue : defaultValue;
+	const callbacks = {};
+	const get = () => {
+		return currentValue;
+	};
+	const set = (newValue) => {
+		if (newValue !== currentValue) {
+			currentValue = newValue;
+			callbacks.onSet?.();
+		}
+	};
+	const reset = () => {
+		set(defaultValue);
+	};
+	return {
+		varId,
+		get,
+		set,
+		reset,
+		callbacks
+	};
 }
-
-// src/_shared/outputs.ts
-import { ok, err } from "neverthrow";
-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) => __spreadValues({}, p));
-    return new _Series(this.varId, pointsCopy);
-  }
+//#endregion
+//#region src/_shared/outputs.ts
+/**
+* A time series of data points for an output variable.
+*/
+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) {
+		return this.points.find((p) => p.x === time)?.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);
+	}
 };
+/** Represents the outputs from a model run. */
 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;
-    this.endTime = endTime;
-    this.saveFreq = saveFreq;
-    this.seriesLength = Math.round((endTime - startTime) / saveFreq) + 1;
-    this.varSeries = new Array(varIds.length);
-    for (let i = 0; i < varIds.length; i++) {
-      const points = new Array(this.seriesLength);
-      for (let j = 0; j < this.seriesLength; j++) {
-        points[j] = { x: startTime + j * saveFreq, y: 0 };
-      }
-      const varId = varIds[i];
-      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()) {
-      return ok(void 0);
-    } else {
-      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) {
-      return this.varSeries[seriesIndex];
-    } else {
-      return void 0;
-    }
-  }
+	/**
+	* @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;
+		this.endTime = endTime;
+		this.saveFreq = saveFreq;
+		this.seriesLength = Math.round((endTime - startTime) / saveFreq) + 1;
+		this.varSeries = new Array(varIds.length);
+		for (let i = 0; i < varIds.length; i++) {
+			const points = new Array(this.seriesLength);
+			for (let j = 0; j < this.seriesLength; j++) points[j] = {
+				x: startTime + j * saveFreq,
+				y: 0
+			};
+			const varId = varIds[i];
+			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()) return ok(void 0);
+		else 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) return this.varSeries[seriesIndex];
+		else return;
+	}
 };
+/**
+* Parse the raw buffer produced by the model and store the values in the
+* given (reused) `Outputs` object.
+*
+* @param outputsBuffer The raw outputs buffer produced by the model.
+* @param rowLength The number of elements per row (one element per year or save point).
+* @return An `ok` result if the buffer is valid, otherwise an `err` result.
+* @hidden
+*/
 function parseOutputsBuffer(outputsBuffer, rowLength, outputs) {
-  const varCount = outputs.varIds.length;
-  const seriesLength = outputs.seriesLength;
-  if (rowLength < seriesLength || outputsBuffer.length < varCount * seriesLength) {
-    return err("invalid-point-count");
-  }
-  for (let outputVarIndex = 0; outputVarIndex < varCount; outputVarIndex++) {
-    const series = outputs.varSeries[outputVarIndex];
-    let sourceIndex = rowLength * outputVarIndex;
-    for (let valueIndex = 0; valueIndex < seriesLength; valueIndex++) {
-      series.points[valueIndex].y = validateNumber(outputsBuffer[sourceIndex]);
-      sourceIndex++;
-    }
-  }
-  return ok(outputs);
+	const varCount = outputs.varIds.length;
+	const seriesLength = outputs.seriesLength;
+	if (rowLength < seriesLength || outputsBuffer.length < varCount * seriesLength) return err("invalid-point-count");
+	for (let outputVarIndex = 0; outputVarIndex < varCount; outputVarIndex++) {
+		const series = outputs.varSeries[outputVarIndex];
+		let sourceIndex = rowLength * outputVarIndex;
+		for (let valueIndex = 0; valueIndex < seriesLength; valueIndex++) {
+			series.points[valueIndex].y = validateNumber(outputsBuffer[sourceIndex]);
+			sourceIndex++;
+		}
+	}
+	return ok(outputs);
 }
+/**
+* Return the given number if it is valid, or undefined if it is invalid.
+*
+* SDE converts Vensim's `:NA:` values to `-DBL_MAX`, so if we see a very large negative
+* value, convert it to `undefined`.  This is preferable to including extreme values
+* because some charting libraries (e.g. Chart.js) appear to choke on these large values
+* in certain browsers (e.g. Safari), but `undefined` appears to be handled better and
+* does a better job of signaling that the data point is undefined.
+*
+* @hidden
+*/
 function validateNumber(x) {
-  if (!isNaN(x) && x > -1e32) {
-    return x;
-  } else {
-    return void 0;
-  }
+	if (!isNaN(x) && x > -1e32) return x;
+	else return;
 }
-
-// src/_shared/var-indices.ts
+//#endregion
+//#region src/_shared/var-indices.ts
+/**
+* Return the length of the array that is required to store the variable
+* indices for the given `VarSpec` instances.
+*
+* @hidden This is not part of the public API; it is exposed here for use by
+* the synchronous and asynchronous model runner implementations.
+*
+* @param varSpecs The `VarSpec` instances to encode.
+*/
 function getEncodedVarIndicesLength(varSpecs) {
-  var _a;
-  let length = 1;
-  for (const varSpec of varSpecs) {
-    length += 2;
-    const subCount = ((_a = varSpec.subscriptIndices) == null ? void 0 : _a.length) || 0;
-    length += subCount;
-  }
-  return length;
+	let length = 1;
+	for (const varSpec of varSpecs) {
+		length += 2;
+		const subCount = varSpec.subscriptIndices?.length || 0;
+		length += subCount;
+	}
+	return length;
 }
+/**
+* Encode variable indices to the given array.
+*
+* @hidden This is not part of the public API; it is exposed here for use by
+* the synchronous and asynchronous model runner implementations.
+*
+* @param varSpecs The `VarSpec` instances to encode.
+*/
 function encodeVarIndices(varSpecs, indicesArray) {
-  let offset = 0;
-  indicesArray[offset++] = varSpecs.length;
-  for (const varSpec of varSpecs) {
-    indicesArray[offset++] = varSpec.varIndex;
-    const subs = varSpec.subscriptIndices;
-    const subCount = (subs == null ? void 0 : subs.length) || 0;
-    indicesArray[offset++] = subCount;
-    for (let i = 0; i < subCount; i++) {
-      indicesArray[offset++] = subs[i];
-    }
-  }
+	let offset = 0;
+	indicesArray[offset++] = varSpecs.length;
+	for (const varSpec of varSpecs) {
+		indicesArray[offset++] = varSpec.varIndex;
+		const subs = varSpec.subscriptIndices;
+		const subCount = subs?.length || 0;
+		indicesArray[offset++] = subCount;
+		for (let i = 0; i < subCount; i++) indicesArray[offset++] = subs[i];
+	}
 }
+/**
+* Return the lengths of the arrays that are required to store the constant values
+* and indices for the given `ConstantDef` instances.
+*
+* @hidden This is not part of the public API; it is exposed here for use by
+* the synchronous and asynchronous model runner implementations.
+*
+* @param constantDefs The `ConstantDef` instances to encode.
+*/
 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
-  };
+	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 = varSpec.subscriptIndices?.length || 0;
+		constantIndicesLength += subCount;
+		constantsLength += 1;
+	}
+	return {
+		constantIndicesLength,
+		constantsLength
+	};
 }
+/**
+* Encode constant values and indices to the given arrays.
+*
+* @hidden This is not part of the public API; it is exposed here for use by
+* the synchronous and asynchronous model runner implementations.
+*
+* @param constantDefs The `ConstantDef` instances to encode.
+* @param constantIndicesArray The view on the constant indices buffer.
+* @param constantsArray The view on the constant values buffer.
+*/
 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;
-  }
+	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?.length || 0;
+		constantIndicesArray[ci++] = subCount;
+		for (let i = 0; i < subCount; i++) constantIndicesArray[ci++] = subs[i];
+		constantsArray[constantDataOffset++] = constantDef.value;
+	}
 }
+/**
+* Decode constant values and indices from the given buffer views and return the
+* reconstructed `ConstantDef` instances.
+*
+* @hidden This is not part of the public API; it is exposed here for use by
+* the synchronous and asynchronous model runner implementations.
+*
+* @param constantIndicesArray The view on the constant indices buffer.
+* @param constantsArray The view on the constant values buffer.
+*/
 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;
+	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;
 }
+/**
+* Return the lengths of the arrays that are required to store the lookup data
+* and indices for the given `LookupDef` instances.
+*
+* @hidden This is not part of the public API; it is exposed here for use by
+* the synchronous and asynchronous model runner implementations.
+*
+* @param lookupDefs The `LookupDef` instances to encode.
+*/
 function getEncodedLookupBufferLengths(lookupDefs) {
-  var _a, _b;
-  let lookupIndicesLength = 1;
-  let lookupsLength = 0;
-  for (const lookupDef of lookupDefs) {
-    const varSpec = lookupDef.varRef.varSpec;
-    if (varSpec === void 0) {
-      throw new Error("Cannot compute lookup buffer lengths until all lookup var specs are defined");
-    }
-    lookupIndicesLength += 2;
-    const subCount = ((_a = varSpec.subscriptIndices) == null ? void 0 : _a.length) || 0;
-    lookupIndicesLength += subCount;
-    lookupIndicesLength += 2;
-    lookupsLength += ((_b = lookupDef.points) == null ? void 0 : _b.length) || 0;
-  }
-  return {
-    lookupIndicesLength,
-    lookupsLength
-  };
+	let lookupIndicesLength = 1;
+	let lookupsLength = 0;
+	for (const lookupDef of lookupDefs) {
+		const varSpec = lookupDef.varRef.varSpec;
+		if (varSpec === void 0) throw new Error("Cannot compute lookup buffer lengths until all lookup var specs are defined");
+		lookupIndicesLength += 2;
+		const subCount = varSpec.subscriptIndices?.length || 0;
+		lookupIndicesLength += subCount;
+		lookupIndicesLength += 2;
+		lookupsLength += lookupDef.points?.length || 0;
+	}
+	return {
+		lookupIndicesLength,
+		lookupsLength
+	};
 }
+/**
+* Encode lookup data and indices to the given arrays.
+*
+* @hidden This is not part of the public API; it is exposed here for use by
+* the synchronous and asynchronous model runner implementations.
+*
+* @param lookupDefs The `LookupDef` instances to encode.
+* @param lookupIndicesArray The view on the lookup indices buffer.
+* @param lookupsArray The view on the lookup data buffer.  This can be undefined in
+* the case where the data for the lookup(s) is empty.
+*/
 function encodeLookups(lookupDefs, lookupIndicesArray, lookupsArray) {
-  let li = 0;
-  lookupIndicesArray[li++] = lookupDefs.length;
-  let lookupDataOffset = 0;
-  for (const lookupDef of lookupDefs) {
-    const varSpec = lookupDef.varRef.varSpec;
-    lookupIndicesArray[li++] = varSpec.varIndex;
-    const subs = varSpec.subscriptIndices;
-    const subCount = (subs == null ? void 0 : subs.length) || 0;
-    lookupIndicesArray[li++] = subCount;
-    for (let i = 0; i < subCount; i++) {
-      lookupIndicesArray[li++] = subs[i];
-    }
-    if (lookupDef.points !== void 0) {
-      lookupIndicesArray[li++] = lookupDataOffset;
-      lookupIndicesArray[li++] = lookupDef.points.length;
-      lookupsArray == null ? void 0 : lookupsArray.set(lookupDef.points, lookupDataOffset);
-      lookupDataOffset += lookupDef.points.length;
-    } else {
-      lookupIndicesArray[li++] = -1;
-      lookupIndicesArray[li++] = 0;
-    }
-  }
+	let li = 0;
+	lookupIndicesArray[li++] = lookupDefs.length;
+	let lookupDataOffset = 0;
+	for (const lookupDef of lookupDefs) {
+		const varSpec = lookupDef.varRef.varSpec;
+		lookupIndicesArray[li++] = varSpec.varIndex;
+		const subs = varSpec.subscriptIndices;
+		const subCount = subs?.length || 0;
+		lookupIndicesArray[li++] = subCount;
+		for (let i = 0; i < subCount; i++) lookupIndicesArray[li++] = subs[i];
+		if (lookupDef.points !== void 0) {
+			lookupIndicesArray[li++] = lookupDataOffset;
+			lookupIndicesArray[li++] = lookupDef.points.length;
+			lookupsArray?.set(lookupDef.points, lookupDataOffset);
+			lookupDataOffset += lookupDef.points.length;
+		} else {
+			lookupIndicesArray[li++] = -1;
+			lookupIndicesArray[li++] = 0;
+		}
+	}
 }
+/**
+* Decode lookup data and indices from the given buffer views and return the
+* reconstructed `LookupDef` instances.
+*
+* @hidden This is not part of the public API; it is exposed here for use by
+* the synchronous and asynchronous model runner implementations.
+*
+* @param lookupIndicesArray The view on the lookup indices buffer.
+* @param lookupsArray The view on the lookup data buffer.  This can be undefined in
+* the case where the data for the lookup(s) is empty.
+*/
 function decodeLookups(lookupIndicesArray, lookupsArray) {
-  const lookupDefs = [];
-  let li = 0;
-  const lookupCount = lookupIndicesArray[li++];
-  for (let i = 0; i < lookupCount; i++) {
-    const varIndex = lookupIndicesArray[li++];
-    const subCount = lookupIndicesArray[li++];
-    const subscriptIndices = subCount > 0 ? Array(subCount) : void 0;
-    for (let subIndex = 0; subIndex < subCount; subIndex++) {
-      subscriptIndices[subIndex] = lookupIndicesArray[li++];
-    }
-    const lookupDataOffset = lookupIndicesArray[li++];
-    const lookupDataLength = lookupIndicesArray[li++];
-    const varSpec = {
-      varIndex,
-      subscriptIndices
-    };
-    let points;
-    if (lookupDataOffset >= 0) {
-      if (lookupsArray) {
-        points = lookupsArray.slice(lookupDataOffset, lookupDataOffset + lookupDataLength);
-      } else {
-        points = new Float64Array(0);
-      }
-    } else {
-      points = void 0;
-    }
-    lookupDefs.push({
-      varRef: {
-        varSpec
-      },
-      points
-    });
-  }
-  return lookupDefs;
+	const lookupDefs = [];
+	let li = 0;
+	const lookupCount = lookupIndicesArray[li++];
+	for (let i = 0; i < lookupCount; i++) {
+		const varIndex = lookupIndicesArray[li++];
+		const subCount = lookupIndicesArray[li++];
+		const subscriptIndices = subCount > 0 ? Array(subCount) : void 0;
+		for (let subIndex = 0; subIndex < subCount; subIndex++) subscriptIndices[subIndex] = lookupIndicesArray[li++];
+		const lookupDataOffset = lookupIndicesArray[li++];
+		const lookupDataLength = lookupIndicesArray[li++];
+		const varSpec = {
+			varIndex,
+			subscriptIndices
+		};
+		let points;
+		if (lookupDataOffset >= 0) {
+			if (lookupsArray) points = lookupsArray.slice(lookupDataOffset, lookupDataOffset + lookupDataLength);
+			else points = /* @__PURE__ */ new Float64Array(0);
+		} else points = void 0;
+		lookupDefs.push({
+			varRef: { varSpec },
+			points
+		});
+	}
+	return lookupDefs;
 }
-
-// src/_shared/constant-def.ts
+//#endregion
+//#region src/_shared/constant-def.ts
+/**
+* Create a `ConstantDef` instance.
+*
+* @param varRef The reference to the constant variable to be modified.
+* @param value The new constant value.
+*/
 function createConstantDef(varRef, value) {
-  return {
-    varRef,
-    value
-  };
+	return {
+		varRef,
+		value
+	};
 }
-
-// src/_shared/lookup-def.ts
+//#endregion
+//#region src/_shared/lookup-def.ts
+/**
+* Create a `LookupDef` instance from the given array of `Point` objects.
+*
+* @param varRef The reference to the lookup or data variable to be modified.
+* @param points The lookup data as an array of `Point` objects.  This can be
+* undefined, in which case the lookup data will be reset to the original data.
+*/
 function createLookupDef(varRef, points) {
-  let flatPoints;
-  if (points) {
-    flatPoints = new Float64Array(points.length * 2);
-    let i = 0;
-    for (const p of points) {
-      flatPoints[i++] = p.x;
-      flatPoints[i++] = p.y;
-    }
-  }
-  return {
-    varRef,
-    points: flatPoints
-  };
+	let flatPoints;
+	if (points) {
+		flatPoints = new Float64Array(points.length * 2);
+		let i = 0;
+		for (const p of points) {
+			flatPoints[i++] = p.x;
+			flatPoints[i++] = p.y;
+		}
+	}
+	return {
+		varRef,
+		points: flatPoints
+	};
 }
-
-// src/model-listing/model-listing.ts
+//#endregion
+//#region src/model-listing/model-listing.ts
+/**
+* @hidden This is not yet part of the public API; it is exposed here for use
+* in experimental testing tools.
+*/
 var ModelListing = class {
-  constructor(listingObj) {
-    this.varSpecs = /* @__PURE__ */ new Map();
-    const dimensions = /* @__PURE__ */ new Map();
-    for (const dimInfo of listingObj.dimensions) {
-      const dimId = dimInfo.id;
-      const subscripts = [];
-      for (let i = 0; i < dimInfo.subIds.length; i++) {
-        subscripts.push({
-          id: dimInfo.subIds[i],
-          index: i
-        });
-      }
-      dimensions.set(dimId, {
-        id: dimId,
-        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 listingObj.variables) {
-      const baseVarId = varIdWithoutSubscripts(v.id);
-      if (!baseVarIds.has(baseVarId)) {
-        const dimIds = v.dimIds || [];
-        const dimensions2 = dimIds.map(dimensionForId);
-        if (dimensions2.length > 0) {
-          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.index,
-              subscriptIndices: subIndices
-            });
-          }
-        } else {
-          this.varSpecs.set(baseVarId, {
-            varIndex: v.index
-          });
-        }
-        baseVarIds.add(baseVarId);
-      }
-    }
-  }
-  /**
-   * Return the `VarSpec` for the given variable ID, or undefined if there is no spec defined
-   * in the listing for that variable.
-   */
-  getSpecForVarId(varId) {
-    return this.varSpecs.get(varId);
-  }
-  /**
-   * Return the `VarSpec` for the given variable name, or undefined if there is no spec defined
-   * in the listing for that variable.
-   */
-  getSpecForVarName(varName) {
-    const varId = sdeVarIdForVensimVarName(varName);
-    return this.varSpecs.get(varId);
-  }
-  /**
-   * 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;
-  }
+	constructor(listingObj) {
+		this.varSpecs = /* @__PURE__ */ new Map();
+		const dimensions = /* @__PURE__ */ new Map();
+		for (const dimInfo of listingObj.dimensions) {
+			const dimId = dimInfo.id;
+			const subscripts = [];
+			for (let i = 0; i < dimInfo.subIds.length; i++) subscripts.push({
+				id: dimInfo.subIds[i],
+				index: i
+			});
+			dimensions.set(dimId, {
+				id: dimId,
+				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 listingObj.variables) {
+			const baseVarId = varIdWithoutSubscripts(v.id);
+			if (!baseVarIds.has(baseVarId)) {
+				const dimensions = (v.dimIds || []).map(dimensionForId);
+				if (dimensions.length > 0) {
+					const dimSubs = [];
+					for (const dim of dimensions) 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.index,
+							subscriptIndices: subIndices
+						});
+					}
+				} else this.varSpecs.set(baseVarId, { varIndex: v.index });
+				baseVarIds.add(baseVarId);
+			}
+		}
+	}
+	/**
+	* Return the `VarSpec` for the given variable ID, or undefined if there is no spec defined
+	* in the listing for that variable.
+	*/
+	getSpecForVarId(varId) {
+		return this.varSpecs.get(varId);
+	}
+	/**
+	* Return the `VarSpec` for the given variable name, or undefined if there is no spec defined
+	* in the listing for that variable.
+	*/
+	getSpecForVarName(varName) {
+		const varId = sdeVarIdForVensimVarName(varName);
+		return this.varSpecs.get(varId);
+	}
+	/**
+	* 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;
+	}
 };
+/**
+* Helper function that returns the base name of a variable without the subscripts.
+*/
 function varIdWithoutSubscripts(fullVarId) {
-  const bracketIndex = fullVarId.indexOf("[");
-  if (bracketIndex >= 0) {
-    return fullVarId.substring(0, bracketIndex);
-  } else {
-    return fullVarId;
-  }
+	const bracketIndex = fullVarId.indexOf("[");
+	if (bracketIndex >= 0) return fullVarId.substring(0, bracketIndex);
+	else return fullVarId;
 }
+/**
+* Return the cartesian product of the given array of arrays.
+*
+* For example, if we have an array that lists out two dimensions:
+*   [ ['a1','a2'], ['b1','b2','b3'] ]
+* this function will return all the combinations, e.g.:
+*   [ ['a1', 'b1'], ['a1', 'b2'], ['a1', 'b3'], ['a2', 'b1'], ... ]
+*
+* This can be used in place of nested for loops and has the benefit of working
+* for multi-dimensional inputs.
+*/
 function cartesianProductOf(arr) {
-  return arr.reduce(
-    (a, b) => {
-      return a.map((x) => b.map((y) => x.concat([y]))).reduce((v, w) => v.concat(w), []);
-    },
-    [[]]
-  );
+	return arr.reduce((a, b) => {
+		return a.map((x) => b.map((y) => x.concat([y]))).reduce((v, w) => v.concat(w), []);
+	}, [[]]);
 }
+/**
+* Helper function that converts a Vensim variable or subscript name
+* into a valid C identifier as used by SDE.
+* TODO: Import helper function from `compile` package instead
+*/
 function sdeVarIdForVensimName(name) {
-  return "_" + name.trim().replace(/"/g, "_").replace(/\s+!$/g, "!").replace(/\s/g, "_").replace(/,/g, "_").replace(/-/g, "_").replace(/\./g, "_").replace(/\$/g, "_").replace(/'/g, "_").replace(/&/g, "_").replace(/%/g, "_").replace(/\//g, "_").replace(/\|/g, "_").toLowerCase();
+	return "_" + name.trim().replace(/"/g, "_").replace(/\s+!$/g, "!").replace(/\s/g, "_").replace(/,/g, "_").replace(/-/g, "_").replace(/\./g, "_").replace(/\$/g, "_").replace(/'/g, "_").replace(/&/g, "_").replace(/%/g, "_").replace(/\//g, "_").replace(/\|/g, "_").toLowerCase();
 }
+/**
+* Helper function that converts a Vensim variable name (possibly containing
+* subscripts) into a valid C identifier as used by SDE.
+* TODO: Import helper function from `compile` package instead
+*/
 function sdeVarIdForVensimVarName(varName) {
-  const m = varName.match(/([^[]+)(?:\[([^\]]+)\])?/);
-  if (!m) {
-    throw new Error(`Invalid Vensim name: ${varName}`);
-  }
-  let id = sdeVarIdForVensimName(m[1]);
-  if (m[2]) {
-    const subscripts = m[2].split(",").map((x) => sdeVarIdForVensimName(x));
-    id += `[${subscripts.join(",")}]`;
-  }
-  return id;
+	const m = varName.match(/([^[]+)(?:\[([^\]]+)\])?/);
+	if (!m) throw new Error(`Invalid Vensim name: ${varName}`);
+	let id = sdeVarIdForVensimName(m[1]);
+	if (m[2]) {
+		const subscripts = m[2].split(",").map((x) => sdeVarIdForVensimName(x));
+		id += `[${subscripts.join(",")}]`;
+	}
+	return id;
 }
-
-// src/runnable-model/resolve-var-ref.ts
+//#endregion
+//#region src/runnable-model/resolve-var-ref.ts
+/**
+* Resolve the provided variable reference using the `ModelListing` and variable name
+* or identifier.
+*
+* - If `varRef` has a defined `varSpec`, it is assumed to be valid.
+* - Otherwise, if `varRef` has a defined `varId`, it will be used to locate the
+*   corresponding `varSpec` in the provided listing.
+* - Otherwise, if `varRef` has a defined `varName`, it will be used to locate the
+*   corresponding `varSpec` in the provided listing.
+*
+* If the `varSpec` is found, this will set the `varSpec` property on the provided `varRef`.
+* Otherwise, this will throw an error.
+*
+* @hidden This is not part of the public API; it is exposed here for internal
+* use only.
+*
+* @param listing The model listing.
+* @param varRef The variable reference.
+* @param varKind The kind of variable (e.g., "lookup"), used to build an error message.
+*/
 function resolveVarRef(listing, varRef, varKind) {
-  if (varRef.varSpec) {
-    return;
-  }
-  if (listing === void 0) {
-    throw new Error(
-      `Unable to resolve ${varKind} variable references by name or identifier when model listing is unavailable`
-    );
-  }
-  if (varRef.varId) {
-    const varSpec = listing == null ? void 0 : listing.getSpecForVarId(varRef.varId);
-    if (varSpec) {
-      varRef.varSpec = varSpec;
-    } else {
-      throw new Error(`Failed to resolve ${varKind} variable reference for varId=${varRef.varId}`);
-    }
-  } else {
-    const varSpec = listing == null ? void 0 : listing.getSpecForVarName(varRef.varName);
-    if (varSpec) {
-      varRef.varSpec = varSpec;
-    } else {
-      throw new Error(`Failed to resolve ${varKind} variable reference for varName='${varRef.varId}'`);
-    }
-  }
+	if (varRef.varSpec) return;
+	if (listing === void 0) throw new Error(`Unable to resolve ${varKind} variable references by name or identifier when model listing is unavailable`);
+	if (varRef.varId) {
+		const varSpec = listing?.getSpecForVarId(varRef.varId);
+		if (varSpec) varRef.varSpec = varSpec;
+		else throw new Error(`Failed to resolve ${varKind} variable reference for varId=${varRef.varId}`);
+	} else {
+		const varSpec = listing?.getSpecForVarName(varRef.varName);
+		if (varSpec) varRef.varSpec = varSpec;
+		else throw new Error(`Failed to resolve ${varKind} variable reference for varName='${varRef.varId}'`);
+	}
 }
-
-// src/runnable-model/buffered-run-model-params.ts
-var headerLengthInElements = 20;
-var extrasLengthInElements = 1;
+//#endregion
+//#region src/runnable-model/buffered-run-model-params.ts
+const headerLengthInElements = 20;
+const extrasLengthInElements = 1;
 var Int32Section = class {
-  constructor() {
-    this.offsetInBytes = 0;
-    this.lengthInElements = 0;
-  }
-  update(encoded, offsetInBytes, lengthInElements) {
-    this.view = lengthInElements > 0 ? new Int32Array(encoded, offsetInBytes, lengthInElements) : void 0;
-    this.offsetInBytes = offsetInBytes;
-    this.lengthInElements = lengthInElements;
-  }
+	constructor() {
+		this.offsetInBytes = 0;
+		this.lengthInElements = 0;
+	}
+	update(encoded, offsetInBytes, lengthInElements) {
+		this.view = lengthInElements > 0 ? new Int32Array(encoded, offsetInBytes, lengthInElements) : void 0;
+		this.offsetInBytes = offsetInBytes;
+		this.lengthInElements = lengthInElements;
+	}
 };
 var Float64Section = class {
-  constructor() {
-    this.offsetInBytes = 0;
-    this.lengthInElements = 0;
-  }
-  update(encoded, offsetInBytes, lengthInElements) {
-    this.view = lengthInElements > 0 ? new Float64Array(encoded, offsetInBytes, lengthInElements) : void 0;
-    this.offsetInBytes = offsetInBytes;
-    this.lengthInElements = lengthInElements;
-  }
+	constructor() {
+		this.offsetInBytes = 0;
+		this.lengthInElements = 0;
+	}
+	update(encoded, offsetInBytes, lengthInElements) {
+		this.view = lengthInElements > 0 ? new Float64Array(encoded, offsetInBytes, lengthInElements) : void 0;
+		this.offsetInBytes = offsetInBytes;
+		this.lengthInElements = lengthInElements;
+	}
 };
+/**
+* An implementation of `RunModelParams` that copies the input and output arrays into a single,
+* combined buffer.  This implementation is designed to work with an asynchronous `ModelRunner`
+* implementation because the buffer can be transferred to/from a Web Worker or Node.js worker
+* thread without copying (if it is marked `Transferable`).
+*
+* @hidden This is not yet exposed in the public API; it is currently only used by
+* the implementations of the `RunnableModel` interface.
+*/
 var BufferedRunModelParams = class {
-  /**
-   * @param listing The model listing that is used to locate a variable that is referenced by
-   * name or identifier.  If undefined, variables cannot be referenced by name or identifier,
-   * and can only be referenced using a valid `VarSpec`.
-   */
-  constructor(listing) {
-    this.listing = listing;
-    /**
-     * The header section of the `encoded` buffer.  The header declares the byte offset and length
-     * (in elements) of each section of the buffer.
-     */
-    this.header = new Int32Section();
-    /** The extras section of the `encoded` buffer (holds elapsed time, etc). */
-    this.extras = new Float64Section();
-    /** The inputs section of the `encoded` buffer. */
-    this.inputs = new Float64Section();
-    /** The outputs section of the `encoded` buffer. */
-    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. */
-    this.lookupIndices = new Int32Section();
-  }
-  /**
-   * Return the encoded buffer from this instance, which can be passed to `updateFromEncodedBuffer`.
-   */
-  getEncodedBuffer() {
-    return this.encoded;
-  }
-  // from RunModelParams interface
-  getInputs() {
-    return this.inputs.view;
-  }
-  // from RunModelParams interface
-  copyInputs(array, create) {
-    if (this.inputs.lengthInElements === 0) {
-      return;
-    }
-    if (array === void 0 || array.length < this.inputs.lengthInElements) {
-      array = create(this.inputs.lengthInElements);
-    }
-    array.set(this.inputs.view);
-  }
-  // from RunModelParams interface
-  getOutputIndicesLength() {
-    return this.outputIndices.lengthInElements;
-  }
-  // from RunModelParams interface
-  getOutputIndices() {
-    return this.outputIndices.view;
-  }
-  // from RunModelParams interface
-  copyOutputIndices(array, create) {
-    if (this.outputIndices.lengthInElements === 0) {
-      return;
-    }
-    if (array === void 0 || array.length < this.outputIndices.lengthInElements) {
-      array = create(this.outputIndices.lengthInElements);
-    }
-    array.set(this.outputIndices.view);
-  }
-  // from RunModelParams interface
-  getOutputsLength() {
-    return this.outputs.lengthInElements;
-  }
-  // from RunModelParams interface
-  getOutputs() {
-    return this.outputs.view;
-  }
-  // from RunModelParams interface
-  getOutputsObject() {
-    return void 0;
-  }
-  // from RunModelParams interface
-  storeOutputs(array) {
-    if (this.outputs.view === void 0) {
-      return;
-    }
-    if (array.length > this.outputs.view.length) {
-      this.outputs.view.set(array.subarray(0, this.outputs.view.length));
-    } else {
-      this.outputs.view.set(array);
-    }
-  }
-  // 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;
-    }
-    return decodeLookups(this.lookupIndices.view, this.lookups.view);
-  }
-  // from RunModelParams interface
-  getElapsedTime() {
-    return this.extras.view[0];
-  }
-  // from RunModelParams interface
-  storeElapsedTime(elapsed) {
-    this.extras.view[0] = elapsed;
-  }
-  /**
-   * Copy the outputs buffer to the given `Outputs` instance.  This should be called
-   * after the `runModel` call has completed so that the output values are copied from
-   * the internal buffer to the `Outputs` instance that was passed to `runModel`.
-   *
-   * @param outputs The `Outputs` instance into which the output values will be copied.
-   */
-  finalizeOutputs(outputs) {
-    if (this.outputs.view) {
-      outputs.updateFromBuffer(this.outputs.view, outputs.seriesLength);
-    }
-    outputs.runTimeInMillis = this.getElapsedTime();
-  }
-  /**
-   * Update this instance using the parameters that are passed to a `runModel` call.
-   *
-   * @param inputs The model input values (must be in the same order as in the spec file).
-   * @param outputs The structure into which the model outputs will be stored.
-   * @param options Additional options that influence the model run.
-   */
-  updateFromParams(inputs, outputs, options) {
-    const inputsLengthInElements = inputs.length;
-    const outputsLengthInElements = outputs.varIds.length * outputs.seriesLength;
-    let outputIndicesLengthInElements;
-    const outputVarSpecs = outputs.varSpecs;
-    if (outputVarSpecs !== void 0 && outputVarSpecs.length > 0) {
-      outputIndicesLengthInElements = getEncodedVarIndicesLength(outputVarSpecs);
-    } 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) {
-      for (const lookupDef of options.lookups) {
-        resolveVarRef(this.listing, lookupDef.varRef, "lookup");
-      }
-      const encodedLengths = getEncodedLookupBufferLengths(options.lookups);
-      lookupsLengthInElements = encodedLengths.lookupsLength;
-      lookupIndicesLengthInElements = encodedLengths.lookupIndicesLength;
-    } else {
-      lookupsLengthInElements = 0;
-      lookupIndicesLengthInElements = 0;
-    }
-    let byteOffset = 0;
-    function section(kind, lengthInElements) {
-      const sectionOffsetInBytes = byteOffset;
-      const bytesPerElement = kind === "float64" ? Float64Array.BYTES_PER_ELEMENT : Int32Array.BYTES_PER_ELEMENT;
-      const requiredSectionLengthInBytes = Math.round(lengthInElements * bytesPerElement);
-      const alignedSectionLengthInBytes = Math.ceil(requiredSectionLengthInBytes / 8) * 8;
-      byteOffset += alignedSectionLengthInBytes;
-      return sectionOffsetInBytes;
-    }
-    const headerOffsetInBytes = section("int32", headerLengthInElements);
-    const extrasOffsetInBytes = section("float64", extrasLengthInElements);
-    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;
-    if (this.encoded === void 0 || this.encoded.byteLength < requiredLengthInBytes) {
-      const totalLengthInBytes = Math.ceil(requiredLengthInBytes * 1.2);
-      this.encoded = new ArrayBuffer(totalLengthInBytes);
-      this.header.update(this.encoded, headerOffsetInBytes, headerLengthInElements);
-    }
-    const headerView = this.header.view;
-    let headerIndex = 0;
-    headerView[headerIndex++] = extrasOffsetInBytes;
-    headerView[headerIndex++] = extrasLengthInElements;
-    headerView[headerIndex++] = inputsOffsetInBytes;
-    headerView[headerIndex++] = inputsLengthInElements;
-    headerView[headerIndex++] = outputsOffsetInBytes;
-    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;
-    headerView[headerIndex++] = lookupIndicesLengthInElements;
-    this.inputs.update(this.encoded, inputsOffsetInBytes, inputsLengthInElements);
-    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;
-    for (let i = 0; i < inputs.length; i++) {
-      const input = inputs[i];
-      if (typeof input === "number") {
-        inputsView[i] = input;
-      } else {
-        inputsView[i] = input.get();
-      }
-    }
-    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);
-    }
-  }
-  /**
-   * Update this instance using the values contained in the encoded buffer from another
-   * `BufferedRunModelParams` instance.
-   *
-   * @param buffer An encoded buffer returned by `getEncodedBuffer`.
-   */
-  updateFromEncodedBuffer(buffer) {
-    const headerLengthInBytes = headerLengthInElements * Int32Array.BYTES_PER_ELEMENT;
-    if (buffer.byteLength < headerLengthInBytes) {
-      throw new Error("Buffer must be long enough to contain header section");
-    }
-    this.encoded = buffer;
-    const headerOffsetInBytes = 0;
-    this.header.update(this.encoded, headerOffsetInBytes, headerLengthInElements);
-    const headerView = this.header.view;
-    let headerIndex = 0;
-    const extrasOffsetInBytes = headerView[headerIndex++];
-    const extrasLengthInElements2 = headerView[headerIndex++];
-    const inputsOffsetInBytes = headerView[headerIndex++];
-    const inputsLengthInElements = headerView[headerIndex++];
-    const outputsOffsetInBytes = headerView[headerIndex++];
-    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++];
-    const lookupIndicesLengthInElements = headerView[headerIndex++];
-    const extrasLengthInBytes = extrasLengthInElements2 * Float64Array.BYTES_PER_ELEMENT;
-    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 + constantsLengthInBytes + constantIndicesLengthInBytes + lookupsLengthInBytes + lookupIndicesLengthInBytes;
-    if (buffer.byteLength < requiredLengthInBytes) {
-      throw new Error("Buffer must be long enough to contain sections declared in header");
-    }
-    this.extras.update(this.encoded, extrasOffsetInBytes, extrasLengthInElements2);
-    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);
-  }
+	/**
+	* @param listing The model listing that is used to locate a variable that is referenced by
+	* name or identifier.  If undefined, variables cannot be referenced by name or identifier,
+	* and can only be referenced using a valid `VarSpec`.
+	*/
+	constructor(listing) {
+		this.listing = listing;
+		this.header = new Int32Section();
+		this.extras = new Float64Section();
+		this.inputs = new Float64Section();
+		this.outputs = new Float64Section();
+		this.outputIndices = new Int32Section();
+		this.constants = new Float64Section();
+		this.constantIndices = new Int32Section();
+		this.lookups = new Float64Section();
+		this.lookupIndices = new Int32Section();
+	}
+	/**
+	* Return the encoded buffer from this instance, which can be passed to `updateFromEncodedBuffer`.
+	*/
+	getEncodedBuffer() {
+		return this.encoded;
+	}
+	getInputs() {
+		return this.inputs.view;
+	}
+	copyInputs(array, create) {
+		if (this.inputs.lengthInElements === 0) return;
+		if (array === void 0 || array.length < this.inputs.lengthInElements) array = create(this.inputs.lengthInElements);
+		array.set(this.inputs.view);
+	}
+	getOutputIndicesLength() {
+		return this.outputIndices.lengthInElements;
+	}
+	getOutputIndices() {
+		return this.outputIndices.view;
+	}
+	copyOutputIndices(array, create) {
+		if (this.outputIndices.lengthInElements === 0) return;
+		if (array === void 0 || array.length < this.outputIndices.lengthInElements) array = create(this.outputIndices.lengthInElements);
+		array.set(this.outputIndices.view);
+	}
+	getOutputsLength() {
+		return this.outputs.lengthInElements;
+	}
+	getOutputs() {
+		return this.outputs.view;
+	}
+	getOutputsObject() {}
+	storeOutputs(array) {
+		if (this.outputs.view === void 0) return;
+		if (array.length > this.outputs.view.length) this.outputs.view.set(array.subarray(0, this.outputs.view.length));
+		else this.outputs.view.set(array);
+	}
+	getConstants() {
+		if (this.constantIndices.lengthInElements === 0) return;
+		return decodeConstants(this.constantIndices.view, this.constants.view);
+	}
+	getLookups() {
+		if (this.lookupIndices.lengthInElements === 0) return;
+		return decodeLookups(this.lookupIndices.view, this.lookups.view);
+	}
+	getElapsedTime() {
+		return this.extras.view[0];
+	}
+	storeElapsedTime(elapsed) {
+		this.extras.view[0] = elapsed;
+	}
+	/**
+	* Copy the outputs buffer to the given `Outputs` instance.  This should be called
+	* after the `runModel` call has completed so that the output values are copied from
+	* the internal buffer to the `Outputs` instance that was passed to `runModel`.
+	*
+	* @param outputs The `Outputs` instance into which the output values will be copied.
+	*/
+	finalizeOutputs(outputs) {
+		if (this.outputs.view) outputs.updateFromBuffer(this.outputs.view, outputs.seriesLength);
+		outputs.runTimeInMillis = this.getElapsedTime();
+	}
+	/**
+	* Update this instance using the parameters that are passed to a `runModel` call.
+	*
+	* @param inputs The model input values (must be in the same order as in the spec file).
+	* @param outputs The structure into which the model outputs will be stored.
+	* @param options Additional options that influence the model run.
+	*/
+	updateFromParams(inputs, outputs, options) {
+		const inputsLengthInElements = inputs.length;
+		const outputsLengthInElements = outputs.varIds.length * outputs.seriesLength;
+		let outputIndicesLengthInElements;
+		const outputVarSpecs = outputs.varSpecs;
+		if (outputVarSpecs !== void 0 && outputVarSpecs.length > 0) outputIndicesLengthInElements = getEncodedVarIndicesLength(outputVarSpecs);
+		else outputIndicesLengthInElements = 0;
+		let constantsLengthInElements;
+		let constantIndicesLengthInElements;
+		if (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?.lookups !== void 0 && options.lookups.length > 0) {
+			for (const lookupDef of options.lookups) resolveVarRef(this.listing, lookupDef.varRef, "lookup");
+			const encodedLengths = getEncodedLookupBufferLengths(options.lookups);
+			lookupsLengthInElements = encodedLengths.lookupsLength;
+			lookupIndicesLengthInElements = encodedLengths.lookupIndicesLength;
+		} else {
+			lookupsLengthInElements = 0;
+			lookupIndicesLengthInElements = 0;
+		}
+		let byteOffset = 0;
+		function section(kind, lengthInElements) {
+			const sectionOffsetInBytes = byteOffset;
+			const bytesPerElement = kind === "float64" ? Float64Array.BYTES_PER_ELEMENT : Int32Array.BYTES_PER_ELEMENT;
+			const requiredSectionLengthInBytes = Math.round(lengthInElements * bytesPerElement);
+			const alignedSectionLengthInBytes = Math.ceil(requiredSectionLengthInBytes / 8) * 8;
+			byteOffset += alignedSectionLengthInBytes;
+			return sectionOffsetInBytes;
+		}
+		const headerOffsetInBytes = section("int32", headerLengthInElements);
+		const extrasOffsetInBytes = section("float64", extrasLengthInElements);
+		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;
+		if (this.encoded === void 0 || this.encoded.byteLength < requiredLengthInBytes) {
+			const totalLengthInBytes = Math.ceil(requiredLengthInBytes * 1.2);
+			this.encoded = new ArrayBuffer(totalLengthInBytes);
+			this.header.update(this.encoded, headerOffsetInBytes, headerLengthInElements);
+		}
+		const headerView = this.header.view;
+		let headerIndex = 0;
+		headerView[headerIndex++] = extrasOffsetInBytes;
+		headerView[headerIndex++] = extrasLengthInElements;
+		headerView[headerIndex++] = inputsOffsetInBytes;
+		headerView[headerIndex++] = inputsLengthInElements;
+		headerView[headerIndex++] = outputsOffsetInBytes;
+		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;
+		headerView[headerIndex++] = lookupIndicesLengthInElements;
+		this.inputs.update(this.encoded, inputsOffsetInBytes, inputsLengthInElements);
+		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;
+		for (let i = 0; i < inputs.length; i++) {
+			const input = inputs[i];
+			if (typeof input === "number") inputsView[i] = input;
+			else inputsView[i] = input.get();
+		}
+		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);
+	}
+	/**
+	* Update this instance using the values contained in the encoded buffer from another
+	* `BufferedRunModelParams` instance.
+	*
+	* @param buffer An encoded buffer returned by `getEncodedBuffer`.
+	*/
+	updateFromEncodedBuffer(buffer) {
+		const headerLengthInBytes = headerLengthInElements * Int32Array.BYTES_PER_ELEMENT;
+		if (buffer.byteLength < headerLengthInBytes) throw new Error("Buffer must be long enough to contain header section");
+		this.encoded = buffer;
+		this.header.update(this.encoded, 0, headerLengthInElements);
+		const headerView = this.header.view;
+		let headerIndex = 0;
+		const extrasOffsetInBytes = headerView[headerIndex++];
+		const extrasLengthInElements = headerView[headerIndex++];
+		const inputsOffsetInBytes = headerView[headerIndex++];
+		const inputsLengthInElements = headerView[headerIndex++];
+		const outputsOffsetInBytes = headerView[headerIndex++];
+		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++];
+		const lookupIndicesLengthInElements = headerView[headerIndex++];
+		const extrasLengthInBytes = extrasLengthInElements * Float64Array.BYTES_PER_ELEMENT;
+		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 + constantsLengthInBytes + constantIndicesLengthInBytes + lookupsLengthInBytes + lookupIndicesLengthInBytes;
+		if (buffer.byteLength < requiredLengthInBytes) throw new Error("Buffer must be long enough to contain sections declared in header");
+		this.extras.update(this.encoded, extrasOffsetInBytes, extrasLengthInElements);
+		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);
+	}
 };
-
-// src/runnable-model/referenced-run-model-params.ts
+//#endregion
+//#region src/runnable-model/referenced-run-model-params.ts
+/**
+* An implementation of `RunModelParams` that keeps references to the `inputs` and
+* `outputs` parameters that are passed to the `runModel` function.  This implementation
+* is best used with a synchronous `ModelRunner`.
+*
+* @hidden This is not yet exposed in the public API; it is currently only used by
+* the implementations of the `RunnableModel` interface.
+*/
 var ReferencedRunModelParams = class {
-  /**
-   * @param listing The model listing that is used to locate a variable that is referenced by
-   * name or identifier.  If undefined, variables cannot be referenced by name or identifier,
-   * and can only be referenced using a valid `VarSpec`.
-   */
-  constructor(listing) {
-    this.listing = listing;
-    this.outputsLengthInElements = 0;
-    this.outputIndicesLengthInElements = 0;
-  }
-  // from RunModelParams interface
-  getInputs() {
-    return void 0;
-  }
-  // from RunModelParams interface
-  copyInputs(array, create) {
-    const inputsLengthInElements = this.inputs.length;
-    if (array === void 0 || array.length < inputsLengthInElements) {
-      array = create(inputsLengthInElements);
-    }
-    for (let i = 0; i < this.inputs.length; i++) {
-      const input = this.inputs[i];
-      if (typeof input === "number") {
-        array[i] = input;
-      } else {
-        array[i] = input.get();
-      }
-    }
-  }
-  // from RunModelParams interface
-  getOutputIndicesLength() {
-    return this.outputIndicesLengthInElements;
-  }
-  // from RunModelParams interface
-  getOutputIndices() {
-    return void 0;
-  }
-  // from RunModelParams interface
-  copyOutputIndices(array, create) {
-    if (this.outputIndicesLengthInElements === 0) {
-      return;
-    }
-    if (array === void 0 || array.length < this.outputIndicesLengthInElements) {
-      array = create(this.outputIndicesLengthInElements);
-    }
-    encodeVarIndices(this.outputs.varSpecs, array);
-  }
-  // from RunModelParams interface
-  getOutputsLength() {
-    return this.outputsLengthInElements;
-  }
-  // from RunModelParams interface
-  getOutputs() {
-    return void 0;
-  }
-  // from RunModelParams interface
-  getOutputsObject() {
-    return this.outputs;
-  }
-  // from RunModelParams interface
-  storeOutputs(array) {
-    if (this.outputs) {
-      const result = this.outputs.updateFromBuffer(array, this.outputs.seriesLength);
-      if (result.isErr()) {
-        throw new Error(`Failed to store outputs: ${result.error}`);
-      }
-    }
-  }
-  // 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;
-    } else {
-      return void 0;
-    }
-  }
-  // from RunModelParams interface
-  getElapsedTime() {
-    var _a;
-    return (_a = this.outputs) == null ? void 0 : _a.runTimeInMillis;
-  }
-  // from RunModelParams interface
-  storeElapsedTime(elapsed) {
-    if (this.outputs) {
-      this.outputs.runTimeInMillis = elapsed;
-    }
-  }
-  /**
-   * Update this instance using the parameters that are passed to a `runModel` call.
-   *
-   * @param inputs The model input values (must be in the same order as in the spec file).
-   * @param outputs The structure into which the model outputs will be stored.
-   * @param options Additional options that influence the model run.
-   */
-  updateFromParams(inputs, outputs, options) {
-    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");
-      }
-    }
-    const outputVarSpecs = outputs.varSpecs;
-    if (outputVarSpecs !== void 0 && outputVarSpecs.length > 0) {
-      this.outputIndicesLengthInElements = getEncodedVarIndicesLength(outputVarSpecs);
-    } else {
-      this.outputIndicesLengthInElements = 0;
-    }
-  }
+	/**
+	* @param listing The model listing that is used to locate a variable that is referenced by
+	* name or identifier.  If undefined, variables cannot be referenced by name or identifier,
+	* and can only be referenced using a valid `VarSpec`.
+	*/
+	constructor(listing) {
+		this.listing = listing;
+		this.outputsLengthInElements = 0;
+		this.outputIndicesLengthInElements = 0;
+	}
+	getInputs() {}
+	copyInputs(array, create) {
+		const inputsLengthInElements = this.inputs.length;
+		if (array === void 0 || array.length < inputsLengthInElements) array = create(inputsLengthInElements);
+		for (let i = 0; i < this.inputs.length; i++) {
+			const input = this.inputs[i];
+			if (typeof input === "number") array[i] = input;
+			else array[i] = input.get();
+		}
+	}
+	getOutputIndicesLength() {
+		return this.outputIndicesLengthInElements;
+	}
+	getOutputIndices() {}
+	copyOutputIndices(array, create) {
+		if (this.outputIndicesLengthInElements === 0) return;
+		if (array === void 0 || array.length < this.outputIndicesLengthInElements) array = create(this.outputIndicesLengthInElements);
+		encodeVarIndices(this.outputs.varSpecs, array);
+	}
+	getOutputsLength() {
+		return this.outputsLengthInElements;
+	}
+	getOutputs() {}
+	getOutputsObject() {
+		return this.outputs;
+	}
+	storeOutputs(array) {
+		if (this.outputs) {
+			const result = this.outputs.updateFromBuffer(array, this.outputs.seriesLength);
+			if (result.isErr()) throw new Error(`Failed to store outputs: ${result.error}`);
+		}
+	}
+	getConstants() {
+		if (this.constants !== void 0 && this.constants.length > 0) return this.constants;
+		else return;
+	}
+	getLookups() {
+		if (this.lookups !== void 0 && this.lookups.length > 0) return this.lookups;
+		else return;
+	}
+	getElapsedTime() {
+		return this.outputs?.runTimeInMillis;
+	}
+	storeElapsedTime(elapsed) {
+		if (this.outputs) this.outputs.runTimeInMillis = elapsed;
+	}
+	/**
+	* Update this instance using the parameters that are passed to a `runModel` call.
+	*
+	* @param inputs The model input values (must be in the same order as in the spec file).
+	* @param outputs The structure into which the model outputs will be stored.
+	* @param options Additional options that influence the model run.
+	*/
+	updateFromParams(inputs, outputs, options) {
+		this.inputs = inputs;
+		this.outputs = outputs;
+		this.outputsLengthInElements = outputs.varIds.length * outputs.seriesLength;
+		this.constants = options?.constants;
+		this.lookups = 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");
+		const outputVarSpecs = outputs.varSpecs;
+		if (outputVarSpecs !== void 0 && outputVarSpecs.length > 0) this.outputIndicesLengthInElements = getEncodedVarIndicesLength(outputVarSpecs);
+		else this.outputIndicesLengthInElements = 0;
+	}
 };
-
-// src/js-model/js-model-constants.ts
-var _NA_ = -Number.MAX_VALUE;
-
-// src/js-model/js-model-lookup.ts
+//#endregion
+//#region src/js-model/js-model-constants.ts
+const _NA_ = -Number.MAX_VALUE;
+//#endregion
+//#region src/js-model/js-model-lookup.ts
+/**
+* @hidden This is not yet part of the public API; for internal use only.
+*/
 var JsModelLookup = class {
-  /**
-   * @param size The number of (x,y) pairs in the lookup.
-   * @param data The lookup data, as (x,y) pairs.  The length of the array must be
-   * >= 2*n.  Note that the data will be stored by reference, so if there is a chance
-   * that the array will be reused or modified by other code, be sure to pass in a
-   * copy of the array.
-   */
-  constructor(size, data) {
-    if (data && data.length < size * 2) {
-      throw new Error(`Lookup data array length must be >= 2*size (length=${data.length} size=${size}`);
-    }
-    this.originalData = data;
-    this.originalSize = size;
-    this.dynamicData = void 0;
-    this.dynamicSize = 0;
-    this.activeData = this.originalData;
-    this.activeSize = this.originalSize;
-    this.lastInput = Number.MAX_VALUE;
-    this.lastHitIndex = 0;
-  }
-  /**
-   * Set new data for this lookup instance, or restore the original data.
-   *
-   * If `data` is undefined, the original data that was supplied to the constructor will
-   * be restored as the "active" data.  Otherwise, `data` will be copied to an internal
-   * data buffer, which will be the "active" data.  If `size` is greater than the size
-   * passed to previous calls, the internal data buffer will be grown as needed.
-   *
-   * @param size The number of (x,y) pairs in the lookup.
-   * @param data The lookup data, as (x,y) pairs.  The length of the array must be
-   * >= 2*n.  Note that the data will be copied into an internal data buffer, so it
-   * is not necessary to defensively copy data before calling this method.
-   */
-  setData(size, data) {
-    if (data) {
-      if (data.length < size * 2) {
-        throw new Error(`Lookup data array length must be >= 2*size (length=${data.length} size=${size}`);
-      }
-      const dataLengthInElems = size * 2;
-      if (this.dynamicData === void 0 || dataLengthInElems > this.dynamicData.length) {
-        this.dynamicData = new Float64Array(dataLengthInElems);
-      }
-      this.dynamicSize = size;
-      if (size > 0) {
-        const subarray = data.subarray(0, dataLengthInElems);
-        this.dynamicData.set(subarray);
-      }
-      this.activeData = this.dynamicData;
-      this.activeSize = this.dynamicSize;
-    } else {
-      this.activeData = this.originalData;
-      this.activeSize = this.originalSize;
-    }
-    this.invertedData = void 0;
-    this.lastInput = Number.MAX_VALUE;
-    this.lastHitIndex = 0;
-  }
-  getValueForX(x, mode) {
-    return this.getValue(x, false, mode);
-  }
-  getValueForY(y) {
-    if (this.invertedData === void 0) {
-      const numValues = this.activeSize * 2;
-      const normalData = this.activeData;
-      const invertedData = Array(numValues);
-      for (let i = 0; i < numValues; i += 2) {
-        invertedData[i] = normalData[i + 1];
-        invertedData[i + 1] = normalData[i];
-      }
-      this.invertedData = invertedData;
-    }
-    return this.getValue(y, true, "interpolate");
-  }
-  /**
-   * Interpolate the y value from the array of (x,y) pairs.
-   * NOTE: The x values are assumed to be monotonically increasing.
-   */
-  getValue(input, useInvertedData, mode) {
-    if (this.activeSize === 0) {
-      return _NA_;
-    }
-    const data = useInvertedData ? this.invertedData : this.activeData;
-    const max = this.activeSize * 2;
-    const useCachedValues = !useInvertedData;
-    let startIndex;
-    if (useCachedValues && input >= this.lastInput) {
-      startIndex = this.lastHitIndex;
-    } else {
-      startIndex = 0;
-    }
-    for (let xi = startIndex; xi < max; xi += 2) {
-      const x = data[xi];
-      if (x >= input) {
-        if (useCachedValues) {
-          this.lastInput = input;
-          this.lastHitIndex = xi;
-        }
-        if (xi === 0 || x === input) {
-          return data[xi + 1];
-        }
-        switch (mode) {
-          default:
-          case "interpolate": {
-            const last_x = data[xi - 2];
-            const last_y = data[xi - 1];
-            const y = data[xi + 1];
-            const dx = x - last_x;
-            const dy = y - last_y;
-            return last_y + dy / dx * (input - last_x);
-          }
-          case "forward":
-            return data[xi + 1];
-          case "backward":
-            return data[xi - 1];
-        }
-      }
-    }
-    if (useCachedValues) {
-      this.lastInput = input;
-      this.lastHitIndex = max;
-    }
-    return data[max - 1];
-  }
-  /**
-   * Return the most appropriate y value from the array of (x,y) pairs when
-   * this instance is used to provide inputs for the `GAME` function.
-   *
-   * NOTE: The x values are assumed to be monotonically increasing.
-   *
-   * This method is similar to `getValueForX` in concept, except that this one
-   * returns the provided `defaultValue` if the `time` parameter is earlier than
-   * the first data point in the lookup.  Also, this method always uses the
-   * `backward` interpolation mode, meaning that it holds the "current" value
-   * constant instead of interpolating.
-   *
-   * @param time The time that is used to select the data point that has an
-   * `x` value less than or equal to the provided time.
-   * @param defaultValue The value that is returned if this lookup is empty (has
-   * no points) or if the provided time is earlier than the first data point.
-   */
-  getValueForGameTime(time, defaultValue) {
-    if (this.activeSize <= 0) {
-      return defaultValue;
-    }
-    const x0 = this.activeData[0];
-    if (time < x0) {
-      return defaultValue;
-    }
-    return this.getValue(time, false, "backward");
-  }
-  /**
-   * Interpolate the y value from the array of (x,y) pairs.
-   * NOTE: The x values are assumed to be monotonically increasing.
-   *
-   * This method is similar to `getValue` in concept, but Vensim produces results for
-   * the `GET DATA BETWEEN TIMES` function that differ in unexpected ways from normal
-   * lookup behavior, so we implement it as a separate method here.
-   */
-  getValueBetweenTimes(input, mode) {
-    if (this.activeSize === 0) {
-      return _NA_;
-    }
-    const data = this.activeData;
-    const max = this.activeSize * 2;
-    switch (mode) {
-      case "forward": {
-        input = Math.floor(input);
-        for (let xi = 0; xi < max; xi += 2) {
-          const x = data[xi];
-          if (x >= input) {
-            return data[xi + 1];
-          }
-        }
-        return data[max - 1];
-      }
-      case "backward": {
-        input = Math.floor(input);
-        for (let xi = 2; xi < max; xi += 2) {
-          const x = data[xi];
-          if (x >= input) {
-            return data[xi - 1];
-          }
-        }
-        if (max >= 4) {
-          return data[max - 3];
-        } else {
-          return data[1];
-        }
-      }
-      case "interpolate":
-      default: {
-        if (input - Math.floor(input) > 0) {
-          let msg = `GET DATA BETWEEN TIMES was called with an input value (${input}) that has a fractional part. `;
-          msg += "When mode is 0 (interpolate) and the input value is not a whole number, Vensim produces unexpected ";
-          msg += "results that may differ from those produced by SDEverywhere.";
-          throw new Error(msg);
-        }
-        for (let xi = 2; xi < max; xi += 2) {
-          const x = data[xi];
-          if (x >= input) {
-            const last_x = data[xi - 2];
-            const last_y = data[xi - 1];
-            const y = data[xi + 1];
-            const dx = x - last_x;
-            const dy = y - last_y;
-            return last_y + dy / dx * (input - last_x);
-          }
-        }
-        return data[max - 1];
-      }
-    }
-  }
+	/**
+	* @param size The number of (x,y) pairs in the lookup.
+	* @param data The lookup data, as (x,y) pairs.  The length of the array must be
+	* >= 2*n.  Note that the data will be stored by reference, so if there is a chance
+	* that the array will be reused or modified by other code, be sure to pass in a
+	* copy of the array.
+	*/
+	constructor(size, data) {
+		if (data && data.length < size * 2) throw new Error(`Lookup data array length must be >= 2*size (length=${data.length} size=${size}`);
+		this.originalData = data;
+		this.originalSize = size;
+		this.dynamicData = void 0;
+		this.dynamicSize = 0;
+		this.activeData = this.originalData;
+		this.activeSize = this.originalSize;
+		this.lastInput = Number.MAX_VALUE;
+		this.lastHitIndex = 0;
+	}
+	/**
+	* Set new data for this lookup instance, or restore the original data.
+	*
+	* If `data` is undefined, the original data that was supplied to the constructor will
+	* be restored as the "active" data.  Otherwise, `data` will be copied to an internal
+	* data buffer, which will be the "active" data.  If `size` is greater than the size
+	* passed to previous calls, the internal data buffer will be grown as needed.
+	*
+	* @param size The number of (x,y) pairs in the lookup.
+	* @param data The lookup data, as (x,y) pairs.  The length of the array must be
+	* >= 2*n.  Note that the data will be copied into an internal data buffer, so it
+	* is not necessary to defensively copy data before calling this method.
+	*/
+	setData(size, data) {
+		if (data) {
+			if (data.length < size * 2) throw new Error(`Lookup data array length must be >= 2*size (length=${data.length} size=${size}`);
+			const dataLengthInElems = size * 2;
+			if (this.dynamicData === void 0 || dataLengthInElems > this.dynamicData.length) this.dynamicData = new Float64Array(dataLengthInElems);
+			this.dynamicSize = size;
+			if (size > 0) {
+				const subarray = data.subarray(0, dataLengthInElems);
+				this.dynamicData.set(subarray);
+			}
+			this.activeData = this.dynamicData;
+			this.activeSize = this.dynamicSize;
+		} else {
+			this.activeData = this.originalData;
+			this.activeSize = this.originalSize;
+		}
+		this.invertedData = void 0;
+		this.lastInput = Number.MAX_VALUE;
+		this.lastHitIndex = 0;
+	}
+	getValueForX(x, mode) {
+		return this.getValue(x, false, mode);
+	}
+	getValueForY(y) {
+		if (this.invertedData === void 0) {
+			const numValues = this.activeSize * 2;
+			const normalData = this.activeData;
+			const invertedData = Array(numValues);
+			for (let i = 0; i < numValues; i += 2) {
+				invertedData[i] = normalData[i + 1];
+				invertedData[i + 1] = normalData[i];
+			}
+			this.invertedData = invertedData;
+		}
+		return this.getValue(y, true, "interpolate");
+	}
+	/**
+	* Interpolate the y value from the array of (x,y) pairs.
+	* NOTE: The x values are assumed to be monotonically increasing.
+	*/
+	getValue(input, useInvertedData, mode) {
+		if (this.activeSize === 0) return _NA_;
+		const data = useInvertedData ? this.invertedData : this.activeData;
+		const max = this.activeSize * 2;
+		const useCachedValues = !useInvertedData;
+		let startIndex;
+		if (useCachedValues && input >= this.lastInput) startIndex = this.lastHitIndex;
+		else startIndex = 0;
+		for (let xi = startIndex; xi < max; xi += 2) {
+			const x = data[xi];
+			if (x >= input) {
+				if (useCachedValues) {
+					this.lastInput = input;
+					this.lastHitIndex = xi;
+				}
+				if (xi === 0 || x === input) return data[xi + 1];
+				switch (mode) {
+					default:
+					case "interpolate": {
+						const last_x = data[xi - 2];
+						const last_y = data[xi - 1];
+						const y = data[xi + 1];
+						const dx = x - last_x;
+						return last_y + (y - last_y) / dx * (input - last_x);
+					}
+					case "forward": return data[xi + 1];
+					case "backward": return data[xi - 1];
+				}
+			}
+		}
+		if (useCachedValues) {
+			this.lastInput = input;
+			this.lastHitIndex = max;
+		}
+		return data[max - 1];
+	}
+	/**
+	* Return the most appropriate y value from the array of (x,y) pairs when
+	* this instance is used to provide inputs for the `GAME` function.
+	*
+	* NOTE: The x values are assumed to be monotonically increasing.
+	*
+	* This method is similar to `getValueForX` in concept, except that this one
+	* returns the provided `defaultValue` if the `time` parameter is earlier than
+	* the first data point in the lookup.  Also, this method always uses the
+	* `backward` interpolation mode, meaning that it holds the "current" value
+	* constant instead of interpolating.
+	*
+	* @param time The time that is used to select the data point that has an
+	* `x` value less than or equal to the provided time.
+	* @param defaultValue The value that is returned if this lookup is empty (has
+	* no points) or if the provided time is earlier than the first data point.
+	*/
+	getValueForGameTime(time, defaultValue) {
+		if (this.activeSize <= 0) return defaultValue;
+		if (time < this.activeData[0]) return defaultValue;
+		return this.getValue(time, false, "backward");
+	}
+	/**
+	* Interpolate the y value from the array of (x,y) pairs.
+	* NOTE: The x values are assumed to be monotonically increasing.
+	*
+	* This method is similar to `getValue` in concept, but Vensim produces results for
+	* the `GET DATA BETWEEN TIMES` function that differ in unexpected ways from normal
+	* lookup behavior, so we implement it as a separate method here.
+	*/
+	getValueBetweenTimes(input, mode) {
+		if (this.activeSize === 0) return _NA_;
+		const data = this.activeData;
+		const max = this.activeSize * 2;
+		switch (mode) {
+			case "forward":
+				input = Math.floor(input);
+				for (let xi = 0; xi < max; xi += 2) if (data[xi] >= input) return data[xi + 1];
+				return data[max - 1];
+			case "backward":
+				input = Math.floor(input);
+				for (let xi = 2; xi < max; xi += 2) if (data[xi] >= input) return data[xi - 1];
+				if (max >= 4) return data[max - 3];
+				else return data[1];
+			default:
+				if (input - Math.floor(input) > 0) {
+					let msg = `GET DATA BETWEEN TIMES was called with an input value (${input}) that has a fractional part. `;
+					msg += "When mode is 0 (interpolate) and the input value is not a whole number, Vensim produces unexpected ";
+					msg += "results that may differ from those produced by SDEverywhere.";
+					throw new Error(msg);
+				}
+				for (let xi = 2; xi < max; xi += 2) {
+					const x = data[xi];
+					if (x >= input) {
+						const last_x = data[xi - 2];
+						const last_y = data[xi - 1];
+						const y = data[xi + 1];
+						const dx = x - last_x;
+						return last_y + (y - last_y) / dx * (input - last_x);
+					}
+				}
+				return data[max - 1];
+		}
+	}
 };
-
-// src/js-model/js-model-functions.ts
-var EPSILON = 1e-6;
+//#endregion
+//#region src/js-model/js-model-functions.ts
+const EPSILON = 1e-6;
+/**
+* Returns a default implementation of the `JsModelFunctions` interface.  If needed,
+* you can provide a custom implementation of any exposed function by overriding
+* (setting) a new function implementation on the returned instance.
+*
+* @hidden This is not yet part of the public API; for internal use by generated
+* `JsModel` implementations.
+*/
 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;
-    },
-    ABS(x) {
-      return Math.abs(x);
-    },
-    ARCCOS(x) {
-      return Math.acos(x);
-    },
-    ARCSIN(x) {
-      return Math.asin(x);
-    },
-    ARCTAN(x) {
-      return Math.atan(x);
-    },
-    COS(x) {
-      return Math.cos(x);
-    },
-    EXP(x) {
-      return Math.exp(x);
-    },
-    GAME(inputs, x) {
-      return inputs ? inputs.getValueForGameTime(ctx.currentTime, x) : x;
-    },
-    // GAMMA_LN(): number {
-    //   throw new Error('GAMMA_LN function not yet implemented for JS target')
-    // },
-    INTEG(value, rate) {
-      return value + rate * ctx.timeStep;
-    },
-    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);
-    },
-    MAX(x, y) {
-      return Math.max(x, y);
-    },
-    MIN(x, y) {
-      return Math.min(x, y);
-    },
-    MODULO(x, y) {
-      return x % y;
-    },
-    POW(x, y) {
-      return Math.pow(x, y);
-    },
-    POWER(x, y) {
-      return Math.pow(x, y);
-    },
-    PULSE(start, width) {
-      return pulse(ctx, start, width);
-    },
-    PULSE_TRAIN(start, width, interval, end) {
-      const n = Math.floor((end - start) / interval);
-      for (let k = 0; k <= n; k++) {
-        if (ctx.currentTime <= end && pulse(ctx, start + k * interval, width)) {
-          return 1;
-        }
-      }
-      return 0;
-    },
-    QUANTUM(x, y) {
-      return y <= 0 ? x : y * Math.trunc(x / y);
-    },
-    RAMP(slope, startTime, endTime) {
-      if (ctx.currentTime > startTime) {
-        if (ctx.currentTime < endTime || startTime > endTime) {
-          return slope * (ctx.currentTime - startTime);
-        } else {
-          return slope * (endTime - startTime);
-        }
-      } else {
-        return 0;
-      }
-    },
-    SIN(x) {
-      return Math.sin(x);
-    },
-    SQRT(x) {
-      return Math.sqrt(x);
-    },
-    STEP(height, stepTime) {
-      return ctx.currentTime + ctx.timeStep / 2 > stepTime ? height : 0;
-    },
-    TAN(x) {
-      return Math.tan(x);
-    },
-    VECTOR_SORT_ORDER(vector, size, direction) {
-      if (size > vector.length) {
-        throw new Error(`VECTOR SORT ORDER input vector length (${vector.length}) must be >= size (${size})`);
-      }
-      let sortVector = cachedSortVectors.get(size);
-      if (sortVector === void 0) {
-        sortVector = Array(size);
-        for (let i = 0; i < size; i++) {
-          sortVector[i] = { x: 0, ind: 0 };
-        }
-        cachedSortVectors.set(size, sortVector);
-      }
-      let outArray = cachedVectors.get(size);
-      if (outArray === void 0) {
-        outArray = Array(size);
-        cachedVectors.set(size, outArray);
-      }
-      for (let i = 0; i < size; i++) {
-        sortVector[i].x = vector[i];
-        sortVector[i].ind = i;
-      }
-      const sortOrder = direction > 0 ? 1 : -1;
-      sortVector.sort((a, b) => {
-        let result;
-        if (a.x < b.x) {
-          result = -1;
-        } else if (a.x > b.x) {
-          result = 1;
-        } else {
-          result = 0;
-        }
-        return result * sortOrder;
-      });
-      for (let i = 0; i < size; i++) {
-        outArray[i] = sortVector[i].ind;
-      }
-      return outArray;
-    },
-    XIDZ(a, b, x) {
-      return Math.abs(b) < EPSILON ? x : a / b;
-    },
-    ZIDZ(a, b) {
-      if (Math.abs(b) < EPSILON) {
-        return 0;
-      } else {
-        return a / b;
-      }
-    },
-    //
-    // Lookup functions
-    //
-    createLookup(size, data) {
-      return new JsModelLookup(size, data);
-    },
-    LOOKUP(lookup, x) {
-      return lookup ? lookup.getValueForX(x, "interpolate") : _NA_;
-    },
-    LOOKUP_FORWARD(lookup, x) {
-      return lookup ? lookup.getValueForX(x, "forward") : _NA_;
-    },
-    LOOKUP_BACKWARD(lookup, x) {
-      return lookup ? lookup.getValueForX(x, "backward") : _NA_;
-    },
-    LOOKUP_INVERT(lookup, y) {
-      return lookup ? lookup.getValueForY(y) : _NA_;
-    },
-    WITH_LOOKUP(x, lookup) {
-      return lookup ? lookup.getValueForX(x, "interpolate") : _NA_;
-    },
-    GET_DATA_BETWEEN_TIMES(lookup, x, mode) {
-      let lookupMode;
-      if (mode >= 1) {
-        lookupMode = "forward";
-      } else if (mode <= -1) {
-        lookupMode = "backward";
-      } else {
-        lookupMode = "interpolate";
-      }
-      return lookup ? lookup.getValueBetweenTimes(x, lookupMode) : _NA_;
-    }
-  };
+	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;
+		},
+		ABS(x) {
+			return Math.abs(x);
+		},
+		ARCCOS(x) {
+			return Math.acos(x);
+		},
+		ARCSIN(x) {
+			return Math.asin(x);
+		},
+		ARCTAN(x) {
+			return Math.atan(x);
+		},
+		COS(x) {
+			return Math.cos(x);
+		},
+		EXP(x) {
+			return Math.exp(x);
+		},
+		GAME(inputs, x) {
+			return inputs ? inputs.getValueForGameTime(ctx.currentTime, x) : x;
+		},
+		INTEG(value, rate) {
+			return value + rate * ctx.timeStep;
+		},
+		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);
+		},
+		MAX(x, y) {
+			return Math.max(x, y);
+		},
+		MIN(x, y) {
+			return Math.min(x, y);
+		},
+		MODULO(x, y) {
+			return x % y;
+		},
+		POW(x, y) {
+			return Math.pow(x, y);
+		},
+		POWER(x, y) {
+			return Math.pow(x, y);
+		},
+		PULSE(start, width) {
+			return pulse(ctx, start, width);
+		},
+		PULSE_TRAIN(start, width, interval, end) {
+			const n = Math.floor((end - start) / interval);
+			for (let k = 0; k <= n; k++) if (ctx.currentTime <= end && pulse(ctx, start + k * interval, width)) return 1;
+			return 0;
+		},
+		QUANTUM(x, y) {
+			return y <= 0 ? x : y * Math.trunc(x / y);
+		},
+		RAMP(slope, startTime, endTime) {
+			if (ctx.currentTime > startTime) {
+				if (ctx.currentTime < endTime || startTime > endTime) return slope * (ctx.currentTime - startTime);
+				else return slope * (endTime - startTime);
+			} else return 0;
+		},
+		SIN(x) {
+			return Math.sin(x);
+		},
+		SQRT(x) {
+			return Math.sqrt(x);
+		},
+		STEP(height, stepTime) {
+			return ctx.currentTime + ctx.timeStep / 2 > stepTime ? height : 0;
+		},
+		TAN(x) {
+			return Math.tan(x);
+		},
+		VECTOR_SORT_ORDER(vector, size, direction) {
+			if (size > vector.length) throw new Error(`VECTOR SORT ORDER input vector length (${vector.length}) must be >= size (${size})`);
+			let sortVector = cachedSortVectors.get(size);
+			if (sortVector === void 0) {
+				sortVector = Array(size);
+				for (let i = 0; i < size; i++) sortVector[i] = {
+					x: 0,
+					ind: 0
+				};
+				cachedSortVectors.set(size, sortVector);
+			}
+			let outArray = cachedVectors.get(size);
+			if (outArray === void 0) {
+				outArray = Array(size);
+				cachedVectors.set(size, outArray);
+			}
+			for (let i = 0; i < size; i++) {
+				sortVector[i].x = vector[i];
+				sortVector[i].ind = i;
+			}
+			const sortOrder = direction > 0 ? 1 : -1;
+			sortVector.sort((a, b) => {
+				let result;
+				if (a.x < b.x) result = -1;
+				else if (a.x > b.x) result = 1;
+				else result = 0;
+				return result * sortOrder;
+			});
+			for (let i = 0; i < size; i++) outArray[i] = sortVector[i].ind;
+			return outArray;
+		},
+		XIDZ(a, b, x) {
+			return Math.abs(b) < EPSILON ? x : a / b;
+		},
+		ZIDZ(a, b) {
+			if (Math.abs(b) < EPSILON) return 0;
+			else return a / b;
+		},
+		createLookup(size, data) {
+			return new JsModelLookup(size, data);
+		},
+		LOOKUP(lookup, x) {
+			return lookup ? lookup.getValueForX(x, "interpolate") : _NA_;
+		},
+		LOOKUP_FORWARD(lookup, x) {
+			return lookup ? lookup.getValueForX(x, "forward") : _NA_;
+		},
+		LOOKUP_BACKWARD(lookup, x) {
+			return lookup ? lookup.getValueForX(x, "backward") : _NA_;
+		},
+		LOOKUP_INVERT(lookup, y) {
+			return lookup ? lookup.getValueForY(y) : _NA_;
+		},
+		WITH_LOOKUP(x, lookup) {
+			return lookup ? lookup.getValueForX(x, "interpolate") : _NA_;
+		},
+		GET_DATA_BETWEEN_TIMES(lookup, x, mode) {
+			let lookupMode;
+			if (mode >= 1) lookupMode = "forward";
+			else if (mode <= -1) lookupMode = "backward";
+			else lookupMode = "interpolate";
+			return lookup ? lookup.getValueBetweenTimes(x, lookupMode) : _NA_;
+		}
+	};
 }
 function pulse(ctx, start, width) {
-  const timePlus = ctx.currentTime + ctx.timeStep / 2;
-  if (width === 0) {
-    width = ctx.timeStep;
-  }
-  return timePlus > start && timePlus < start + width ? 1 : 0;
+	const timePlus = ctx.currentTime + ctx.timeStep / 2;
+	if (width === 0) width = ctx.timeStep;
+	return timePlus > start && timePlus < start + width ? 1 : 0;
 }
-
-// src/perf/perf.ts
-var isWeb;
+//#endregion
+//#region src/perf/perf.ts
+let isWeb;
+/**
+* Return a timestamp that can be passed to `perfElapsed` for calculating the elapsed
+* time of an operation.
+*
+* @hidden This is not part of the public API; exposed only for use in performance testing.
+*/
 function perfNow() {
-  if (isWeb === void 0) {
-    isWeb = typeof self !== "undefined" && (self == null ? void 0 : self.performance) !== void 0;
-  }
-  if (isWeb) {
-    return self.performance.now();
-  } else {
-    return process == null ? void 0 : process.hrtime();
-  }
+	if (isWeb === void 0) isWeb = typeof self !== "undefined" && self?.performance !== void 0;
+	if (isWeb) return self.performance.now();
+	else return process?.hrtime();
 }
+/**
+* Return the elapsed time between the given timestamp (created by `perfNow`) and now.
+*
+* @hidden This is not part of the public API; exposed only for use in performance testing.
+*/
 function perfElapsed(t0) {
-  if (isWeb) {
-    const t1 = self.performance.now();
-    return t1 - t0;
-  } else {
-    const elapsed = process.hrtime(t0);
-    return (elapsed[0] * 1e9 + elapsed[1]) / 1e6;
-  }
+	if (isWeb) return self.performance.now() - t0;
+	else {
+		const elapsed = process.hrtime(t0);
+		return (elapsed[0] * 1e9 + elapsed[1]) / 1e6;
+	}
 }
-
-// src/runnable-model/base-runnable-model.ts
+//#endregion
+//#region src/runnable-model/base-runnable-model.ts
+/**
+* A base implementation of the `RunnableModel` interface that takes care
+* of managing internal buffers and copying values to/from the `RunModelParams`.
+*
+* The `onRunModel` function allows an implementation of the core model run loop
+* to deal with typed arrays only.
+*
+* @hidden This is not part of the public API; for internal use only.
+*/
 var BaseRunnableModel = class {
-  constructor(options) {
-    this.startTime = options.startTime;
-    this.endTime = options.endTime;
-    this.saveFreq = options.saveFreq;
-    this.numSavePoints = options.numSavePoints;
-    this.outputVarIds = options.outputVarIds;
-    this.modelListing = options.modelListing;
-    this.onRunModel = options.onRunModel;
-  }
-  // from RunnableModel interface
-  runModel(params) {
-    var _a;
-    let inputsArray = params.getInputs();
-    if (inputsArray === void 0) {
-      params.copyInputs(this.inputs, (numElements) => {
-        this.inputs = new Float64Array(numElements);
-        return this.inputs;
-      });
-      inputsArray = this.inputs;
-    }
-    let outputIndicesArray = params.getOutputIndices();
-    if (outputIndicesArray === void 0 && params.getOutputIndicesLength() > 0) {
-      params.copyOutputIndices(this.outputIndices, (numElements) => {
-        this.outputIndices = new Int32Array(numElements);
-        return this.outputIndices;
-      });
-      outputIndicesArray = this.outputIndices;
-    }
-    const outputsLengthInElements = params.getOutputsLength();
-    if (this.outputs === void 0 || this.outputs.length < outputsLengthInElements) {
-      this.outputs = new Float64Array(outputsLengthInElements);
-    }
-    const outputsArray = this.outputs;
-    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);
-    params.storeOutputs(outputsArray);
-    params.storeElapsedTime(elapsed);
-  }
-  // from RunnableModel interface
-  terminate() {
-  }
+	constructor(options) {
+		this.startTime = options.startTime;
+		this.endTime = options.endTime;
+		this.saveFreq = options.saveFreq;
+		this.numSavePoints = options.numSavePoints;
+		this.outputVarIds = options.outputVarIds;
+		this.modelListing = options.modelListing;
+		this.onRunModel = options.onRunModel;
+	}
+	runModel(params) {
+		let inputsArray = params.getInputs();
+		if (inputsArray === void 0) {
+			params.copyInputs(this.inputs, (numElements) => {
+				this.inputs = new Float64Array(numElements);
+				return this.inputs;
+			});
+			inputsArray = this.inputs;
+		}
+		let outputIndicesArray = params.getOutputIndices();
+		if (outputIndicesArray === void 0 && params.getOutputIndicesLength() > 0) {
+			params.copyOutputIndices(this.outputIndices, (numElements) => {
+				this.outputIndices = new Int32Array(numElements);
+				return this.outputIndices;
+			});
+			outputIndicesArray = this.outputIndices;
+		}
+		const outputsLengthInElements = params.getOutputsLength();
+		if (this.outputs === void 0 || this.outputs.length < outputsLengthInElements) this.outputs = new Float64Array(outputsLengthInElements);
+		const outputsArray = this.outputs;
+		const t0 = perfNow();
+		this.onRunModel?.(inputsArray, outputsArray, {
+			outputIndices: outputIndicesArray,
+			constants: params.getConstants(),
+			lookups: params.getLookups()
+		});
+		const elapsed = perfElapsed(t0);
+		params.storeOutputs(outputsArray);
+		params.storeElapsedTime(elapsed);
+	}
+	terminate() {}
 };
-
-// src/js-model/js-model.ts
+//#endregion
+//#region src/js-model/js-model.ts
+/**
+* Create a `RunnableModel` from a given `JsModel` that was generated by the
+* SDEverywhere transpiler.
+*
+* @hidden This is not part of the public API; only the top-level `createRunnableModel`
+* function is exposed in the public API.
+*/
 function initJsModel(model) {
-  let fns = model.getModelFunctions();
-  if (fns === void 0) {
-    fns = getJsModelFunctions();
-    model.setModelFunctions(fns);
-  }
-  const initialTime = model.getInitialTime();
-  const finalTime = model.getFinalTime();
-  const timeStep = model.getTimeStep();
-  const saveFreq = model.getSaveFreq();
-  const numSavePoints = Math.round((finalTime - initialTime) / saveFreq) + 1;
-  return new BaseRunnableModel({
-    startTime: initialTime,
-    endTime: finalTime,
-    saveFreq,
-    numSavePoints,
-    outputVarIds: model.outputVarIds,
-    modelListing: model.modelListing,
-    onRunModel: (inputs, outputs, options) => {
-      runJsModel(
-        model,
-        initialTime,
-        finalTime,
-        timeStep,
-        saveFreq,
-        numSavePoints,
-        inputs,
-        outputs,
-        options == null ? void 0 : options.outputIndices,
-        options == null ? void 0 : options.constants,
-        options == null ? void 0 : options.lookups,
-        void 0
-      );
-    }
-  });
+	let fns = model.getModelFunctions();
+	if (fns === void 0) {
+		fns = getJsModelFunctions();
+		model.setModelFunctions(fns);
+	}
+	const initialTime = model.getInitialTime();
+	const finalTime = model.getFinalTime();
+	const timeStep = model.getTimeStep();
+	const saveFreq = model.getSaveFreq();
+	const numSavePoints = Math.round((finalTime - initialTime) / saveFreq) + 1;
+	return new BaseRunnableModel({
+		startTime: initialTime,
+		endTime: finalTime,
+		saveFreq,
+		numSavePoints,
+		outputVarIds: model.outputVarIds,
+		modelListing: model.modelListing,
+		onRunModel: (inputs, outputs, options) => {
+			runJsModel(model, initialTime, finalTime, timeStep, saveFreq, numSavePoints, inputs, outputs, options?.outputIndices, options?.constants, options?.lookups, void 0);
+		}
+	});
 }
 function runJsModel(model, initialTime, finalTime, timeStep, saveFreq, numSavePoints, inputs, outputs, outputIndices, constants, lookups, stopAfterTime) {
-  let time = initialTime;
-  model.setTime(time);
-  const fnContext = {
-    timeStep,
-    currentTime: time
-  };
-  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);
-    }
-  }
-  if ((inputs == null ? void 0 : inputs.length) > 0) {
-    model.setInputs((index) => inputs[index]);
-  }
-  model.initLevels();
-  const lastStep = Math.round((finalTime - initialTime) / timeStep);
-  const stopTime = stopAfterTime !== void 0 ? stopAfterTime : finalTime;
-  let step = 0;
-  let savePointIndex = 0;
-  let outputVarIndex = 0;
-  while (step <= lastStep) {
-    model.evalAux();
-    if (time % saveFreq < 1e-6) {
-      outputVarIndex = 0;
-      const storeValue = (value) => {
-        const outputBufferIndex = outputVarIndex * numSavePoints + savePointIndex;
-        outputs[outputBufferIndex] = time <= stopTime ? value : void 0;
-        outputVarIndex++;
-      };
-      if (outputIndices !== void 0) {
-        let indexBufferOffset = 0;
-        const outputCount = outputIndices[indexBufferOffset++];
-        for (let i = 0; i < outputCount; i++) {
-          const varIndex = outputIndices[indexBufferOffset++];
-          const subCount = outputIndices[indexBufferOffset++];
-          let subscriptIndices;
-          if (subCount > 0) {
-            subscriptIndices = outputIndices.subarray(indexBufferOffset, indexBufferOffset + subCount);
-            indexBufferOffset += subCount;
-          }
-          const varSpec = {
-            varIndex,
-            subscriptIndices
-          };
-          model.storeOutput(varSpec, storeValue);
-        }
-      } else {
-        model.storeOutputs(storeValue);
-      }
-      savePointIndex++;
-    }
-    if (step === lastStep) {
-      break;
-    }
-    model.evalLevels();
-    time += timeStep;
-    model.setTime(time);
-    fnContext.currentTime = time;
-    step++;
-  }
+	let time = initialTime;
+	model.setTime(time);
+	const fnContext = {
+		timeStep,
+		currentTime: time
+	};
+	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);
+	if (inputs?.length > 0) model.setInputs((index) => inputs[index]);
+	model.initLevels();
+	const lastStep = Math.round((finalTime - initialTime) / timeStep);
+	const stopTime = stopAfterTime !== void 0 ? stopAfterTime : finalTime;
+	let step = 0;
+	let savePointIndex = 0;
+	let outputVarIndex = 0;
+	while (step <= lastStep) {
+		model.evalAux();
+		if (time % saveFreq < 1e-6) {
+			outputVarIndex = 0;
+			const storeValue = (value) => {
+				const outputBufferIndex = outputVarIndex * numSavePoints + savePointIndex;
+				outputs[outputBufferIndex] = time <= stopTime ? value : void 0;
+				outputVarIndex++;
+			};
+			if (outputIndices !== void 0) {
+				let indexBufferOffset = 0;
+				const outputCount = outputIndices[indexBufferOffset++];
+				for (let i = 0; i < outputCount; i++) {
+					const varIndex = outputIndices[indexBufferOffset++];
+					const subCount = outputIndices[indexBufferOffset++];
+					let subscriptIndices;
+					if (subCount > 0) {
+						subscriptIndices = outputIndices.subarray(indexBufferOffset, indexBufferOffset + subCount);
+						indexBufferOffset += subCount;
+					}
+					const varSpec = {
+						varIndex,
+						subscriptIndices
+					};
+					model.storeOutput(varSpec, storeValue);
+				}
+			} else model.storeOutputs(storeValue);
+			savePointIndex++;
+		}
+		if (step === lastStep) break;
+		model.evalLevels();
+		time += timeStep;
+		model.setTime(time);
+		fnContext.currentTime = time;
+		step++;
+	}
 }
-
-// src/js-model/exec-js-model.ts
+//#endregion
+//#region src/js-model/exec-js-model.ts
+/**
+* Run the given model synchronously and log the output values to the console in
+* TSV (tab-separated values) format.
+*
+* @hidden This is mainly intended for use in implementing the `sde exec` command,
+* so isn't exposed in the public API at this time.
+*
+* @param jsModel A `JsModel` instance.
+*/
 function execJsModel(jsModel) {
-  const runnableModel = initJsModel(jsModel);
-  const inputs = [];
-  const outputVarIds = jsModel.outputVarIds;
-  const startTime = jsModel.getInitialTime();
-  const endTime = jsModel.getFinalTime();
-  const saveFreq = jsModel.getSaveFreq();
-  const outputs = new Outputs(outputVarIds, startTime, endTime, saveFreq);
-  const params = new ReferencedRunModelParams();
-  params.updateFromParams(inputs, outputs);
-  runnableModel.runModel(params);
-  const outputVarNames = jsModel.outputVarNames.map((name) => name.replace(/"/g, '\\"'));
-  const header = outputVarNames.join("	");
-  console.log(header);
-  for (let i = 0; i < outputs.seriesLength; i++) {
-    const rowValues = [];
-    for (const series of outputs.varSeries) {
-      rowValues.push(series.points[i].y);
-    }
-    console.log(rowValues.join("	"));
-  }
+	const runnableModel = initJsModel(jsModel);
+	const inputs = [];
+	const outputVarIds = jsModel.outputVarIds;
+	const outputs = new Outputs(outputVarIds, jsModel.getInitialTime(), jsModel.getFinalTime(), jsModel.getSaveFreq());
+	const params = new ReferencedRunModelParams();
+	params.updateFromParams(inputs, outputs);
+	runnableModel.runModel(params);
+	const header = jsModel.outputVarNames.map((name) => name.replace(/"/g, "\\\"")).join("	");
+	console.log(header);
+	for (let i = 0; i < outputs.seriesLength; i++) {
+		const rowValues = [];
+		for (const series of outputs.varSeries) rowValues.push(series.points[i].y);
+		console.log(rowValues.join("	"));
+	}
 }
-
-// src/js-model/_mocks/mock-js-model.ts
+//#endregion
+//#region src/js-model/_mocks/mock-js-model.ts
+/**
+* @hidden This type is not part of the public API; it is exposed only for use in
+* tests in the runtime-async package.
+*/
 var MockJsModel = class {
-  constructor(options) {
-    // 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;
-    this.initialTime = options.initialTime;
-    this.finalTime = options.finalTime;
-    this.outputVarIds = options.outputVarIds;
-    if (options.listingJson) {
-      this.modelListing = JSON.parse(options.listingJson);
-      this.internalListing = new ModelListing(this.modelListing);
-    }
-    this.onEvalAux = options.onEvalAux;
-  }
-  varIdForSpec(varSpec) {
-    for (const [listingVarId, listingSpec] of this.internalListing.varSpecs) {
-      if (listingSpec.varIndex === varSpec.varIndex) {
-        return listingVarId;
-      }
-    }
-    return void 0;
-  }
-  // from JsModel interface
-  getInitialTime() {
-    return this.initialTime;
-  }
-  // from JsModel interface
-  getFinalTime() {
-    return this.finalTime;
-  }
-  // from JsModel interface
-  getTimeStep() {
-    return 1;
-  }
-  // from JsModel interface
-  getSaveFreq() {
-    return 1;
-  }
-  // from JsModel interface
-  getModelFunctions() {
-    return this.fns;
-  }
-  // from JsModel interface
-  setModelFunctions(fns) {
-    this.fns = fns;
-  }
-  // from JsModel interface
-  setTime(time) {
-    this.vars.set("_time", time);
-  }
-  // from JsModel interface
-  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) {
-      throw new Error(`No lookup variable found for spec ${varSpec}`);
-    }
-    const numPoints = points ? points.length / 2 : 0;
-    this.lookups.set(varId, new JsModelLookup(numPoints, points));
-  }
-  // from JsModel interface
-  storeOutputs(storeValue) {
-    for (const varId of this.outputVarIds) {
-      storeValue(this.vars.get(varId));
-    }
-  }
-  // from JsModel interface
-  storeOutput(varSpec, storeValue) {
-    const varId = this.varIdForSpec(varSpec);
-    if (varId === void 0) {
-      throw new Error(`No output variable found for spec ${varSpec}`);
-    }
-    storeValue(this.vars.get(varId));
-  }
-  // from JsModel interface
-  initConstants() {
-    this.constants.clear();
-  }
-  // from JsModel interface
-  initLevels() {
-  }
-  // from JsModel interface
-  evalAux() {
-    var _a;
-    (_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() {
-  }
+	constructor(options) {
+		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;
+		this.initialTime = options.initialTime;
+		this.finalTime = options.finalTime;
+		this.outputVarIds = options.outputVarIds;
+		if (options.listingJson) {
+			this.modelListing = JSON.parse(options.listingJson);
+			this.internalListing = new ModelListing(this.modelListing);
+		}
+		this.onEvalAux = options.onEvalAux;
+	}
+	varIdForSpec(varSpec) {
+		for (const [listingVarId, listingSpec] of this.internalListing.varSpecs) if (listingSpec.varIndex === varSpec.varIndex) return listingVarId;
+	}
+	getInitialTime() {
+		return this.initialTime;
+	}
+	getFinalTime() {
+		return this.finalTime;
+	}
+	getTimeStep() {
+		return 1;
+	}
+	getSaveFreq() {
+		return 1;
+	}
+	getModelFunctions() {
+		return this.fns;
+	}
+	setModelFunctions(fns) {
+		this.fns = fns;
+	}
+	setTime(time) {
+		this.vars.set("_time", time);
+	}
+	setInputs() {}
+	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);
+	}
+	setLookup(varSpec, points) {
+		const varId = this.varIdForSpec(varSpec);
+		if (varId === void 0) throw new Error(`No lookup variable found for spec ${varSpec}`);
+		const numPoints = points ? points.length / 2 : 0;
+		this.lookups.set(varId, new JsModelLookup(numPoints, points));
+	}
+	storeOutputs(storeValue) {
+		for (const varId of this.outputVarIds) storeValue(this.vars.get(varId));
+	}
+	storeOutput(varSpec, storeValue) {
+		const varId = this.varIdForSpec(varSpec);
+		if (varId === void 0) throw new Error(`No output variable found for spec ${varSpec}`);
+		storeValue(this.vars.get(varId));
+	}
+	initConstants() {
+		this.constants.clear();
+	}
+	initLevels() {}
+	evalAux() {
+		this.onEvalAux?.(this.vars, this.constants.size > 0 ? this.constants : void 0, this.lookups);
+	}
+	evalLevels() {}
 };
-
-// src/wasm-model/wasm-buffer.ts
+//#endregion
+//#region src/wasm-model/wasm-buffer.ts
+/**
+* Wraps a `WebAssembly.Memory` buffer allocated on the wasm heap.
+*
+* When this is used synchronously (in the browser's normal JavaScript thread),
+* the client can use `getArrayView` to write directly into the underlying memory.
+*
+* Note, however, that `WebAssembly.Memory` buffers cannot be transferred to/from
+* a Web Worker.  When using this class in a worker thread, create a separate
+* `Float64Array` that can be transferred between the worker and the client running
+* in the browser's normal JS thread, and then use `getArrayView` to copy into and
+* out of the wasm buffer.
+*
+* @hidden For internal use only.
+*/
 var WasmBuffer = class {
-  /**
-   * @param wasmModule The `WasmModule` used to initialize the memory.
-   * @param numElements The number of 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, numElements, byteOffset, heapArray) {
-    this.wasmModule = wasmModule;
-    this.numElements = 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() {
-    var _a, _b;
-    if (this.heapArray) {
-      (_b = (_a = this.wasmModule)._free) == null ? void 0 : _b.call(_a, this.byteOffset);
-      this.numElements = void 0;
-      this.heapArray = void 0;
-      this.byteOffset = void 0;
-    }
-  }
+	/**
+	* @param wasmModule The `WasmModule` used to initialize the memory.
+	* @param numElements The number of 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, numElements, byteOffset, heapArray) {
+		this.wasmModule = wasmModule;
+		this.numElements = 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);
+			this.numElements = void 0;
+			this.heapArray = void 0;
+			this.byteOffset = void 0;
+		}
+	}
 };
+/**
+* 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.
+*/
 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, numElements, byteOffset, heapArray);
+	const elemSizeInBytes = 4;
+	const lengthInBytes = numElements * elemSizeInBytes;
+	const byteOffset = wasmModule._malloc(lengthInBytes);
+	const elemOffset = byteOffset / elemSizeInBytes;
+	return new WasmBuffer(wasmModule, numElements, byteOffset, wasmModule.HEAP32.subarray(elemOffset, elemOffset + numElements));
 }
+/**
+* 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.
+*/
 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, numElements, byteOffset, heapArray);
+	const elemSizeInBytes = 8;
+	const lengthInBytes = numElements * elemSizeInBytes;
+	const byteOffset = wasmModule._malloc(lengthInBytes);
+	const elemOffset = byteOffset / elemSizeInBytes;
+	return new WasmBuffer(wasmModule, numElements, byteOffset, wasmModule.HEAPF64.subarray(elemOffset, elemOffset + numElements));
 }
-
-// src/wasm-model/wasm-model.ts
+//#endregion
+//#region src/wasm-model/wasm-model.ts
+/**
+* A wrapper around a WebAssembly module generated by the SDEverywhere transpiler,
+* which allows for running the model with a given set of input values, producing
+* a set of output values.
+*/
 var WasmModel = class {
-  /**
-   * @param wasmModule The `WasmModule` that provides access to the native functions.
-   * @param outputVarIds The output variable IDs for this model.
-   */
-  constructor(wasmModule) {
-    this.wasmModule = wasmModule;
-    function getNumberValue(funcName) {
-      const wasmGetValue = wasmModule.cwrap(funcName, "number", []);
-      return wasmGetValue();
-    }
-    this.startTime = getNumberValue("getInitialTime");
-    this.endTime = getNumberValue("getFinalTime");
-    this.saveFreq = getNumberValue("getSaveper");
-    this.numSavePoints = Math.round((this.endTime - this.startTime) / this.saveFreq) + 1;
-    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",
-      "number",
-      "number",
-      "number"
-    ]);
-  }
-  // from RunnableModel interface
-  runModel(params) {
-    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) {
-        const varSpec = lookupDef.varRef.varSpec;
-        const numSubElements = ((_a = varSpec.subscriptIndices) == null ? void 0 : _a.length) || 0;
-        let subIndicesAddress;
-        if (numSubElements > 0) {
-          if (this.lookupSubIndicesBuffer === void 0 || this.lookupSubIndicesBuffer.numElements < numSubElements) {
-            (_b = this.lookupSubIndicesBuffer) == null ? void 0 : _b.dispose();
-            this.lookupSubIndicesBuffer = createInt32WasmBuffer(this.wasmModule, numSubElements);
-          }
-          this.lookupSubIndicesBuffer.getArrayView().set(varSpec.subscriptIndices);
-          subIndicesAddress = this.lookupSubIndicesBuffer.getAddress();
-        } else {
-          subIndicesAddress = 0;
-        }
-        let pointsAddress;
-        let numPoints;
-        if (lookupDef.points) {
-          const numLookupElements = lookupDef.points.length;
-          if (this.lookupDataBuffer === void 0 || this.lookupDataBuffer.numElements < numLookupElements) {
-            (_c = this.lookupDataBuffer) == null ? void 0 : _c.dispose();
-            this.lookupDataBuffer = createFloat64WasmBuffer(this.wasmModule, numLookupElements);
-          }
-          this.lookupDataBuffer.getArrayView().set(lookupDef.points);
-          pointsAddress = this.lookupDataBuffer.getAddress();
-          numPoints = numLookupElements / 2;
-        } else {
-          pointsAddress = 0;
-          numPoints = 0;
-        }
-        const varIndex = varSpec.varIndex;
-        this.wasmSetLookup(varIndex, subIndicesAddress, pointsAddress, numPoints);
-      }
-    }
-    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);
-      return this.inputsBuffer.getArrayView();
-    });
-    let outputIndicesBuffer;
-    if (params.getOutputIndicesLength() > 0) {
-      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);
-        return this.outputIndicesBuffer.getArrayView();
-      });
-      outputIndicesBuffer = this.outputIndicesBuffer;
-    } else {
-      outputIndicesBuffer = void 0;
-    }
-    const outputsLengthInElements = params.getOutputsLength();
-    if (this.outputsBuffer === void 0 || this.outputsBuffer.numElements < outputsLengthInElements) {
-      (_j = this.outputsBuffer) == null ? void 0 : _j.dispose();
-      this.outputsBuffer = createFloat64WasmBuffer(this.wasmModule, outputsLengthInElements);
-    }
-    const t0 = perfNow();
-    this.wasmRunModel(
-      ((_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,
-      (constantValuesBuffer == null ? void 0 : constantValuesBuffer.getAddress()) || 0,
-      (constantIndicesBuffer == null ? void 0 : constantIndicesBuffer.getAddress()) || 0
-    );
-    const elapsed = perfElapsed(t0);
-    params.storeOutputs(this.outputsBuffer.getArrayView());
-    params.storeElapsedTime(elapsed);
-  }
-  // from RunnableModel interface
-  terminate() {
-    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;
-  }
+	/**
+	* @param wasmModule The `WasmModule` that provides access to the native functions.
+	* @param outputVarIds The output variable IDs for this model.
+	*/
+	constructor(wasmModule) {
+		this.wasmModule = wasmModule;
+		function getNumberValue(funcName) {
+			return wasmModule.cwrap(funcName, "number", [])();
+		}
+		this.startTime = getNumberValue("getInitialTime");
+		this.endTime = getNumberValue("getFinalTime");
+		this.saveFreq = getNumberValue("getSaveper");
+		this.numSavePoints = Math.round((this.endTime - this.startTime) / this.saveFreq) + 1;
+		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",
+			"number",
+			"number",
+			"number"
+		]);
+	}
+	runModel(params) {
+		const lookups = params.getLookups();
+		if (lookups !== void 0) for (const lookupDef of lookups) {
+			const varSpec = lookupDef.varRef.varSpec;
+			const numSubElements = varSpec.subscriptIndices?.length || 0;
+			let subIndicesAddress;
+			if (numSubElements > 0) {
+				if (this.lookupSubIndicesBuffer === void 0 || this.lookupSubIndicesBuffer.numElements < numSubElements) {
+					this.lookupSubIndicesBuffer?.dispose();
+					this.lookupSubIndicesBuffer = createInt32WasmBuffer(this.wasmModule, numSubElements);
+				}
+				this.lookupSubIndicesBuffer.getArrayView().set(varSpec.subscriptIndices);
+				subIndicesAddress = this.lookupSubIndicesBuffer.getAddress();
+			} else subIndicesAddress = 0;
+			let pointsAddress;
+			let numPoints;
+			if (lookupDef.points) {
+				const numLookupElements = lookupDef.points.length;
+				if (this.lookupDataBuffer === void 0 || this.lookupDataBuffer.numElements < numLookupElements) {
+					this.lookupDataBuffer?.dispose();
+					this.lookupDataBuffer = createFloat64WasmBuffer(this.wasmModule, numLookupElements);
+				}
+				this.lookupDataBuffer.getArrayView().set(lookupDef.points);
+				pointsAddress = this.lookupDataBuffer.getAddress();
+				numPoints = numLookupElements / 2;
+			} else {
+				pointsAddress = 0;
+				numPoints = 0;
+			}
+			const varIndex = varSpec.varIndex;
+			this.wasmSetLookup(varIndex, subIndicesAddress, pointsAddress, numPoints);
+		}
+		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 = constantDef.varRef.varSpec.subscriptIndices?.length || 0;
+				totalIndicesSize += 2 + numSubElements;
+			}
+			if (this.constantIndicesBuffer === void 0 || this.constantIndicesBuffer.numElements < totalIndicesSize) {
+				this.constantIndicesBuffer?.dispose();
+				this.constantIndicesBuffer = createInt32WasmBuffer(this.wasmModule, totalIndicesSize);
+			}
+			const numConstants = constants.length;
+			if (this.constantValuesBuffer === void 0 || this.constantValuesBuffer.numElements < numConstants) {
+				this.constantValuesBuffer?.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 = varSpec.subscriptIndices?.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(this.inputsBuffer?.getArrayView(), (numElements) => {
+			this.inputsBuffer?.dispose();
+			this.inputsBuffer = createFloat64WasmBuffer(this.wasmModule, numElements);
+			return this.inputsBuffer.getArrayView();
+		});
+		let outputIndicesBuffer;
+		if (params.getOutputIndicesLength() > 0) {
+			params.copyOutputIndices(this.outputIndicesBuffer?.getArrayView(), (numElements) => {
+				this.outputIndicesBuffer?.dispose();
+				this.outputIndicesBuffer = createInt32WasmBuffer(this.wasmModule, numElements);
+				return this.outputIndicesBuffer.getArrayView();
+			});
+			outputIndicesBuffer = this.outputIndicesBuffer;
+		} else outputIndicesBuffer = void 0;
+		const outputsLengthInElements = params.getOutputsLength();
+		if (this.outputsBuffer === void 0 || this.outputsBuffer.numElements < outputsLengthInElements) {
+			this.outputsBuffer?.dispose();
+			this.outputsBuffer = createFloat64WasmBuffer(this.wasmModule, outputsLengthInElements);
+		}
+		const t0 = perfNow();
+		this.wasmRunModel(this.inputsBuffer?.getAddress() || 0, 0, this.outputsBuffer.getAddress(), outputIndicesBuffer?.getAddress() || 0, constantValuesBuffer?.getAddress() || 0, constantIndicesBuffer?.getAddress() || 0);
+		const elapsed = perfElapsed(t0);
+		params.storeOutputs(this.outputsBuffer.getArrayView());
+		params.storeElapsedTime(elapsed);
+	}
+	terminate() {
+		this.inputsBuffer?.dispose();
+		this.inputsBuffer = void 0;
+		this.outputsBuffer?.dispose();
+		this.outputsBuffer = void 0;
+		this.outputIndicesBuffer?.dispose();
+		this.outputIndicesBuffer = void 0;
+		this.constantValuesBuffer?.dispose();
+		this.constantValuesBuffer = void 0;
+		this.constantIndicesBuffer?.dispose();
+		this.constantIndicesBuffer = void 0;
+	}
 };
+/**
+* Initialize the wasm model.
+*
+* @hidden This is not part of the public API; only the top-level `createRunnableModel`
+* function is exposed in the public API.
+*
+* @param wasmModule The `WasmModule` that wraps the `wasm` binary.
+* @return The initialized `WasmModel` instance.
+*/
 function initWasmModel(wasmModule) {
-  return new WasmModel(wasmModule);
+	return new WasmModel(wasmModule);
 }
-
-// src/wasm-model/_mocks/mock-wasm-module.ts
+//#endregion
+//#region src/wasm-model/_mocks/mock-wasm-module.ts
+/**
+* @hidden This type is not part of the public API; it is exposed only for use in
+* tests in the runtime-async package.
+*/
 var MockWasmModule = class {
-  constructor(options) {
-    // from WasmModule interface
-    this.kind = "wasm";
-    // Start at 8 so that we can treat 0 as NULL
-    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;
-    if (options.listingJson) {
-      this.modelListing = JSON.parse(options.listingJson);
-      this.internalListing = new ModelListing(this.modelListing);
-    }
-    this.onRunModel = options.onRunModel;
-    this.heap = new ArrayBuffer(8192);
-    this.HEAP32 = new Int32Array(this.heap);
-    this.HEAPF64 = new Float64Array(this.heap);
-  }
-  varIdForSpec(varSpec) {
-    for (const [listingVarId, listingSpec] of this.internalListing.varSpecs) {
-      if (listingSpec.varIndex === varSpec.varIndex) {
-        return listingVarId;
-      }
-    }
-    return void 0;
-  }
-  // from WasmModule interface
-  cwrap(fname) {
-    switch (fname) {
-      case "getInitialTime":
-        return () => this.initialTime;
-      case "getFinalTime":
-        return () => this.finalTime;
-      case "getSaveper":
-        return () => 1;
-      case "setLookup":
-        return (varIndex, _subIndicesAddress, pointsAddress, numPoints) => {
-          const varId = this.varIdForSpec({ varIndex });
-          if (varId === void 0) {
-            throw new Error(`No lookup variable found for var index ${varIndex}`);
-          }
-          const points = new Float64Array(this.getHeapView("float64", pointsAddress));
-          this.lookups.set(varId, new JsModelLookup(numPoints, points));
-        };
-      case "runModelWithBuffers":
-        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.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}'`);
-    }
-  }
-  // from WasmModule interface
-  _malloc(lengthInBytes) {
-    const currentOffset = this.mallocOffset;
-    this.allocs.set(currentOffset, lengthInBytes);
-    if (lengthInBytes > 0) {
-      this.mallocOffset += lengthInBytes;
-    } else {
-      this.mallocOffset += 8;
-    }
-    return currentOffset;
-  }
-  // from WasmModule interface
-  _free() {
-  }
-  getHeapView(kind, address) {
-    if (address === 0) {
-      return void 0;
-    }
-    const lengthInBytes = this.allocs.get(address);
-    if (lengthInBytes === void 0) {
-      throw new Error("Failed to locate heap allocation");
-    }
-    if (kind === "float64") {
-      const offset = address / 8;
-      return this.HEAPF64.subarray(offset, offset + lengthInBytes / 8);
-    } else {
-      const offset = address / 4;
-      return this.HEAP32.subarray(offset, offset + lengthInBytes / 4);
-    }
-  }
+	constructor(options) {
+		this.kind = "wasm";
+		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;
+		if (options.listingJson) {
+			this.modelListing = JSON.parse(options.listingJson);
+			this.internalListing = new ModelListing(this.modelListing);
+		}
+		this.onRunModel = options.onRunModel;
+		this.heap = /* @__PURE__ */ new ArrayBuffer(8192);
+		this.HEAP32 = new Int32Array(this.heap);
+		this.HEAPF64 = new Float64Array(this.heap);
+	}
+	varIdForSpec(varSpec) {
+		for (const [listingVarId, listingSpec] of this.internalListing.varSpecs) if (listingSpec.varIndex === varSpec.varIndex) return listingVarId;
+	}
+	cwrap(fname) {
+		switch (fname) {
+			case "getInitialTime": return () => this.initialTime;
+			case "getFinalTime": return () => this.finalTime;
+			case "getSaveper": return () => 1;
+			case "setLookup": return (varIndex, _subIndicesAddress, pointsAddress, numPoints) => {
+				const varId = this.varIdForSpec({ varIndex });
+				if (varId === void 0) throw new Error(`No lookup variable found for var index ${varIndex}`);
+				const points = new Float64Array(this.getHeapView("float64", pointsAddress));
+				this.lookups.set(varId, new JsModelLookup(numPoints, points));
+			};
+			case "runModelWithBuffers": 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.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}'`);
+		}
+	}
+	_malloc(lengthInBytes) {
+		const currentOffset = this.mallocOffset;
+		this.allocs.set(currentOffset, lengthInBytes);
+		if (lengthInBytes > 0) this.mallocOffset += lengthInBytes;
+		else this.mallocOffset += 8;
+		return currentOffset;
+	}
+	_free() {}
+	getHeapView(kind, address) {
+		if (address === 0) return;
+		const lengthInBytes = this.allocs.get(address);
+		if (lengthInBytes === void 0) throw new Error("Failed to locate heap allocation");
+		if (kind === "float64") {
+			const offset = address / 8;
+			return this.HEAPF64.subarray(offset, offset + lengthInBytes / 8);
+		} else {
+			const offset = address / 4;
+			return this.HEAP32.subarray(offset, offset + lengthInBytes / 4);
+		}
+	}
 };
-
-// src/model-runner/synchronous-model-runner.ts
+//#endregion
+//#region src/model-runner/synchronous-model-runner.ts
+/**
+* Create a `RunnableModel` from a given `JsModel` or `WasmModule` that was generated by the
+* SDEverywhere transpiler/builder.
+*
+* @hidden This is not yet part of the public API; it is only exposed for use by
+* the runtime-async package.
+*/
 function createRunnableModel(generatedModel) {
-  switch (generatedModel.kind) {
-    case "js":
-      return initJsModel(generatedModel);
-    case "wasm":
-      return initWasmModel(generatedModel);
-    default:
-      throw new Error(`Unable to identify generated model kind`);
-  }
+	switch (generatedModel.kind) {
+		case "js": return initJsModel(generatedModel);
+		case "wasm": return initWasmModel(generatedModel);
+		default: throw new Error(`Unable to identify generated model kind`);
+	}
 }
+/**
+* Create a `ModelRunner` that runs a generated model on the JS thread.
+*
+* @param generatedModel A `JsModel` or `WasmModule` generated by the SDEverywhere transpiler.
+*/
 function createSynchronousModelRunner(generatedModel) {
-  const runnableModel = createRunnableModel(generatedModel);
-  return createRunnerFromRunnableModel(runnableModel);
+	return createRunnerFromRunnableModel(createRunnableModel(generatedModel));
 }
+/**
+* Create a `ModelRunner` that runs the given model on the JS thread.
+*
+* @param model The runnable model instance.
+*/
 function createRunnerFromRunnableModel(model) {
-  const listing = model.modelListing ? new ModelListing(model.modelListing) : void 0;
-  const params = new ReferencedRunModelParams(listing);
-  let terminated = false;
-  const runModelSync = (inputs, outputs, options) => {
-    params.updateFromParams(inputs, outputs, options);
-    model.runModel(params);
-    return outputs;
-  };
-  return {
-    createOutputs: () => {
-      return new Outputs(model.outputVarIds, model.startTime, model.endTime, model.saveFreq);
-    },
-    runModel: (inputs, outputs, options) => {
-      if (terminated) {
-        return Promise.reject(new Error("Model runner has already been terminated"));
-      }
-      return Promise.resolve(runModelSync(inputs, outputs, options));
-    },
-    runModelSync: (inputs, outputs, options) => {
-      if (terminated) {
-        throw new Error("Model runner has already been terminated");
-      }
-      return runModelSync(inputs, outputs, options);
-    },
-    terminate: () => __async(null, null, function* () {
-      if (!terminated) {
-        model.terminate();
-        terminated = true;
-      }
-    })
-  };
+	const params = new ReferencedRunModelParams(model.modelListing ? new ModelListing(model.modelListing) : void 0);
+	let terminated = false;
+	const runModelSync = (inputs, outputs, options) => {
+		params.updateFromParams(inputs, outputs, options);
+		model.runModel(params);
+		return outputs;
+	};
+	return {
+		createOutputs: () => {
+			return new Outputs(model.outputVarIds, model.startTime, model.endTime, model.saveFreq);
+		},
+		runModel: (inputs, outputs, options) => {
+			if (terminated) return Promise.reject(/* @__PURE__ */ new Error("Model runner has already been terminated"));
+			return Promise.resolve(runModelSync(inputs, outputs, options));
+		},
+		runModelSync: (inputs, outputs, options) => {
+			if (terminated) throw new Error("Model runner has already been terminated");
+			return runModelSync(inputs, outputs, options);
+		},
+		terminate: async () => {
+			if (!terminated) {
+				model.terminate();
+				terminated = true;
+			}
+		}
+	};
 }
-
-// src/model-scheduler/model-scheduler.ts
+//#endregion
+//#region src/model-scheduler/model-scheduler.ts
+/**
+* A high-level interface that schedules the underlying `ModelRunner`.
+*
+* When one or more input values are changed, this class will schedule a model
+* run to be completed as soon as possible.  When the model run has completed,
+* `onOutputsChanged` is called to notify that new output data is available.
+*
+* The `ModelRunner` is pluggable to allow for running the model synchronously
+* (on the main JavaScript thread) or asynchronously (in a Web Worker or Node.js
+* worker thread).
+*/
 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.runModelIfNeeded();
-    };
-    for (const userInput of userInputs) {
-      userInput.callbacks.onSet = afterSet;
-    }
-    this.currentInputs = [];
-    for (const userInput of userInputs) {
-      this.currentInputs.push(createSimpleInputValue(userInput.varId));
-    }
-  }
-  /**
-   * 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 using the current set of input values.
-   */
-  runModelNow() {
-    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.runModelNow();
-        }, 0);
-      } else {
-        this.runNeeded = false;
-        this.runInProgress = false;
-      }
-    });
-  }
+	/**
+	* @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;
+		this.runNeeded = false;
+		this.runInProgress = false;
+		const afterSet = () => {
+			this.runModelIfNeeded();
+		};
+		for (const userInput of userInputs) userInput.callbacks.onSet = afterSet;
+		this.currentInputs = [];
+		for (const userInput of userInputs) this.currentInputs.push(createSimpleInputValue(userInput.varId));
+	}
+	/**
+	* 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 using the current set of input values.
+	*/
+	async runModelNow() {
+		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);
+			this.onOutputsChanged?.(this.outputs);
+		} catch (e) {
+			console.error(`ERROR: Failed to run model: ${e.message}`);
+		}
+		if (this.runNeeded) {
+			this.runNeeded = false;
+			setTimeout(() => {
+				this.runModelNow();
+			}, 0);
+		} else {
+			this.runNeeded = false;
+			this.runInProgress = false;
+		}
+	}
 };
+/**
+* Create an `InputValue` that is only used to hold a copy of another input (no callbacks).
+* @hidden
+*/
 function createSimpleInputValue(varId) {
-  let currentValue = 0;
-  const get = () => {
-    return currentValue;
-  };
-  const set = (newValue) => {
-    currentValue = newValue;
-  };
-  const reset = () => {
-    set(0);
-  };
-  return { varId, get, set, reset, callbacks: {} };
+	let currentValue = 0;
+	const get = () => {
+		return currentValue;
+	};
+	const set = (newValue) => {
+		currentValue = newValue;
+	};
+	const reset = () => {
+		set(0);
+	};
+	return {
+		varId,
+		get,
+		set,
+		reset,
+		callbacks: {}
+	};
 }
-
-// src/model-scheduler/multi-context-model-scheduler.ts
+//#endregion
+//#region src/model-scheduler/multi-context-model-scheduler.ts
+/**
+* A high-level interface that schedules running of the underlying `ModelRunner`.
+*
+* This class is similar to the (single context) `ModelScheduler` class, except
+* this one supports multiple contexts, each with its own distinct set of
+* inputs and outputs.  This is useful for running the same underlying model
+* instance with different sets of inputs and outputs.  For example, you can
+* use this to show the outputs for multiple scenarios in a single graph, or
+* multiple scenarios across different graphs.
+*
+* When input values are changed in one or more contexts, this class will schedule
+* a model run for each changed context to be completed as soon as possible.
+* When the model run has completed, the context's `onOutputsChanged` function
+* is called to notify that new output data is available for that context.
+*
+* The `ModelRunner` is pluggable to allow for running the model synchronously
+* (on the main JavaScript thread) or asynchronously (in a Web Worker or Node.js
+* worker thread).
+*/
 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);
-      }
-    });
-  }
+	/**
+	* @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;
+		this.contexts = [];
+		this.runNeeded = false;
+		this.runInProgress = false;
+		this.initialOutputs = 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?.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.
+	*/
+	async runModelNow() {
+		this.initialOutputs = void 0;
+		for (const context of this.contexts) if (context.runNeeded) {
+			context.runNeeded = false;
+			await 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.
+	*/
+	async runModelNowForContext(context) {
+		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 {
+			await this.runner.runModel(this.currentInputs, context.outputs);
+			context.onOutputsChanged?.();
+		} 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;
-      }
-    }
-  }
-};
-export {
-  BufferedRunModelParams,
-  MockJsModel,
-  MockWasmModule,
-  ModelListing,
-  ModelScheduler,
-  MultiContextModelScheduler,
-  Outputs,
-  ReferencedRunModelParams,
-  Series,
-  createConstantDef,
-  createInputValue,
-  createLookupDef,
-  createRunnableModel,
-  createSynchronousModelRunner,
-  decodeConstants,
-  decodeLookups,
-  encodeConstants,
-  encodeLookups,
-  encodeVarIndices,
-  execJsModel,
-  getEncodedConstantBufferLengths,
-  getEncodedLookupBufferLengths,
-  getEncodedVarIndicesLength,
-  getJsModelFunctions,
-  initJsModel,
-  initWasmModel,
-  perfElapsed,
-  perfNow
+	/**
+	* @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;
+		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;
+		}
+	}
 };
+//#endregion
+export { BufferedRunModelParams, MockJsModel, MockWasmModule, ModelListing, ModelScheduler, MultiContextModelScheduler, Outputs, ReferencedRunModelParams, Series, createConstantDef, createInputValue, createLookupDef, createRunnableModel, createSynchronousModelRunner, decodeConstants, decodeLookups, encodeConstants, encodeLookups, encodeVarIndices, execJsModel, getEncodedConstantBufferLengths, getEncodedLookupBufferLengths, getEncodedVarIndicesLength, getJsModelFunctions, initJsModel, initWasmModel, perfElapsed, perfNow };
+
 //# sourceMappingURL=index.js.map