@sdeverywhere/runtime-async 0.2.0 → 0.2.3

package/README.md

@@ -1,28 +1,43 @@
 # @sdeverywhere/runtime-async
 
-This package provides an implementation of the `ModelRunner` interface from
-the `@sdeverywhere/runtime` package that uses a Web Worker (in the browser)
-or a worker thread (in a Node.js app) to run the model asynchronously off
-the main JavaScript thread.
+This package provides an implementation of the `ModelRunner` interface (from the `@sdeverywhere/runtime` package) that uses a Web Worker (in the browser) or a worker thread (in a Node.js app) to run the model asynchronously off the main JavaScript thread.
+
+## Quick Start
+
+The best way to get started with SDEverywhere is to follow the [Quick Start](https://github.com/climateinteractive/SDEverywhere#quick-start) instructions.
+If you follow those instructions, the `@sdeverywhere/runtime-async` package will be added to your project automatically, in which case you can skip the next section and jump straight to the ["Usage"](#usage) section below.
+
+## Install
+
+```sh
+# npm
+npm install @sdeverywhere/runtime-async
+
+# pnpm
+pnpm add @sdeverywhere/runtime-async
+
+# yarn
+yarn add @sdeverywhere/runtime-async
+```
 
 ## Usage
 
-### 1. Initialize the `WasmModel` in a Web Worker
+_NOTE:_ If you followed the "Quick Start" instructions and/or used the
+`@sdeverywhere/create` package to generate your project, the initialization
+steps listed below are already implemented for you in the generated `core` package,
+and you can work directly with a `ModelRunner` and/or `ModelScheduler` instance.
+
+### 1. Initialize your generated model in a Web Worker
 
 In your app project, define a separate JavaScript file, called
-`worker.js` for example, that initializes the model worker in the
+`worker.js` for example, that initializes the generated model in the
 context of the Web Worker:
 
 ```js
-import { initWasmModelAndBuffers } from '@sdeverywhere/runtime'
 import { exposeModelWorker } from '@sdeverywhere/runtime-async/worker'
+import loadGeneratedModel from './sde-prep/generated-model.js'
 
-async function initWasmModel() {
-  const wasmModules = loadWasm()
-  return initWasmModelAndBuffers(...)
-}
-
-exposeModelWorker(initWasmModel)
+exposeModelWorker(loadGeneratedModel)
 ```
 
 ### 2. Spawn the worker

package/dist/index.cjs

@@ -37,15 +37,15 @@ async function spawnAsyncModelRunner(workerSpec) {
 async function spawnAsyncModelRunnerWithWorker(worker) {
   const modelWorker2 = await (0, import_threads.spawn)(worker);
   const initResult = await modelWorker2.initModel();
-  let ioBuffer = initResult.ioBuffer;
-  const rowLength = initResult.rowLength;
+  const modelListing = initResult.modelListing ? new import_runtime.ModelListing(initResult.modelListing) : void 0;
+  const params2 = new import_runtime.BufferedRunModelParams(modelListing);
   let running = false;
   let terminated = false;
   return {
     createOutputs: () => {
       return new import_runtime.Outputs(initResult.outputVarIds, initResult.startTime, initResult.endTime, initResult.saveFreq);
     },
-    runModel: async (inputs, outputs) => {
+    runModel: async (inputs, outputs, options) => {
       if (terminated) {
         throw new Error("Async model runner has already been terminated");
       } else if (running) {
@@ -53,24 +53,15 @@ async function spawnAsyncModelRunnerWithWorker(worker) {
       } else {
         running = true;
       }
-      const runTimeLengthInElements = 1;
-      const runTimeLengthInBytes = runTimeLengthInElements * 8;
-      const inputsLengthInElements = inputs.length;
-      const inputsLengthInBytes = inputsLengthInElements * 8;
-      const inputsArray = new Float64Array(ioBuffer, runTimeLengthInBytes, inputsLengthInElements);
-      for (let i = 0; i < inputs.length; i++) {
-        inputsArray[i] = inputs[i].get();
-      }
+      params2.updateFromParams(inputs, outputs, options);
+      let ioBuffer;
       try {
-        ioBuffer = await modelWorker2.runModel((0, import_threads.Transfer)(ioBuffer));
+        ioBuffer = await modelWorker2.runModel((0, import_threads.Transfer)(params2.getEncodedBuffer()));
       } finally {
         running = false;
       }
-      const runTimeBufferArray = new Float64Array(ioBuffer, 0, runTimeLengthInElements);
-      outputs.runTimeInMillis = runTimeBufferArray[0];
-      const outputsOffsetInBytes = runTimeLengthInBytes + inputsLengthInBytes;
-      const outputsArray = new Float64Array(ioBuffer, outputsOffsetInBytes);
-      outputs.updateFromBuffer(outputsArray, rowLength);
+      params2.updateFromEncodedBuffer(ioBuffer);
+      params2.finalizeOutputs(outputs);
       return outputs;
     },
     terminate: () => {
@@ -87,58 +78,36 @@ async function spawnAsyncModelRunnerWithWorker(worker) {
 // src/worker.ts
 var import_worker = require("threads/worker");
 var import_runtime2 = require("@sdeverywhere/runtime");
-var initWasmModel;
-var wasmModel;
-var inputsWasmBuffer;
-var outputsWasmBuffer;
+var initGeneratedModel;
+var runnableModel;
+var params = new import_runtime2.BufferedRunModelParams();
 var modelWorker = {
   async initModel() {
-    if (wasmModel) {
-      throw new Error("WasmModel was already initialized");
+    if (runnableModel) {
+      throw new Error("RunnableModel was already initialized");
     }
-    const wasmResult = await initWasmModel();
-    wasmModel = wasmResult.model;
-    inputsWasmBuffer = wasmResult.inputsBuffer;
-    outputsWasmBuffer = wasmResult.outputsBuffer;
-    const runTimeLength = 8;
-    const inputsLength = inputsWasmBuffer.getArrayView().length;
-    const outputsLength = outputsWasmBuffer.getArrayView().length;
-    const ioArray = new Float64Array(runTimeLength + inputsLength + outputsLength);
-    const ioBuffer = ioArray.buffer;
-    const initResult = {
-      outputVarIds: wasmResult.outputVarIds,
-      startTime: wasmModel.startTime,
-      endTime: wasmModel.endTime,
-      saveFreq: wasmModel.saveFreq,
-      rowLength: wasmModel.numSavePoints,
-      ioBuffer
+    const generatedModel = await initGeneratedModel();
+    runnableModel = (0, import_runtime2.createRunnableModel)(generatedModel);
+    return {
+      outputVarIds: runnableModel.outputVarIds,
+      modelListing: runnableModel.modelListing,
+      startTime: runnableModel.startTime,
+      endTime: runnableModel.endTime,
+      saveFreq: runnableModel.saveFreq,
+      outputRowLength: runnableModel.numSavePoints
     };
-    return (0, import_worker.Transfer)(initResult, [ioBuffer]);
   },
   runModel(ioBuffer) {
-    if (!wasmModel) {
-      throw new Error("WasmModel must be initialized before running the model in worker");
+    if (!runnableModel) {
+      throw new Error("RunnableModel must be initialized before running the model in worker");
     }
-    const runTimeLengthInElements = 1;
-    const runTimeLengthInBytes = runTimeLengthInElements * 8;
-    const inputsWasmArray = inputsWasmBuffer.getArrayView();
-    const inputsLengthInElements = inputsWasmArray.length;
-    const inputsLengthInBytes = inputsLengthInElements * 8;
-    const inputsBufferArray = new Float64Array(ioBuffer, runTimeLengthInBytes, inputsLengthInElements);
-    inputsWasmArray.set(inputsBufferArray);
-    const t0 = (0, import_runtime2.perfNow)();
-    wasmModel.runModel(inputsWasmBuffer, outputsWasmBuffer);
-    const elapsed = (0, import_runtime2.perfElapsed)(t0);
-    const runTimeBufferArray = new Float64Array(ioBuffer, 0, runTimeLengthInElements);
-    runTimeBufferArray[0] = elapsed;
-    const outputsOffsetInBytes = runTimeLengthInBytes + inputsLengthInBytes;
-    const outputsBufferArray = new Float64Array(ioBuffer, outputsOffsetInBytes);
-    outputsBufferArray.set(outputsWasmBuffer.getArrayView());
+    params.updateFromEncodedBuffer(ioBuffer);
+    runnableModel.runModel(params);
     return (0, import_worker.Transfer)(ioBuffer);
   }
 };
 function exposeModelWorker(init) {
-  initWasmModel = init;
+  initGeneratedModel = init;
   (0, import_worker.expose)(modelWorker);
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts","../src/runner.ts","../src/worker.ts"],"sourcesContent":["// Copyright (c) 2020-2022 Climate Interactive / New Venture Fund\n\nexport { spawnAsyncModelRunner } from './runner'\n\nexport { exposeModelWorker } from './worker'\n","// Copyright (c) 2020-2022 Climate Interactive / New Venture Fund\n\nimport { BlobWorker, spawn, Thread, Transfer, Worker } from 'threads'\n\nimport type { ModelRunner } from '@sdeverywhere/runtime'\nimport { Outputs } from '@sdeverywhere/runtime'\n\n/**\n * Initialize a `ModelRunner` that runs the model asynchronously in a worker thread.\n *\n * In your app project, define a JavaScript file, called `worker.js` for example, that\n * initializes the model worker in the context of the Web Worker:\n *\n * ```js\n * import { initWasmModelAndBuffers } from '@sdeverywhere/runtime'\n * import { exposeModelWorker } from '@sdeverywhere/runtime-async/worker'\n *\n * async function initWasmModel() {\n *   const wasmModules = loadWasm()\n *   return initWasmModelAndBuffers(...)\n * }\n *\n * exposeModelWorker(initWasmModel)\n * ```\n *\n * Then, in your web app, call the `spawnAsyncModelRunner` function, which\n * will spawn the Web Worker and initialize the `ModelRunner` that communicates\n * with the worker:\n *\n * ```js\n * import { spawnAsyncModelRunner } from '@sdeverywhere/runtime-async/runner'\n *\n * async function initApp() {\n *   // ...\n *   const runner = await spawnAsyncModelRunner({ path: './worker.js' })\n *   // ...\n * }\n * ```\n *\n * @param workerSpec Either a `path` to the worker JavaScript file, or the `source`\n * containing the full JavaScript source of the worker.\n */\nexport async function spawnAsyncModelRunner(workerSpec: { path: string } | { source: string }): Promise<ModelRunner> {\n  if (workerSpec['path']) {\n    return spawnAsyncModelRunnerWithWorker(new Worker(workerSpec['path']))\n  } else {\n    return spawnAsyncModelRunnerWithWorker(BlobWorker.fromText(workerSpec['source']))\n  }\n}\n\n/**\n * @hidden For internal use only\n */\nasync function spawnAsyncModelRunnerWithWorker(worker: Worker): Promise<ModelRunner> {\n  // Spawn the given Worker that contains the `ModelWorker`\n  const modelWorker = await spawn(worker)\n\n  // Wait for the worker to initialize the wasm model (in the worker thread)\n  const initResult = await modelWorker.initModel()\n  let ioBuffer: ArrayBuffer = initResult.ioBuffer\n\n  // The row length is the number of elements in each row of the outputs buffer\n  const rowLength = initResult.rowLength\n\n  // Use a flag to ensure that only one request is made at a time\n  let running = false\n\n  // Disallow `runModel` after the runner has been terminated\n  let terminated = false\n\n  return {\n    createOutputs: () => {\n      return new Outputs(initResult.outputVarIds, initResult.startTime, initResult.endTime, initResult.saveFreq)\n    },\n\n    runModel: async (inputs, outputs) => {\n      if (terminated) {\n        throw new Error('Async model runner has already been terminated')\n      } else if (running) {\n        throw new Error('Async model runner only supports one `runModel` call at a time')\n      } else {\n        running = true\n      }\n\n      // The run time is stored in the first 8 bytes\n      const runTimeLengthInElements = 1\n      const runTimeLengthInBytes = runTimeLengthInElements * 8\n\n      // Capture the current set of input values into the reusable buffer\n      const inputsLengthInElements = inputs.length\n      const inputsLengthInBytes = inputsLengthInElements * 8\n      const inputsArray = new Float64Array(ioBuffer, runTimeLengthInBytes, inputsLengthInElements)\n      for (let i = 0; i < inputs.length; i++) {\n        inputsArray[i] = inputs[i].get()\n      }\n\n      // Run the model in the worker. We pass the underlying `ArrayBuffer`\n      // instance back to the worker wrapped in a `Transfer` to make it\n      // no-copy transferable, and then the worker will return it back\n      // to us.\n      try {\n        ioBuffer = await modelWorker.runModel(Transfer(ioBuffer))\n      } finally {\n        running = false\n      }\n\n      // Save the model run time\n      const runTimeBufferArray = new Float64Array(ioBuffer, 0, runTimeLengthInElements)\n      outputs.runTimeInMillis = runTimeBufferArray[0]\n\n      // Capture the outputs array by copying the data into the given `Outputs`\n      // data structure\n      const outputsOffsetInBytes = runTimeLengthInBytes + inputsLengthInBytes\n      const outputsArray = new Float64Array(ioBuffer, outputsOffsetInBytes)\n      outputs.updateFromBuffer(outputsArray, rowLength)\n\n      return outputs\n    },\n\n    terminate: () => {\n      if (terminated) {\n        return Promise.resolve()\n      } else {\n        terminated = true\n        return Thread.terminate(modelWorker)\n      }\n    }\n  }\n}\n","// Copyright (c) 2020-2022 Climate Interactive / New Venture Fund\n\nimport type { TransferDescriptor } from 'threads'\nimport { expose, Transfer } from 'threads/worker'\n\nimport type { WasmBuffer, WasmModel, WasmModelInitResult } from '@sdeverywhere/runtime'\nimport { perfElapsed, perfNow } from '@sdeverywhere/runtime'\n\n/** @hidden */\nlet initWasmModel: () => Promise<WasmModelInitResult>\n/** @hidden */\nlet wasmModel: WasmModel\n/** @hidden */\nlet inputsWasmBuffer: WasmBuffer\n/** @hidden */\nlet outputsWasmBuffer: WasmBuffer\n\ninterface InitResult {\n  outputVarIds: string[]\n  startTime: number\n  endTime: number\n  saveFreq: number\n  rowLength: number\n  ioBuffer: ArrayBuffer\n}\n\n/** @hidden */\nconst modelWorker = {\n  async initModel(): Promise<TransferDescriptor<InitResult>> {\n    if (wasmModel) {\n      throw new Error('WasmModel was already initialized')\n    }\n\n    // Initialize the wasm model and associated buffers\n    const wasmResult = await initWasmModel()\n\n    // Capture the `WasmModel` instance and `WasmBuffer` instances\n    wasmModel = wasmResult.model\n    inputsWasmBuffer = wasmResult.inputsBuffer\n    outputsWasmBuffer = wasmResult.outputsBuffer\n\n    // Create a combined array that will hold a copy of the inputs and outputs\n    // wasm buffers; this buffer is no-copy transferable, whereas the wasm ones\n    // are not allowed to be transferred\n    const runTimeLength = 8\n    const inputsLength = inputsWasmBuffer.getArrayView().length\n    const outputsLength = outputsWasmBuffer.getArrayView().length\n    const ioArray = new Float64Array(runTimeLength + inputsLength + outputsLength)\n\n    // Transfer the underlying buffer to the runner\n    const ioBuffer = ioArray.buffer\n    const initResult: InitResult = {\n      outputVarIds: wasmResult.outputVarIds,\n      startTime: wasmModel.startTime,\n      endTime: wasmModel.endTime,\n      saveFreq: wasmModel.saveFreq,\n      rowLength: wasmModel.numSavePoints,\n      ioBuffer\n    }\n    return Transfer(initResult, [ioBuffer])\n  },\n\n  runModel(ioBuffer: ArrayBuffer): TransferDescriptor<ArrayBuffer> {\n    if (!wasmModel) {\n      throw new Error('WasmModel must be initialized before running the model in worker')\n    }\n\n    // The run time is stored in the first 8 bytes\n    const runTimeLengthInElements = 1\n    const runTimeLengthInBytes = runTimeLengthInElements * 8\n\n    // Copy the inputs into the wasm inputs buffer\n    const inputsWasmArray = inputsWasmBuffer.getArrayView()\n    const inputsLengthInElements = inputsWasmArray.length\n    const inputsLengthInBytes = inputsLengthInElements * 8\n    const inputsBufferArray = new Float64Array(ioBuffer, runTimeLengthInBytes, inputsLengthInElements)\n    inputsWasmArray.set(inputsBufferArray)\n\n    // Run the model using the wasm buffers\n    const t0 = perfNow()\n    wasmModel.runModel(inputsWasmBuffer, outputsWasmBuffer)\n    const elapsed = perfElapsed(t0)\n\n    // Write the model run time to the buffer\n    const runTimeBufferArray = new Float64Array(ioBuffer, 0, runTimeLengthInElements)\n    runTimeBufferArray[0] = elapsed\n\n    // Copy the outputs from the wasm outputs buffer\n    const outputsOffsetInBytes = runTimeLengthInBytes + inputsLengthInBytes\n    const outputsBufferArray = new Float64Array(ioBuffer, outputsOffsetInBytes)\n    outputsBufferArray.set(outputsWasmBuffer.getArrayView())\n\n    // Transfer the buffer back to the runner\n    return Transfer(ioBuffer)\n  }\n}\n\n/**\n * Expose an object in the current worker thread that communicates with the\n * `ModelRunner` instance running in the main thread.  The exposed worker\n * object will take care of running the `WasmModel` on the worker thread\n * and sending the outputs back to the main process.\n *\n * @param init The function that initializes the `WasmModel` instance that\n * is used in the worker thread.\n */\nexport function exposeModelWorker(init: () => Promise<WasmModelInitResult>): void {\n  // Save the initializer, which will be used when the runner calls `initModel`\n  // on the worker\n  initWasmModel = init\n\n  // Expose the worker implementation to `threads.js`\n  expose(modelWorker)\n}\n"],"mappings":"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","names":["modelWorker","import_runtime"]}
+{"version":3,"sources":["../src/index.ts","../src/runner.ts","../src/worker.ts"],"sourcesContent":["// Copyright (c) 2020-2022 Climate Interactive / New Venture Fund\n\nexport { spawnAsyncModelRunner } from './runner'\n\nexport { exposeModelWorker } from './worker'\n","// Copyright (c) 2020-2022 Climate Interactive / New Venture Fund\n\nimport { BlobWorker, spawn, Thread, Transfer, Worker } from 'threads'\n\nimport type { ModelRunner } from '@sdeverywhere/runtime'\nimport { BufferedRunModelParams, ModelListing, Outputs } from '@sdeverywhere/runtime'\n\n/**\n * Initialize a `ModelRunner` that runs the model asynchronously in a worker\n * (a Web Worker when running in a browser environment, or a worker thread\n * when running in a Node.js environment).\n *\n * In your app project, define a JavaScript file, called `worker.js` for example,\n * that initializes the generated model in the context of a worker thread:\n *\n * ```js\n * import { exposeModelWorker } from '@sdeverywhere/runtime-async/worker'\n * import loadGeneratedModel from './sde-prep/generated-model.js'\n *\n * exposeModelWorker(loadGeneratedModel)\n * ```\n *\n * Then, in your web app, call the `spawnAsyncModelRunner` function, which\n * will spawn the worker thread and initialize the `ModelRunner` that communicates\n * with the worker:\n *\n * ```js\n * import { spawnAsyncModelRunner } from '@sdeverywhere/runtime-async/runner'\n *\n * async function initApp() {\n *   // ...\n *   const runner = await spawnAsyncModelRunner({ path: './worker.js' })\n *   // ...\n * }\n * ```\n *\n * @param workerSpec Either a `path` to the worker JavaScript file, or the `source`\n * containing the full JavaScript source of the worker.\n */\nexport async function spawnAsyncModelRunner(workerSpec: { path: string } | { source: string }): Promise<ModelRunner> {\n  if (workerSpec['path']) {\n    return spawnAsyncModelRunnerWithWorker(new Worker(workerSpec['path']))\n  } else {\n    return spawnAsyncModelRunnerWithWorker(BlobWorker.fromText(workerSpec['source']))\n  }\n}\n\n/**\n * @hidden For internal use only\n */\nasync function spawnAsyncModelRunnerWithWorker(worker: Worker): Promise<ModelRunner> {\n  // Spawn the given Worker that contains the `ModelWorker`\n  const modelWorker = await spawn(worker)\n\n  // Wait for the worker to initialize the wasm model (in the worker thread)\n  const initResult = await modelWorker.initModel()\n\n  // Create a `ModelListing` instance if the listing was defined in the generated model\n  const modelListing = initResult.modelListing ? new ModelListing(initResult.modelListing) : undefined\n\n  // Maintain a `BufferedRunModelParams` instance that holds the I/O parameters\n  const params = new BufferedRunModelParams(modelListing)\n\n  // Use a flag to ensure that only one request is made at a time\n  let running = false\n\n  // Disallow `runModel` after the runner has been terminated\n  let terminated = false\n\n  return {\n    createOutputs: () => {\n      return new Outputs(initResult.outputVarIds, initResult.startTime, initResult.endTime, initResult.saveFreq)\n    },\n\n    runModel: async (inputs, outputs, options) => {\n      if (terminated) {\n        throw new Error('Async model runner has already been terminated')\n      } else if (running) {\n        throw new Error('Async model runner only supports one `runModel` call at a time')\n      } else {\n        running = true\n      }\n\n      // Update the I/O parameters\n      params.updateFromParams(inputs, outputs, options)\n\n      // Run the model in the worker. We pass the underlying `ArrayBuffer`\n      // instance back to the worker wrapped in a `Transfer` to make it\n      // no-copy transferable, and then the worker will return it back\n      // to us.\n      let ioBuffer: ArrayBuffer\n      try {\n        ioBuffer = await modelWorker.runModel(Transfer(params.getEncodedBuffer()))\n      } finally {\n        running = false\n      }\n\n      // Once the buffer is transferred to the worker, the buffer in the\n      // `BufferedRunModelParams` becomes \"detached\" and is no longer usable.\n      // After the buffer is transferred back from the worker, we need to\n      // restore the state of the object to use the new buffer.\n      params.updateFromEncodedBuffer(ioBuffer)\n\n      // Copy the output values and elapsed time from the buffer to the\n      // `Outputs` instance\n      params.finalizeOutputs(outputs)\n\n      return outputs\n    },\n\n    terminate: () => {\n      if (terminated) {\n        return Promise.resolve()\n      } else {\n        terminated = true\n        return Thread.terminate(modelWorker)\n      }\n    }\n  }\n}\n","// Copyright (c) 2020-2022 Climate Interactive / New Venture Fund\n\nimport type { TransferDescriptor } from 'threads'\nimport { expose, Transfer } from 'threads/worker'\n\nimport type { GeneratedModel, RunnableModel } from '@sdeverywhere/runtime'\nimport { BufferedRunModelParams, createRunnableModel } from '@sdeverywhere/runtime'\n\n/** @hidden */\nlet initGeneratedModel: () => Promise<GeneratedModel>\n\n/** @hidden */\nlet runnableModel: RunnableModel\n\n/**\n * Maintain a `BufferedRunModelParams` instance that wraps the transferable buffer\n * containing the I/O parameters.\n * @hidden\n */\nconst params = new BufferedRunModelParams()\n\ninterface InitResult {\n  outputVarIds: string[]\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  modelListing?: /*ModelListingSpecs*/ any\n  startTime: number\n  endTime: number\n  saveFreq: number\n  outputRowLength: number\n}\n\n/** @hidden */\nconst modelWorker = {\n  async initModel(): Promise<InitResult> {\n    if (runnableModel) {\n      throw new Error('RunnableModel was already initialized')\n    }\n\n    // Initialize the runnable model\n    const generatedModel = await initGeneratedModel()\n    runnableModel = createRunnableModel(generatedModel)\n\n    // Transfer the model metadata to the runner\n    return {\n      outputVarIds: runnableModel.outputVarIds,\n      modelListing: runnableModel.modelListing,\n      startTime: runnableModel.startTime,\n      endTime: runnableModel.endTime,\n      saveFreq: runnableModel.saveFreq,\n      outputRowLength: runnableModel.numSavePoints\n    }\n  },\n\n  runModel(ioBuffer: ArrayBuffer): TransferDescriptor<ArrayBuffer> {\n    if (!runnableModel) {\n      throw new Error('RunnableModel must be initialized before running the model in worker')\n    }\n\n    // Update the `BufferedRunModelParams` to use the values in the buffer that was transferred\n    // from the runner to the worker\n    params.updateFromEncodedBuffer(ioBuffer)\n\n    // Run the model synchronously on the worker thread using those I/O parameters\n    runnableModel.runModel(params)\n\n    // Transfer the buffer back to the runner\n    return Transfer(ioBuffer)\n  }\n}\n\n/**\n * Expose an object in the current worker thread that communicates with the\n * `ModelRunner` instance running in the main thread.  The exposed worker\n * object will take care of running the model on the worker thread and\n * sending the outputs back to the main thread.\n *\n * @param init The function that initializes the generated model instance that\n * is used in the worker thread.\n */\nexport function exposeModelWorker(init: () => Promise<GeneratedModel>): void {\n  // Save the initializer, which will be used when the runner calls `initModel`\n  // on the worker\n  initGeneratedModel = init\n\n  // Expose the worker implementation to `threads.js`\n  expose(modelWorker)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACEA,qBAA4D;AAG5D,qBAA8D;AAkC9D,eAAsB,sBAAsB,YAAyE;AACnH,MAAI,WAAW,MAAM,GAAG;AACtB,WAAO,gCAAgC,IAAI,sBAAO,WAAW,MAAM,CAAC,CAAC;AAAA,EACvE,OAAO;AACL,WAAO,gCAAgC,0BAAW,SAAS,WAAW,QAAQ,CAAC,CAAC;AAAA,EAClF;AACF;AAKA,eAAe,gCAAgC,QAAsC;AAEnF,QAAMA,eAAc,UAAM,sBAAM,MAAM;AAGtC,QAAM,aAAa,MAAMA,aAAY,UAAU;AAG/C,QAAM,eAAe,WAAW,eAAe,IAAI,4BAAa,WAAW,YAAY,IAAI;AAG3F,QAAMC,UAAS,IAAI,sCAAuB,YAAY;AAGtD,MAAI,UAAU;AAGd,MAAI,aAAa;AAEjB,SAAO;AAAA,IACL,eAAe,MAAM;AACnB,aAAO,IAAI,uBAAQ,WAAW,cAAc,WAAW,WAAW,WAAW,SAAS,WAAW,QAAQ;AAAA,IAC3G;AAAA,IAEA,UAAU,OAAO,QAAQ,SAAS,YAAY;AAC5C,UAAI,YAAY;AACd,cAAM,IAAI,MAAM,gDAAgD;AAAA,MAClE,WAAW,SAAS;AAClB,cAAM,IAAI,MAAM,gEAAgE;AAAA,MAClF,OAAO;AACL,kBAAU;AAAA,MACZ;AAGA,MAAAA,QAAO,iBAAiB,QAAQ,SAAS,OAAO;AAMhD,UAAI;AACJ,UAAI;AACF,mBAAW,MAAMD,aAAY,aAAS,yBAASC,QAAO,iBAAiB,CAAC,CAAC;AAAA,MAC3E,UAAE;AACA,kBAAU;AAAA,MACZ;AAMA,MAAAA,QAAO,wBAAwB,QAAQ;AAIvC,MAAAA,QAAO,gBAAgB,OAAO;AAE9B,aAAO;AAAA,IACT;AAAA,IAEA,WAAW,MAAM;AACf,UAAI,YAAY;AACd,eAAO,QAAQ,QAAQ;AAAA,MACzB,OAAO;AACL,qBAAa;AACb,eAAO,sBAAO,UAAUD,YAAW;AAAA,MACrC;AAAA,IACF;AAAA,EACF;AACF;;;ACpHA,oBAAiC;AAGjC,IAAAE,kBAA4D;AAG5D,IAAI;AAGJ,IAAI;AAOJ,IAAM,SAAS,IAAI,uCAAuB;AAa1C,IAAM,cAAc;AAAA,EAClB,MAAM,YAAiC;AACrC,QAAI,eAAe;AACjB,YAAM,IAAI,MAAM,uCAAuC;AAAA,IACzD;AAGA,UAAM,iBAAiB,MAAM,mBAAmB;AAChD,wBAAgB,qCAAoB,cAAc;AAGlD,WAAO;AAAA,MACL,cAAc,cAAc;AAAA,MAC5B,cAAc,cAAc;AAAA,MAC5B,WAAW,cAAc;AAAA,MACzB,SAAS,cAAc;AAAA,MACvB,UAAU,cAAc;AAAA,MACxB,iBAAiB,cAAc;AAAA,IACjC;AAAA,EACF;AAAA,EAEA,SAAS,UAAwD;AAC/D,QAAI,CAAC,eAAe;AAClB,YAAM,IAAI,MAAM,sEAAsE;AAAA,IACxF;AAIA,WAAO,wBAAwB,QAAQ;AAGvC,kBAAc,SAAS,MAAM;AAG7B,eAAO,wBAAS,QAAQ;AAAA,EAC1B;AACF;AAWO,SAAS,kBAAkB,MAA2C;AAG3E,uBAAqB;AAGrB,4BAAO,WAAW;AACpB;","names":["modelWorker","params","import_runtime"]}

package/dist/index.d.cts

@@ -0,0 +1,3 @@
+export { spawnAsyncModelRunner } from './runner.cjs';
+export { exposeModelWorker } from './worker.cjs';
+import '@sdeverywhere/runtime';

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/runner.ts
 import { BlobWorker, spawn, Thread, Transfer, Worker } from "threads";
-import { Outputs } from "@sdeverywhere/runtime";
+import { BufferedRunModelParams, ModelListing, Outputs } from "@sdeverywhere/runtime";
 async function spawnAsyncModelRunner(workerSpec) {
   if (workerSpec["path"]) {
     return spawnAsyncModelRunnerWithWorker(new Worker(workerSpec["path"]));
@@ -11,15 +11,15 @@ async function spawnAsyncModelRunner(workerSpec) {
 async function spawnAsyncModelRunnerWithWorker(worker) {
   const modelWorker2 = await spawn(worker);
   const initResult = await modelWorker2.initModel();
-  let ioBuffer = initResult.ioBuffer;
-  const rowLength = initResult.rowLength;
+  const modelListing = initResult.modelListing ? new ModelListing(initResult.modelListing) : void 0;
+  const params2 = new BufferedRunModelParams(modelListing);
   let running = false;
   let terminated = false;
   return {
     createOutputs: () => {
       return new Outputs(initResult.outputVarIds, initResult.startTime, initResult.endTime, initResult.saveFreq);
     },
-    runModel: async (inputs, outputs) => {
+    runModel: async (inputs, outputs, options) => {
       if (terminated) {
         throw new Error("Async model runner has already been terminated");
       } else if (running) {
@@ -27,24 +27,15 @@ async function spawnAsyncModelRunnerWithWorker(worker) {
       } else {
         running = true;
       }
-      const runTimeLengthInElements = 1;
-      const runTimeLengthInBytes = runTimeLengthInElements * 8;
-      const inputsLengthInElements = inputs.length;
-      const inputsLengthInBytes = inputsLengthInElements * 8;
-      const inputsArray = new Float64Array(ioBuffer, runTimeLengthInBytes, inputsLengthInElements);
-      for (let i = 0; i < inputs.length; i++) {
-        inputsArray[i] = inputs[i].get();
-      }
+      params2.updateFromParams(inputs, outputs, options);
+      let ioBuffer;
       try {
-        ioBuffer = await modelWorker2.runModel(Transfer(ioBuffer));
+        ioBuffer = await modelWorker2.runModel(Transfer(params2.getEncodedBuffer()));
       } finally {
         running = false;
       }
-      const runTimeBufferArray = new Float64Array(ioBuffer, 0, runTimeLengthInElements);
-      outputs.runTimeInMillis = runTimeBufferArray[0];
-      const outputsOffsetInBytes = runTimeLengthInBytes + inputsLengthInBytes;
-      const outputsArray = new Float64Array(ioBuffer, outputsOffsetInBytes);
-      outputs.updateFromBuffer(outputsArray, rowLength);
+      params2.updateFromEncodedBuffer(ioBuffer);
+      params2.finalizeOutputs(outputs);
       return outputs;
     },
     terminate: () => {
@@ -60,59 +51,37 @@ async function spawnAsyncModelRunnerWithWorker(worker) {
 
 // src/worker.ts
 import { expose, Transfer as Transfer2 } from "threads/worker";
-import { perfElapsed, perfNow } from "@sdeverywhere/runtime";
-var initWasmModel;
-var wasmModel;
-var inputsWasmBuffer;
-var outputsWasmBuffer;
+import { BufferedRunModelParams as BufferedRunModelParams2, createRunnableModel } from "@sdeverywhere/runtime";
+var initGeneratedModel;
+var runnableModel;
+var params = new BufferedRunModelParams2();
 var modelWorker = {
   async initModel() {
-    if (wasmModel) {
-      throw new Error("WasmModel was already initialized");
+    if (runnableModel) {
+      throw new Error("RunnableModel was already initialized");
     }
-    const wasmResult = await initWasmModel();
-    wasmModel = wasmResult.model;
-    inputsWasmBuffer = wasmResult.inputsBuffer;
-    outputsWasmBuffer = wasmResult.outputsBuffer;
-    const runTimeLength = 8;
-    const inputsLength = inputsWasmBuffer.getArrayView().length;
-    const outputsLength = outputsWasmBuffer.getArrayView().length;
-    const ioArray = new Float64Array(runTimeLength + inputsLength + outputsLength);
-    const ioBuffer = ioArray.buffer;
-    const initResult = {
-      outputVarIds: wasmResult.outputVarIds,
-      startTime: wasmModel.startTime,
-      endTime: wasmModel.endTime,
-      saveFreq: wasmModel.saveFreq,
-      rowLength: wasmModel.numSavePoints,
-      ioBuffer
+    const generatedModel = await initGeneratedModel();
+    runnableModel = createRunnableModel(generatedModel);
+    return {
+      outputVarIds: runnableModel.outputVarIds,
+      modelListing: runnableModel.modelListing,
+      startTime: runnableModel.startTime,
+      endTime: runnableModel.endTime,
+      saveFreq: runnableModel.saveFreq,
+      outputRowLength: runnableModel.numSavePoints
     };
-    return Transfer2(initResult, [ioBuffer]);
   },
   runModel(ioBuffer) {
-    if (!wasmModel) {
-      throw new Error("WasmModel must be initialized before running the model in worker");
+    if (!runnableModel) {
+      throw new Error("RunnableModel must be initialized before running the model in worker");
     }
-    const runTimeLengthInElements = 1;
-    const runTimeLengthInBytes = runTimeLengthInElements * 8;
-    const inputsWasmArray = inputsWasmBuffer.getArrayView();
-    const inputsLengthInElements = inputsWasmArray.length;
-    const inputsLengthInBytes = inputsLengthInElements * 8;
-    const inputsBufferArray = new Float64Array(ioBuffer, runTimeLengthInBytes, inputsLengthInElements);
-    inputsWasmArray.set(inputsBufferArray);
-    const t0 = perfNow();
-    wasmModel.runModel(inputsWasmBuffer, outputsWasmBuffer);
-    const elapsed = perfElapsed(t0);
-    const runTimeBufferArray = new Float64Array(ioBuffer, 0, runTimeLengthInElements);
-    runTimeBufferArray[0] = elapsed;
-    const outputsOffsetInBytes = runTimeLengthInBytes + inputsLengthInBytes;
-    const outputsBufferArray = new Float64Array(ioBuffer, outputsOffsetInBytes);
-    outputsBufferArray.set(outputsWasmBuffer.getArrayView());
+    params.updateFromEncodedBuffer(ioBuffer);
+    runnableModel.runModel(params);
     return Transfer2(ioBuffer);
   }
 };
 function exposeModelWorker(init) {
-  initWasmModel = init;
+  initGeneratedModel = init;
   expose(modelWorker);
 }
 export {

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/runner.ts","../src/worker.ts"],"sourcesContent":["// Copyright (c) 2020-2022 Climate Interactive / New Venture Fund\n\nimport { BlobWorker, spawn, Thread, Transfer, Worker } from 'threads'\n\nimport type { ModelRunner } from '@sdeverywhere/runtime'\nimport { Outputs } from '@sdeverywhere/runtime'\n\n/**\n * Initialize a `ModelRunner` that runs the model asynchronously in a worker thread.\n *\n * In your app project, define a JavaScript file, called `worker.js` for example, that\n * initializes the model worker in the context of the Web Worker:\n *\n * ```js\n * import { initWasmModelAndBuffers } from '@sdeverywhere/runtime'\n * import { exposeModelWorker } from '@sdeverywhere/runtime-async/worker'\n *\n * async function initWasmModel() {\n *   const wasmModules = loadWasm()\n *   return initWasmModelAndBuffers(...)\n * }\n *\n * exposeModelWorker(initWasmModel)\n * ```\n *\n * Then, in your web app, call the `spawnAsyncModelRunner` function, which\n * will spawn the Web Worker and initialize the `ModelRunner` that communicates\n * with the worker:\n *\n * ```js\n * import { spawnAsyncModelRunner } from '@sdeverywhere/runtime-async/runner'\n *\n * async function initApp() {\n *   // ...\n *   const runner = await spawnAsyncModelRunner({ path: './worker.js' })\n *   // ...\n * }\n * ```\n *\n * @param workerSpec Either a `path` to the worker JavaScript file, or the `source`\n * containing the full JavaScript source of the worker.\n */\nexport async function spawnAsyncModelRunner(workerSpec: { path: string } | { source: string }): Promise<ModelRunner> {\n  if (workerSpec['path']) {\n    return spawnAsyncModelRunnerWithWorker(new Worker(workerSpec['path']))\n  } else {\n    return spawnAsyncModelRunnerWithWorker(BlobWorker.fromText(workerSpec['source']))\n  }\n}\n\n/**\n * @hidden For internal use only\n */\nasync function spawnAsyncModelRunnerWithWorker(worker: Worker): Promise<ModelRunner> {\n  // Spawn the given Worker that contains the `ModelWorker`\n  const modelWorker = await spawn(worker)\n\n  // Wait for the worker to initialize the wasm model (in the worker thread)\n  const initResult = await modelWorker.initModel()\n  let ioBuffer: ArrayBuffer = initResult.ioBuffer\n\n  // The row length is the number of elements in each row of the outputs buffer\n  const rowLength = initResult.rowLength\n\n  // Use a flag to ensure that only one request is made at a time\n  let running = false\n\n  // Disallow `runModel` after the runner has been terminated\n  let terminated = false\n\n  return {\n    createOutputs: () => {\n      return new Outputs(initResult.outputVarIds, initResult.startTime, initResult.endTime, initResult.saveFreq)\n    },\n\n    runModel: async (inputs, outputs) => {\n      if (terminated) {\n        throw new Error('Async model runner has already been terminated')\n      } else if (running) {\n        throw new Error('Async model runner only supports one `runModel` call at a time')\n      } else {\n        running = true\n      }\n\n      // The run time is stored in the first 8 bytes\n      const runTimeLengthInElements = 1\n      const runTimeLengthInBytes = runTimeLengthInElements * 8\n\n      // Capture the current set of input values into the reusable buffer\n      const inputsLengthInElements = inputs.length\n      const inputsLengthInBytes = inputsLengthInElements * 8\n      const inputsArray = new Float64Array(ioBuffer, runTimeLengthInBytes, inputsLengthInElements)\n      for (let i = 0; i < inputs.length; i++) {\n        inputsArray[i] = inputs[i].get()\n      }\n\n      // Run the model in the worker. We pass the underlying `ArrayBuffer`\n      // instance back to the worker wrapped in a `Transfer` to make it\n      // no-copy transferable, and then the worker will return it back\n      // to us.\n      try {\n        ioBuffer = await modelWorker.runModel(Transfer(ioBuffer))\n      } finally {\n        running = false\n      }\n\n      // Save the model run time\n      const runTimeBufferArray = new Float64Array(ioBuffer, 0, runTimeLengthInElements)\n      outputs.runTimeInMillis = runTimeBufferArray[0]\n\n      // Capture the outputs array by copying the data into the given `Outputs`\n      // data structure\n      const outputsOffsetInBytes = runTimeLengthInBytes + inputsLengthInBytes\n      const outputsArray = new Float64Array(ioBuffer, outputsOffsetInBytes)\n      outputs.updateFromBuffer(outputsArray, rowLength)\n\n      return outputs\n    },\n\n    terminate: () => {\n      if (terminated) {\n        return Promise.resolve()\n      } else {\n        terminated = true\n        return Thread.terminate(modelWorker)\n      }\n    }\n  }\n}\n","// Copyright (c) 2020-2022 Climate Interactive / New Venture Fund\n\nimport type { TransferDescriptor } from 'threads'\nimport { expose, Transfer } from 'threads/worker'\n\nimport type { WasmBuffer, WasmModel, WasmModelInitResult } from '@sdeverywhere/runtime'\nimport { perfElapsed, perfNow } from '@sdeverywhere/runtime'\n\n/** @hidden */\nlet initWasmModel: () => Promise<WasmModelInitResult>\n/** @hidden */\nlet wasmModel: WasmModel\n/** @hidden */\nlet inputsWasmBuffer: WasmBuffer\n/** @hidden */\nlet outputsWasmBuffer: WasmBuffer\n\ninterface InitResult {\n  outputVarIds: string[]\n  startTime: number\n  endTime: number\n  saveFreq: number\n  rowLength: number\n  ioBuffer: ArrayBuffer\n}\n\n/** @hidden */\nconst modelWorker = {\n  async initModel(): Promise<TransferDescriptor<InitResult>> {\n    if (wasmModel) {\n      throw new Error('WasmModel was already initialized')\n    }\n\n    // Initialize the wasm model and associated buffers\n    const wasmResult = await initWasmModel()\n\n    // Capture the `WasmModel` instance and `WasmBuffer` instances\n    wasmModel = wasmResult.model\n    inputsWasmBuffer = wasmResult.inputsBuffer\n    outputsWasmBuffer = wasmResult.outputsBuffer\n\n    // Create a combined array that will hold a copy of the inputs and outputs\n    // wasm buffers; this buffer is no-copy transferable, whereas the wasm ones\n    // are not allowed to be transferred\n    const runTimeLength = 8\n    const inputsLength = inputsWasmBuffer.getArrayView().length\n    const outputsLength = outputsWasmBuffer.getArrayView().length\n    const ioArray = new Float64Array(runTimeLength + inputsLength + outputsLength)\n\n    // Transfer the underlying buffer to the runner\n    const ioBuffer = ioArray.buffer\n    const initResult: InitResult = {\n      outputVarIds: wasmResult.outputVarIds,\n      startTime: wasmModel.startTime,\n      endTime: wasmModel.endTime,\n      saveFreq: wasmModel.saveFreq,\n      rowLength: wasmModel.numSavePoints,\n      ioBuffer\n    }\n    return Transfer(initResult, [ioBuffer])\n  },\n\n  runModel(ioBuffer: ArrayBuffer): TransferDescriptor<ArrayBuffer> {\n    if (!wasmModel) {\n      throw new Error('WasmModel must be initialized before running the model in worker')\n    }\n\n    // The run time is stored in the first 8 bytes\n    const runTimeLengthInElements = 1\n    const runTimeLengthInBytes = runTimeLengthInElements * 8\n\n    // Copy the inputs into the wasm inputs buffer\n    const inputsWasmArray = inputsWasmBuffer.getArrayView()\n    const inputsLengthInElements = inputsWasmArray.length\n    const inputsLengthInBytes = inputsLengthInElements * 8\n    const inputsBufferArray = new Float64Array(ioBuffer, runTimeLengthInBytes, inputsLengthInElements)\n    inputsWasmArray.set(inputsBufferArray)\n\n    // Run the model using the wasm buffers\n    const t0 = perfNow()\n    wasmModel.runModel(inputsWasmBuffer, outputsWasmBuffer)\n    const elapsed = perfElapsed(t0)\n\n    // Write the model run time to the buffer\n    const runTimeBufferArray = new Float64Array(ioBuffer, 0, runTimeLengthInElements)\n    runTimeBufferArray[0] = elapsed\n\n    // Copy the outputs from the wasm outputs buffer\n    const outputsOffsetInBytes = runTimeLengthInBytes + inputsLengthInBytes\n    const outputsBufferArray = new Float64Array(ioBuffer, outputsOffsetInBytes)\n    outputsBufferArray.set(outputsWasmBuffer.getArrayView())\n\n    // Transfer the buffer back to the runner\n    return Transfer(ioBuffer)\n  }\n}\n\n/**\n * Expose an object in the current worker thread that communicates with the\n * `ModelRunner` instance running in the main thread.  The exposed worker\n * object will take care of running the `WasmModel` on the worker thread\n * and sending the outputs back to the main process.\n *\n * @param init The function that initializes the `WasmModel` instance that\n * is used in the worker thread.\n */\nexport function exposeModelWorker(init: () => Promise<WasmModelInitResult>): void {\n  // Save the initializer, which will be used when the runner calls `initModel`\n  // on the worker\n  initWasmModel = init\n\n  // Expose the worker implementation to `threads.js`\n  expose(modelWorker)\n}\n"],"mappings":"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","names":["modelWorker","Transfer"]}
+{"version":3,"sources":["../src/runner.ts","../src/worker.ts"],"sourcesContent":["// Copyright (c) 2020-2022 Climate Interactive / New Venture Fund\n\nimport { BlobWorker, spawn, Thread, Transfer, Worker } from 'threads'\n\nimport type { ModelRunner } from '@sdeverywhere/runtime'\nimport { BufferedRunModelParams, ModelListing, Outputs } from '@sdeverywhere/runtime'\n\n/**\n * Initialize a `ModelRunner` that runs the model asynchronously in a worker\n * (a Web Worker when running in a browser environment, or a worker thread\n * when running in a Node.js environment).\n *\n * In your app project, define a JavaScript file, called `worker.js` for example,\n * that initializes the generated model in the context of a worker thread:\n *\n * ```js\n * import { exposeModelWorker } from '@sdeverywhere/runtime-async/worker'\n * import loadGeneratedModel from './sde-prep/generated-model.js'\n *\n * exposeModelWorker(loadGeneratedModel)\n * ```\n *\n * Then, in your web app, call the `spawnAsyncModelRunner` function, which\n * will spawn the worker thread and initialize the `ModelRunner` that communicates\n * with the worker:\n *\n * ```js\n * import { spawnAsyncModelRunner } from '@sdeverywhere/runtime-async/runner'\n *\n * async function initApp() {\n *   // ...\n *   const runner = await spawnAsyncModelRunner({ path: './worker.js' })\n *   // ...\n * }\n * ```\n *\n * @param workerSpec Either a `path` to the worker JavaScript file, or the `source`\n * containing the full JavaScript source of the worker.\n */\nexport async function spawnAsyncModelRunner(workerSpec: { path: string } | { source: string }): Promise<ModelRunner> {\n  if (workerSpec['path']) {\n    return spawnAsyncModelRunnerWithWorker(new Worker(workerSpec['path']))\n  } else {\n    return spawnAsyncModelRunnerWithWorker(BlobWorker.fromText(workerSpec['source']))\n  }\n}\n\n/**\n * @hidden For internal use only\n */\nasync function spawnAsyncModelRunnerWithWorker(worker: Worker): Promise<ModelRunner> {\n  // Spawn the given Worker that contains the `ModelWorker`\n  const modelWorker = await spawn(worker)\n\n  // Wait for the worker to initialize the wasm model (in the worker thread)\n  const initResult = await modelWorker.initModel()\n\n  // Create a `ModelListing` instance if the listing was defined in the generated model\n  const modelListing = initResult.modelListing ? new ModelListing(initResult.modelListing) : undefined\n\n  // Maintain a `BufferedRunModelParams` instance that holds the I/O parameters\n  const params = new BufferedRunModelParams(modelListing)\n\n  // Use a flag to ensure that only one request is made at a time\n  let running = false\n\n  // Disallow `runModel` after the runner has been terminated\n  let terminated = false\n\n  return {\n    createOutputs: () => {\n      return new Outputs(initResult.outputVarIds, initResult.startTime, initResult.endTime, initResult.saveFreq)\n    },\n\n    runModel: async (inputs, outputs, options) => {\n      if (terminated) {\n        throw new Error('Async model runner has already been terminated')\n      } else if (running) {\n        throw new Error('Async model runner only supports one `runModel` call at a time')\n      } else {\n        running = true\n      }\n\n      // Update the I/O parameters\n      params.updateFromParams(inputs, outputs, options)\n\n      // Run the model in the worker. We pass the underlying `ArrayBuffer`\n      // instance back to the worker wrapped in a `Transfer` to make it\n      // no-copy transferable, and then the worker will return it back\n      // to us.\n      let ioBuffer: ArrayBuffer\n      try {\n        ioBuffer = await modelWorker.runModel(Transfer(params.getEncodedBuffer()))\n      } finally {\n        running = false\n      }\n\n      // Once the buffer is transferred to the worker, the buffer in the\n      // `BufferedRunModelParams` becomes \"detached\" and is no longer usable.\n      // After the buffer is transferred back from the worker, we need to\n      // restore the state of the object to use the new buffer.\n      params.updateFromEncodedBuffer(ioBuffer)\n\n      // Copy the output values and elapsed time from the buffer to the\n      // `Outputs` instance\n      params.finalizeOutputs(outputs)\n\n      return outputs\n    },\n\n    terminate: () => {\n      if (terminated) {\n        return Promise.resolve()\n      } else {\n        terminated = true\n        return Thread.terminate(modelWorker)\n      }\n    }\n  }\n}\n","// Copyright (c) 2020-2022 Climate Interactive / New Venture Fund\n\nimport type { TransferDescriptor } from 'threads'\nimport { expose, Transfer } from 'threads/worker'\n\nimport type { GeneratedModel, RunnableModel } from '@sdeverywhere/runtime'\nimport { BufferedRunModelParams, createRunnableModel } from '@sdeverywhere/runtime'\n\n/** @hidden */\nlet initGeneratedModel: () => Promise<GeneratedModel>\n\n/** @hidden */\nlet runnableModel: RunnableModel\n\n/**\n * Maintain a `BufferedRunModelParams` instance that wraps the transferable buffer\n * containing the I/O parameters.\n * @hidden\n */\nconst params = new BufferedRunModelParams()\n\ninterface InitResult {\n  outputVarIds: string[]\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  modelListing?: /*ModelListingSpecs*/ any\n  startTime: number\n  endTime: number\n  saveFreq: number\n  outputRowLength: number\n}\n\n/** @hidden */\nconst modelWorker = {\n  async initModel(): Promise<InitResult> {\n    if (runnableModel) {\n      throw new Error('RunnableModel was already initialized')\n    }\n\n    // Initialize the runnable model\n    const generatedModel = await initGeneratedModel()\n    runnableModel = createRunnableModel(generatedModel)\n\n    // Transfer the model metadata to the runner\n    return {\n      outputVarIds: runnableModel.outputVarIds,\n      modelListing: runnableModel.modelListing,\n      startTime: runnableModel.startTime,\n      endTime: runnableModel.endTime,\n      saveFreq: runnableModel.saveFreq,\n      outputRowLength: runnableModel.numSavePoints\n    }\n  },\n\n  runModel(ioBuffer: ArrayBuffer): TransferDescriptor<ArrayBuffer> {\n    if (!runnableModel) {\n      throw new Error('RunnableModel must be initialized before running the model in worker')\n    }\n\n    // Update the `BufferedRunModelParams` to use the values in the buffer that was transferred\n    // from the runner to the worker\n    params.updateFromEncodedBuffer(ioBuffer)\n\n    // Run the model synchronously on the worker thread using those I/O parameters\n    runnableModel.runModel(params)\n\n    // Transfer the buffer back to the runner\n    return Transfer(ioBuffer)\n  }\n}\n\n/**\n * Expose an object in the current worker thread that communicates with the\n * `ModelRunner` instance running in the main thread.  The exposed worker\n * object will take care of running the model on the worker thread and\n * sending the outputs back to the main thread.\n *\n * @param init The function that initializes the generated model instance that\n * is used in the worker thread.\n */\nexport function exposeModelWorker(init: () => Promise<GeneratedModel>): void {\n  // Save the initializer, which will be used when the runner calls `initModel`\n  // on the worker\n  initGeneratedModel = init\n\n  // Expose the worker implementation to `threads.js`\n  expose(modelWorker)\n}\n"],"mappings":";AAEA,SAAS,YAAY,OAAO,QAAQ,UAAU,cAAc;AAG5D,SAAS,wBAAwB,cAAc,eAAe;AAkC9D,eAAsB,sBAAsB,YAAyE;AACnH,MAAI,WAAW,MAAM,GAAG;AACtB,WAAO,gCAAgC,IAAI,OAAO,WAAW,MAAM,CAAC,CAAC;AAAA,EACvE,OAAO;AACL,WAAO,gCAAgC,WAAW,SAAS,WAAW,QAAQ,CAAC,CAAC;AAAA,EAClF;AACF;AAKA,eAAe,gCAAgC,QAAsC;AAEnF,QAAMA,eAAc,MAAM,MAAM,MAAM;AAGtC,QAAM,aAAa,MAAMA,aAAY,UAAU;AAG/C,QAAM,eAAe,WAAW,eAAe,IAAI,aAAa,WAAW,YAAY,IAAI;AAG3F,QAAMC,UAAS,IAAI,uBAAuB,YAAY;AAGtD,MAAI,UAAU;AAGd,MAAI,aAAa;AAEjB,SAAO;AAAA,IACL,eAAe,MAAM;AACnB,aAAO,IAAI,QAAQ,WAAW,cAAc,WAAW,WAAW,WAAW,SAAS,WAAW,QAAQ;AAAA,IAC3G;AAAA,IAEA,UAAU,OAAO,QAAQ,SAAS,YAAY;AAC5C,UAAI,YAAY;AACd,cAAM,IAAI,MAAM,gDAAgD;AAAA,MAClE,WAAW,SAAS;AAClB,cAAM,IAAI,MAAM,gEAAgE;AAAA,MAClF,OAAO;AACL,kBAAU;AAAA,MACZ;AAGA,MAAAA,QAAO,iBAAiB,QAAQ,SAAS,OAAO;AAMhD,UAAI;AACJ,UAAI;AACF,mBAAW,MAAMD,aAAY,SAAS,SAASC,QAAO,iBAAiB,CAAC,CAAC;AAAA,MAC3E,UAAE;AACA,kBAAU;AAAA,MACZ;AAMA,MAAAA,QAAO,wBAAwB,QAAQ;AAIvC,MAAAA,QAAO,gBAAgB,OAAO;AAE9B,aAAO;AAAA,IACT;AAAA,IAEA,WAAW,MAAM;AACf,UAAI,YAAY;AACd,eAAO,QAAQ,QAAQ;AAAA,MACzB,OAAO;AACL,qBAAa;AACb,eAAO,OAAO,UAAUD,YAAW;AAAA,MACrC;AAAA,IACF;AAAA,EACF;AACF;;;ACpHA,SAAS,QAAQ,YAAAE,iBAAgB;AAGjC,SAAS,0BAAAC,yBAAwB,2BAA2B;AAG5D,IAAI;AAGJ,IAAI;AAOJ,IAAM,SAAS,IAAIA,wBAAuB;AAa1C,IAAM,cAAc;AAAA,EAClB,MAAM,YAAiC;AACrC,QAAI,eAAe;AACjB,YAAM,IAAI,MAAM,uCAAuC;AAAA,IACzD;AAGA,UAAM,iBAAiB,MAAM,mBAAmB;AAChD,oBAAgB,oBAAoB,cAAc;AAGlD,WAAO;AAAA,MACL,cAAc,cAAc;AAAA,MAC5B,cAAc,cAAc;AAAA,MAC5B,WAAW,cAAc;AAAA,MACzB,SAAS,cAAc;AAAA,MACvB,UAAU,cAAc;AAAA,MACxB,iBAAiB,cAAc;AAAA,IACjC;AAAA,EACF;AAAA,EAEA,SAAS,UAAwD;AAC/D,QAAI,CAAC,eAAe;AAClB,YAAM,IAAI,MAAM,sEAAsE;AAAA,IACxF;AAIA,WAAO,wBAAwB,QAAQ;AAGvC,kBAAc,SAAS,MAAM;AAG7B,WAAOD,UAAS,QAAQ;AAAA,EAC1B;AACF;AAWO,SAAS,kBAAkB,MAA2C;AAG3E,uBAAqB;AAGrB,SAAO,WAAW;AACpB;","names":["modelWorker","params","Transfer","BufferedRunModelParams"]}

package/dist/runner.cjs

@@ -34,15 +34,15 @@ async function spawnAsyncModelRunner(workerSpec) {
 async function spawnAsyncModelRunnerWithWorker(worker) {
   const modelWorker = await (0, import_threads.spawn)(worker);
   const initResult = await modelWorker.initModel();
-  let ioBuffer = initResult.ioBuffer;
-  const rowLength = initResult.rowLength;
+  const modelListing = initResult.modelListing ? new import_runtime.ModelListing(initResult.modelListing) : void 0;
+  const params = new import_runtime.BufferedRunModelParams(modelListing);
   let running = false;
   let terminated = false;
   return {
     createOutputs: () => {
       return new import_runtime.Outputs(initResult.outputVarIds, initResult.startTime, initResult.endTime, initResult.saveFreq);
     },
-    runModel: async (inputs, outputs) => {
+    runModel: async (inputs, outputs, options) => {
       if (terminated) {
         throw new Error("Async model runner has already been terminated");
       } else if (running) {
@@ -50,24 +50,15 @@ async function spawnAsyncModelRunnerWithWorker(worker) {
       } else {
         running = true;
       }
-      const runTimeLengthInElements = 1;
-      const runTimeLengthInBytes = runTimeLengthInElements * 8;
-      const inputsLengthInElements = inputs.length;
-      const inputsLengthInBytes = inputsLengthInElements * 8;
-      const inputsArray = new Float64Array(ioBuffer, runTimeLengthInBytes, inputsLengthInElements);
-      for (let i = 0; i < inputs.length; i++) {
-        inputsArray[i] = inputs[i].get();
-      }
+      params.updateFromParams(inputs, outputs, options);
+      let ioBuffer;
       try {
-        ioBuffer = await modelWorker.runModel((0, import_threads.Transfer)(ioBuffer));
+        ioBuffer = await modelWorker.runModel((0, import_threads.Transfer)(params.getEncodedBuffer()));
       } finally {
         running = false;
       }
-      const runTimeBufferArray = new Float64Array(ioBuffer, 0, runTimeLengthInElements);
-      outputs.runTimeInMillis = runTimeBufferArray[0];
-      const outputsOffsetInBytes = runTimeLengthInBytes + inputsLengthInBytes;
-      const outputsArray = new Float64Array(ioBuffer, outputsOffsetInBytes);
-      outputs.updateFromBuffer(outputsArray, rowLength);
+      params.updateFromEncodedBuffer(ioBuffer);
+      params.finalizeOutputs(outputs);
       return outputs;
     },
     terminate: () => {

package/dist/runner.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/runner.ts"],"sourcesContent":["// Copyright (c) 2020-2022 Climate Interactive / New Venture Fund\n\nimport { BlobWorker, spawn, Thread, Transfer, Worker } from 'threads'\n\nimport type { ModelRunner } from '@sdeverywhere/runtime'\nimport { Outputs } from '@sdeverywhere/runtime'\n\n/**\n * Initialize a `ModelRunner` that runs the model asynchronously in a worker thread.\n *\n * In your app project, define a JavaScript file, called `worker.js` for example, that\n * initializes the model worker in the context of the Web Worker:\n *\n * ```js\n * import { initWasmModelAndBuffers } from '@sdeverywhere/runtime'\n * import { exposeModelWorker } from '@sdeverywhere/runtime-async/worker'\n *\n * async function initWasmModel() {\n *   const wasmModules = loadWasm()\n *   return initWasmModelAndBuffers(...)\n * }\n *\n * exposeModelWorker(initWasmModel)\n * ```\n *\n * Then, in your web app, call the `spawnAsyncModelRunner` function, which\n * will spawn the Web Worker and initialize the `ModelRunner` that communicates\n * with the worker:\n *\n * ```js\n * import { spawnAsyncModelRunner } from '@sdeverywhere/runtime-async/runner'\n *\n * async function initApp() {\n *   // ...\n *   const runner = await spawnAsyncModelRunner({ path: './worker.js' })\n *   // ...\n * }\n * ```\n *\n * @param workerSpec Either a `path` to the worker JavaScript file, or the `source`\n * containing the full JavaScript source of the worker.\n */\nexport async function spawnAsyncModelRunner(workerSpec: { path: string } | { source: string }): Promise<ModelRunner> {\n  if (workerSpec['path']) {\n    return spawnAsyncModelRunnerWithWorker(new Worker(workerSpec['path']))\n  } else {\n    return spawnAsyncModelRunnerWithWorker(BlobWorker.fromText(workerSpec['source']))\n  }\n}\n\n/**\n * @hidden For internal use only\n */\nasync function spawnAsyncModelRunnerWithWorker(worker: Worker): Promise<ModelRunner> {\n  // Spawn the given Worker that contains the `ModelWorker`\n  const modelWorker = await spawn(worker)\n\n  // Wait for the worker to initialize the wasm model (in the worker thread)\n  const initResult = await modelWorker.initModel()\n  let ioBuffer: ArrayBuffer = initResult.ioBuffer\n\n  // The row length is the number of elements in each row of the outputs buffer\n  const rowLength = initResult.rowLength\n\n  // Use a flag to ensure that only one request is made at a time\n  let running = false\n\n  // Disallow `runModel` after the runner has been terminated\n  let terminated = false\n\n  return {\n    createOutputs: () => {\n      return new Outputs(initResult.outputVarIds, initResult.startTime, initResult.endTime, initResult.saveFreq)\n    },\n\n    runModel: async (inputs, outputs) => {\n      if (terminated) {\n        throw new Error('Async model runner has already been terminated')\n      } else if (running) {\n        throw new Error('Async model runner only supports one `runModel` call at a time')\n      } else {\n        running = true\n      }\n\n      // The run time is stored in the first 8 bytes\n      const runTimeLengthInElements = 1\n      const runTimeLengthInBytes = runTimeLengthInElements * 8\n\n      // Capture the current set of input values into the reusable buffer\n      const inputsLengthInElements = inputs.length\n      const inputsLengthInBytes = inputsLengthInElements * 8\n      const inputsArray = new Float64Array(ioBuffer, runTimeLengthInBytes, inputsLengthInElements)\n      for (let i = 0; i < inputs.length; i++) {\n        inputsArray[i] = inputs[i].get()\n      }\n\n      // Run the model in the worker. We pass the underlying `ArrayBuffer`\n      // instance back to the worker wrapped in a `Transfer` to make it\n      // no-copy transferable, and then the worker will return it back\n      // to us.\n      try {\n        ioBuffer = await modelWorker.runModel(Transfer(ioBuffer))\n      } finally {\n        running = false\n      }\n\n      // Save the model run time\n      const runTimeBufferArray = new Float64Array(ioBuffer, 0, runTimeLengthInElements)\n      outputs.runTimeInMillis = runTimeBufferArray[0]\n\n      // Capture the outputs array by copying the data into the given `Outputs`\n      // data structure\n      const outputsOffsetInBytes = runTimeLengthInBytes + inputsLengthInBytes\n      const outputsArray = new Float64Array(ioBuffer, outputsOffsetInBytes)\n      outputs.updateFromBuffer(outputsArray, rowLength)\n\n      return outputs\n    },\n\n    terminate: () => {\n      if (terminated) {\n        return Promise.resolve()\n      } else {\n        terminated = true\n        return Thread.terminate(modelWorker)\n      }\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,qBAA4D;AAG5D,qBAAwB;AAqCxB,eAAsB,sBAAsB,YAAyE;AACnH,MAAI,WAAW,SAAS;AACtB,WAAO,gCAAgC,IAAI,sBAAO,WAAW,OAAO,CAAC;AAAA,EACvE,OAAO;AACL,WAAO,gCAAgC,0BAAW,SAAS,WAAW,SAAS,CAAC;AAAA,EAClF;AACF;AAKA,eAAe,gCAAgC,QAAsC;AAEnF,QAAM,cAAc,UAAM,sBAAM,MAAM;AAGtC,QAAM,aAAa,MAAM,YAAY,UAAU;AAC/C,MAAI,WAAwB,WAAW;AAGvC,QAAM,YAAY,WAAW;AAG7B,MAAI,UAAU;AAGd,MAAI,aAAa;AAEjB,SAAO;AAAA,IACL,eAAe,MAAM;AACnB,aAAO,IAAI,uBAAQ,WAAW,cAAc,WAAW,WAAW,WAAW,SAAS,WAAW,QAAQ;AAAA,IAC3G;AAAA,IAEA,UAAU,OAAO,QAAQ,YAAY;AACnC,UAAI,YAAY;AACd,cAAM,IAAI,MAAM,gDAAgD;AAAA,MAClE,WAAW,SAAS;AAClB,cAAM,IAAI,MAAM,gEAAgE;AAAA,MAClF,OAAO;AACL,kBAAU;AAAA,MACZ;AAGA,YAAM,0BAA0B;AAChC,YAAM,uBAAuB,0BAA0B;AAGvD,YAAM,yBAAyB,OAAO;AACtC,YAAM,sBAAsB,yBAAyB;AACrD,YAAM,cAAc,IAAI,aAAa,UAAU,sBAAsB,sBAAsB;AAC3F,eAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;AACtC,oBAAY,KAAK,OAAO,GAAG,IAAI;AAAA,MACjC;AAMA,UAAI;AACF,mBAAW,MAAM,YAAY,aAAS,yBAAS,QAAQ,CAAC;AAAA,MAC1D,UAAE;AACA,kBAAU;AAAA,MACZ;AAGA,YAAM,qBAAqB,IAAI,aAAa,UAAU,GAAG,uBAAuB;AAChF,cAAQ,kBAAkB,mBAAmB;AAI7C,YAAM,uBAAuB,uBAAuB;AACpD,YAAM,eAAe,IAAI,aAAa,UAAU,oBAAoB;AACpE,cAAQ,iBAAiB,cAAc,SAAS;AAEhD,aAAO;AAAA,IACT;AAAA,IAEA,WAAW,MAAM;AACf,UAAI,YAAY;AACd,eAAO,QAAQ,QAAQ;AAAA,MACzB,OAAO;AACL,qBAAa;AACb,eAAO,sBAAO,UAAU,WAAW;AAAA,MACrC;AAAA,IACF;AAAA,EACF;AACF;","names":[]}
+{"version":3,"sources":["../src/runner.ts"],"sourcesContent":["// Copyright (c) 2020-2022 Climate Interactive / New Venture Fund\n\nimport { BlobWorker, spawn, Thread, Transfer, Worker } from 'threads'\n\nimport type { ModelRunner } from '@sdeverywhere/runtime'\nimport { BufferedRunModelParams, ModelListing, Outputs } from '@sdeverywhere/runtime'\n\n/**\n * Initialize a `ModelRunner` that runs the model asynchronously in a worker\n * (a Web Worker when running in a browser environment, or a worker thread\n * when running in a Node.js environment).\n *\n * In your app project, define a JavaScript file, called `worker.js` for example,\n * that initializes the generated model in the context of a worker thread:\n *\n * ```js\n * import { exposeModelWorker } from '@sdeverywhere/runtime-async/worker'\n * import loadGeneratedModel from './sde-prep/generated-model.js'\n *\n * exposeModelWorker(loadGeneratedModel)\n * ```\n *\n * Then, in your web app, call the `spawnAsyncModelRunner` function, which\n * will spawn the worker thread and initialize the `ModelRunner` that communicates\n * with the worker:\n *\n * ```js\n * import { spawnAsyncModelRunner } from '@sdeverywhere/runtime-async/runner'\n *\n * async function initApp() {\n *   // ...\n *   const runner = await spawnAsyncModelRunner({ path: './worker.js' })\n *   // ...\n * }\n * ```\n *\n * @param workerSpec Either a `path` to the worker JavaScript file, or the `source`\n * containing the full JavaScript source of the worker.\n */\nexport async function spawnAsyncModelRunner(workerSpec: { path: string } | { source: string }): Promise<ModelRunner> {\n  if (workerSpec['path']) {\n    return spawnAsyncModelRunnerWithWorker(new Worker(workerSpec['path']))\n  } else {\n    return spawnAsyncModelRunnerWithWorker(BlobWorker.fromText(workerSpec['source']))\n  }\n}\n\n/**\n * @hidden For internal use only\n */\nasync function spawnAsyncModelRunnerWithWorker(worker: Worker): Promise<ModelRunner> {\n  // Spawn the given Worker that contains the `ModelWorker`\n  const modelWorker = await spawn(worker)\n\n  // Wait for the worker to initialize the wasm model (in the worker thread)\n  const initResult = await modelWorker.initModel()\n\n  // Create a `ModelListing` instance if the listing was defined in the generated model\n  const modelListing = initResult.modelListing ? new ModelListing(initResult.modelListing) : undefined\n\n  // Maintain a `BufferedRunModelParams` instance that holds the I/O parameters\n  const params = new BufferedRunModelParams(modelListing)\n\n  // Use a flag to ensure that only one request is made at a time\n  let running = false\n\n  // Disallow `runModel` after the runner has been terminated\n  let terminated = false\n\n  return {\n    createOutputs: () => {\n      return new Outputs(initResult.outputVarIds, initResult.startTime, initResult.endTime, initResult.saveFreq)\n    },\n\n    runModel: async (inputs, outputs, options) => {\n      if (terminated) {\n        throw new Error('Async model runner has already been terminated')\n      } else if (running) {\n        throw new Error('Async model runner only supports one `runModel` call at a time')\n      } else {\n        running = true\n      }\n\n      // Update the I/O parameters\n      params.updateFromParams(inputs, outputs, options)\n\n      // Run the model in the worker. We pass the underlying `ArrayBuffer`\n      // instance back to the worker wrapped in a `Transfer` to make it\n      // no-copy transferable, and then the worker will return it back\n      // to us.\n      let ioBuffer: ArrayBuffer\n      try {\n        ioBuffer = await modelWorker.runModel(Transfer(params.getEncodedBuffer()))\n      } finally {\n        running = false\n      }\n\n      // Once the buffer is transferred to the worker, the buffer in the\n      // `BufferedRunModelParams` becomes \"detached\" and is no longer usable.\n      // After the buffer is transferred back from the worker, we need to\n      // restore the state of the object to use the new buffer.\n      params.updateFromEncodedBuffer(ioBuffer)\n\n      // Copy the output values and elapsed time from the buffer to the\n      // `Outputs` instance\n      params.finalizeOutputs(outputs)\n\n      return outputs\n    },\n\n    terminate: () => {\n      if (terminated) {\n        return Promise.resolve()\n      } else {\n        terminated = true\n        return Thread.terminate(modelWorker)\n      }\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,qBAA4D;AAG5D,qBAA8D;AAkC9D,eAAsB,sBAAsB,YAAyE;AACnH,MAAI,WAAW,MAAM,GAAG;AACtB,WAAO,gCAAgC,IAAI,sBAAO,WAAW,MAAM,CAAC,CAAC;AAAA,EACvE,OAAO;AACL,WAAO,gCAAgC,0BAAW,SAAS,WAAW,QAAQ,CAAC,CAAC;AAAA,EAClF;AACF;AAKA,eAAe,gCAAgC,QAAsC;AAEnF,QAAM,cAAc,UAAM,sBAAM,MAAM;AAGtC,QAAM,aAAa,MAAM,YAAY,UAAU;AAG/C,QAAM,eAAe,WAAW,eAAe,IAAI,4BAAa,WAAW,YAAY,IAAI;AAG3F,QAAM,SAAS,IAAI,sCAAuB,YAAY;AAGtD,MAAI,UAAU;AAGd,MAAI,aAAa;AAEjB,SAAO;AAAA,IACL,eAAe,MAAM;AACnB,aAAO,IAAI,uBAAQ,WAAW,cAAc,WAAW,WAAW,WAAW,SAAS,WAAW,QAAQ;AAAA,IAC3G;AAAA,IAEA,UAAU,OAAO,QAAQ,SAAS,YAAY;AAC5C,UAAI,YAAY;AACd,cAAM,IAAI,MAAM,gDAAgD;AAAA,MAClE,WAAW,SAAS;AAClB,cAAM,IAAI,MAAM,gEAAgE;AAAA,MAClF,OAAO;AACL,kBAAU;AAAA,MACZ;AAGA,aAAO,iBAAiB,QAAQ,SAAS,OAAO;AAMhD,UAAI;AACJ,UAAI;AACF,mBAAW,MAAM,YAAY,aAAS,yBAAS,OAAO,iBAAiB,CAAC,CAAC;AAAA,MAC3E,UAAE;AACA,kBAAU;AAAA,MACZ;AAMA,aAAO,wBAAwB,QAAQ;AAIvC,aAAO,gBAAgB,OAAO;AAE9B,aAAO;AAAA,IACT;AAAA,IAEA,WAAW,MAAM;AACf,UAAI,YAAY;AACd,eAAO,QAAQ,QAAQ;AAAA,MACzB,OAAO;AACL,qBAAa;AACb,eAAO,sBAAO,UAAU,WAAW;AAAA,MACrC;AAAA,IACF;AAAA,EACF;AACF;","names":[]}

package/dist/runner.d.cts

@@ -0,0 +1,41 @@
+import { ModelRunner } from '@sdeverywhere/runtime';
+
+/**
+ * Initialize a `ModelRunner` that runs the model asynchronously in a worker
+ * (a Web Worker when running in a browser environment, or a worker thread
+ * when running in a Node.js environment).
+ *
+ * In your app project, define a JavaScript file, called `worker.js` for example,
+ * that initializes the generated model in the context of a worker thread:
+ *
+ * ```js
+ * import { exposeModelWorker } from '@sdeverywhere/runtime-async/worker'
+ * import loadGeneratedModel from './sde-prep/generated-model.js'
+ *
+ * exposeModelWorker(loadGeneratedModel)
+ * ```
+ *
+ * Then, in your web app, call the `spawnAsyncModelRunner` function, which
+ * will spawn the worker thread and initialize the `ModelRunner` that communicates
+ * with the worker:
+ *
+ * ```js
+ * import { spawnAsyncModelRunner } from '@sdeverywhere/runtime-async/runner'
+ *
+ * async function initApp() {
+ *   // ...
+ *   const runner = await spawnAsyncModelRunner({ path: './worker.js' })
+ *   // ...
+ * }
+ * ```
+ *
+ * @param workerSpec Either a `path` to the worker JavaScript file, or the `source`
+ * containing the full JavaScript source of the worker.
+ */
+declare function spawnAsyncModelRunner(workerSpec: {
+    path: string;
+} | {
+    source: string;
+}): Promise<ModelRunner>;
+
+export { spawnAsyncModelRunner };

package/dist/runner.d.ts

@@ -1,25 +1,22 @@
 import { ModelRunner } from '@sdeverywhere/runtime';
 
 /**
- * Initialize a `ModelRunner` that runs the model asynchronously in a worker thread.
+ * Initialize a `ModelRunner` that runs the model asynchronously in a worker
+ * (a Web Worker when running in a browser environment, or a worker thread
+ * when running in a Node.js environment).
  *
- * In your app project, define a JavaScript file, called `worker.js` for example, that
- * initializes the model worker in the context of the Web Worker:
+ * In your app project, define a JavaScript file, called `worker.js` for example,
+ * that initializes the generated model in the context of a worker thread:
  *
  * ```js
- * import { initWasmModelAndBuffers } from '@sdeverywhere/runtime'
  * import { exposeModelWorker } from '@sdeverywhere/runtime-async/worker'
+ * import loadGeneratedModel from './sde-prep/generated-model.js'
  *
- * async function initWasmModel() {
- *   const wasmModules = loadWasm()
- *   return initWasmModelAndBuffers(...)
- * }
- *
- * exposeModelWorker(initWasmModel)
+ * exposeModelWorker(loadGeneratedModel)
  * ```
  *
  * Then, in your web app, call the `spawnAsyncModelRunner` function, which
- * will spawn the Web Worker and initialize the `ModelRunner` that communicates
+ * will spawn the worker thread and initialize the `ModelRunner` that communicates
  * with the worker:
  *
  * ```js

package/dist/runner.js

@@ -1,6 +1,6 @@
 // src/runner.ts
 import { BlobWorker, spawn, Thread, Transfer, Worker } from "threads";
-import { Outputs } from "@sdeverywhere/runtime";
+import { BufferedRunModelParams, ModelListing, Outputs } from "@sdeverywhere/runtime";
 async function spawnAsyncModelRunner(workerSpec) {
   if (workerSpec["path"]) {
     return spawnAsyncModelRunnerWithWorker(new Worker(workerSpec["path"]));
@@ -11,15 +11,15 @@ async function spawnAsyncModelRunner(workerSpec) {
 async function spawnAsyncModelRunnerWithWorker(worker) {
   const modelWorker = await spawn(worker);
   const initResult = await modelWorker.initModel();
-  let ioBuffer = initResult.ioBuffer;
-  const rowLength = initResult.rowLength;
+  const modelListing = initResult.modelListing ? new ModelListing(initResult.modelListing) : void 0;
+  const params = new BufferedRunModelParams(modelListing);
   let running = false;
   let terminated = false;
   return {
     createOutputs: () => {
       return new Outputs(initResult.outputVarIds, initResult.startTime, initResult.endTime, initResult.saveFreq);
     },
-    runModel: async (inputs, outputs) => {
+    runModel: async (inputs, outputs, options) => {
       if (terminated) {
         throw new Error("Async model runner has already been terminated");
       } else if (running) {
@@ -27,24 +27,15 @@ async function spawnAsyncModelRunnerWithWorker(worker) {
       } else {
         running = true;
       }
-      const runTimeLengthInElements = 1;
-      const runTimeLengthInBytes = runTimeLengthInElements * 8;
-      const inputsLengthInElements = inputs.length;
-      const inputsLengthInBytes = inputsLengthInElements * 8;
-      const inputsArray = new Float64Array(ioBuffer, runTimeLengthInBytes, inputsLengthInElements);
-      for (let i = 0; i < inputs.length; i++) {
-        inputsArray[i] = inputs[i].get();
-      }
+      params.updateFromParams(inputs, outputs, options);
+      let ioBuffer;
       try {
-        ioBuffer = await modelWorker.runModel(Transfer(ioBuffer));
+        ioBuffer = await modelWorker.runModel(Transfer(params.getEncodedBuffer()));
       } finally {
         running = false;
       }
-      const runTimeBufferArray = new Float64Array(ioBuffer, 0, runTimeLengthInElements);
-      outputs.runTimeInMillis = runTimeBufferArray[0];
-      const outputsOffsetInBytes = runTimeLengthInBytes + inputsLengthInBytes;
-      const outputsArray = new Float64Array(ioBuffer, outputsOffsetInBytes);
-      outputs.updateFromBuffer(outputsArray, rowLength);
+      params.updateFromEncodedBuffer(ioBuffer);
+      params.finalizeOutputs(outputs);
       return outputs;
     },
     terminate: () => {

package/dist/runner.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/runner.ts"],"sourcesContent":["// Copyright (c) 2020-2022 Climate Interactive / New Venture Fund\n\nimport { BlobWorker, spawn, Thread, Transfer, Worker } from 'threads'\n\nimport type { ModelRunner } from '@sdeverywhere/runtime'\nimport { Outputs } from '@sdeverywhere/runtime'\n\n/**\n * Initialize a `ModelRunner` that runs the model asynchronously in a worker thread.\n *\n * In your app project, define a JavaScript file, called `worker.js` for example, that\n * initializes the model worker in the context of the Web Worker:\n *\n * ```js\n * import { initWasmModelAndBuffers } from '@sdeverywhere/runtime'\n * import { exposeModelWorker } from '@sdeverywhere/runtime-async/worker'\n *\n * async function initWasmModel() {\n *   const wasmModules = loadWasm()\n *   return initWasmModelAndBuffers(...)\n * }\n *\n * exposeModelWorker(initWasmModel)\n * ```\n *\n * Then, in your web app, call the `spawnAsyncModelRunner` function, which\n * will spawn the Web Worker and initialize the `ModelRunner` that communicates\n * with the worker:\n *\n * ```js\n * import { spawnAsyncModelRunner } from '@sdeverywhere/runtime-async/runner'\n *\n * async function initApp() {\n *   // ...\n *   const runner = await spawnAsyncModelRunner({ path: './worker.js' })\n *   // ...\n * }\n * ```\n *\n * @param workerSpec Either a `path` to the worker JavaScript file, or the `source`\n * containing the full JavaScript source of the worker.\n */\nexport async function spawnAsyncModelRunner(workerSpec: { path: string } | { source: string }): Promise<ModelRunner> {\n  if (workerSpec['path']) {\n    return spawnAsyncModelRunnerWithWorker(new Worker(workerSpec['path']))\n  } else {\n    return spawnAsyncModelRunnerWithWorker(BlobWorker.fromText(workerSpec['source']))\n  }\n}\n\n/**\n * @hidden For internal use only\n */\nasync function spawnAsyncModelRunnerWithWorker(worker: Worker): Promise<ModelRunner> {\n  // Spawn the given Worker that contains the `ModelWorker`\n  const modelWorker = await spawn(worker)\n\n  // Wait for the worker to initialize the wasm model (in the worker thread)\n  const initResult = await modelWorker.initModel()\n  let ioBuffer: ArrayBuffer = initResult.ioBuffer\n\n  // The row length is the number of elements in each row of the outputs buffer\n  const rowLength = initResult.rowLength\n\n  // Use a flag to ensure that only one request is made at a time\n  let running = false\n\n  // Disallow `runModel` after the runner has been terminated\n  let terminated = false\n\n  return {\n    createOutputs: () => {\n      return new Outputs(initResult.outputVarIds, initResult.startTime, initResult.endTime, initResult.saveFreq)\n    },\n\n    runModel: async (inputs, outputs) => {\n      if (terminated) {\n        throw new Error('Async model runner has already been terminated')\n      } else if (running) {\n        throw new Error('Async model runner only supports one `runModel` call at a time')\n      } else {\n        running = true\n      }\n\n      // The run time is stored in the first 8 bytes\n      const runTimeLengthInElements = 1\n      const runTimeLengthInBytes = runTimeLengthInElements * 8\n\n      // Capture the current set of input values into the reusable buffer\n      const inputsLengthInElements = inputs.length\n      const inputsLengthInBytes = inputsLengthInElements * 8\n      const inputsArray = new Float64Array(ioBuffer, runTimeLengthInBytes, inputsLengthInElements)\n      for (let i = 0; i < inputs.length; i++) {\n        inputsArray[i] = inputs[i].get()\n      }\n\n      // Run the model in the worker. We pass the underlying `ArrayBuffer`\n      // instance back to the worker wrapped in a `Transfer` to make it\n      // no-copy transferable, and then the worker will return it back\n      // to us.\n      try {\n        ioBuffer = await modelWorker.runModel(Transfer(ioBuffer))\n      } finally {\n        running = false\n      }\n\n      // Save the model run time\n      const runTimeBufferArray = new Float64Array(ioBuffer, 0, runTimeLengthInElements)\n      outputs.runTimeInMillis = runTimeBufferArray[0]\n\n      // Capture the outputs array by copying the data into the given `Outputs`\n      // data structure\n      const outputsOffsetInBytes = runTimeLengthInBytes + inputsLengthInBytes\n      const outputsArray = new Float64Array(ioBuffer, outputsOffsetInBytes)\n      outputs.updateFromBuffer(outputsArray, rowLength)\n\n      return outputs\n    },\n\n    terminate: () => {\n      if (terminated) {\n        return Promise.resolve()\n      } else {\n        terminated = true\n        return Thread.terminate(modelWorker)\n      }\n    }\n  }\n}\n"],"mappings":";AAEA,SAAS,YAAY,OAAO,QAAQ,UAAU,cAAc;AAG5D,SAAS,eAAe;AAqCxB,eAAsB,sBAAsB,YAAyE;AACnH,MAAI,WAAW,SAAS;AACtB,WAAO,gCAAgC,IAAI,OAAO,WAAW,OAAO,CAAC;AAAA,EACvE,OAAO;AACL,WAAO,gCAAgC,WAAW,SAAS,WAAW,SAAS,CAAC;AAAA,EAClF;AACF;AAKA,eAAe,gCAAgC,QAAsC;AAEnF,QAAM,cAAc,MAAM,MAAM,MAAM;AAGtC,QAAM,aAAa,MAAM,YAAY,UAAU;AAC/C,MAAI,WAAwB,WAAW;AAGvC,QAAM,YAAY,WAAW;AAG7B,MAAI,UAAU;AAGd,MAAI,aAAa;AAEjB,SAAO;AAAA,IACL,eAAe,MAAM;AACnB,aAAO,IAAI,QAAQ,WAAW,cAAc,WAAW,WAAW,WAAW,SAAS,WAAW,QAAQ;AAAA,IAC3G;AAAA,IAEA,UAAU,OAAO,QAAQ,YAAY;AACnC,UAAI,YAAY;AACd,cAAM,IAAI,MAAM,gDAAgD;AAAA,MAClE,WAAW,SAAS;AAClB,cAAM,IAAI,MAAM,gEAAgE;AAAA,MAClF,OAAO;AACL,kBAAU;AAAA,MACZ;AAGA,YAAM,0BAA0B;AAChC,YAAM,uBAAuB,0BAA0B;AAGvD,YAAM,yBAAyB,OAAO;AACtC,YAAM,sBAAsB,yBAAyB;AACrD,YAAM,cAAc,IAAI,aAAa,UAAU,sBAAsB,sBAAsB;AAC3F,eAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;AACtC,oBAAY,KAAK,OAAO,GAAG,IAAI;AAAA,MACjC;AAMA,UAAI;AACF,mBAAW,MAAM,YAAY,SAAS,SAAS,QAAQ,CAAC;AAAA,MAC1D,UAAE;AACA,kBAAU;AAAA,MACZ;AAGA,YAAM,qBAAqB,IAAI,aAAa,UAAU,GAAG,uBAAuB;AAChF,cAAQ,kBAAkB,mBAAmB;AAI7C,YAAM,uBAAuB,uBAAuB;AACpD,YAAM,eAAe,IAAI,aAAa,UAAU,oBAAoB;AACpE,cAAQ,iBAAiB,cAAc,SAAS;AAEhD,aAAO;AAAA,IACT;AAAA,IAEA,WAAW,MAAM;AACf,UAAI,YAAY;AACd,eAAO,QAAQ,QAAQ;AAAA,MACzB,OAAO;AACL,qBAAa;AACb,eAAO,OAAO,UAAU,WAAW;AAAA,MACrC;AAAA,IACF;AAAA,EACF;AACF;","names":[]}
+{"version":3,"sources":["../src/runner.ts"],"sourcesContent":["// Copyright (c) 2020-2022 Climate Interactive / New Venture Fund\n\nimport { BlobWorker, spawn, Thread, Transfer, Worker } from 'threads'\n\nimport type { ModelRunner } from '@sdeverywhere/runtime'\nimport { BufferedRunModelParams, ModelListing, Outputs } from '@sdeverywhere/runtime'\n\n/**\n * Initialize a `ModelRunner` that runs the model asynchronously in a worker\n * (a Web Worker when running in a browser environment, or a worker thread\n * when running in a Node.js environment).\n *\n * In your app project, define a JavaScript file, called `worker.js` for example,\n * that initializes the generated model in the context of a worker thread:\n *\n * ```js\n * import { exposeModelWorker } from '@sdeverywhere/runtime-async/worker'\n * import loadGeneratedModel from './sde-prep/generated-model.js'\n *\n * exposeModelWorker(loadGeneratedModel)\n * ```\n *\n * Then, in your web app, call the `spawnAsyncModelRunner` function, which\n * will spawn the worker thread and initialize the `ModelRunner` that communicates\n * with the worker:\n *\n * ```js\n * import { spawnAsyncModelRunner } from '@sdeverywhere/runtime-async/runner'\n *\n * async function initApp() {\n *   // ...\n *   const runner = await spawnAsyncModelRunner({ path: './worker.js' })\n *   // ...\n * }\n * ```\n *\n * @param workerSpec Either a `path` to the worker JavaScript file, or the `source`\n * containing the full JavaScript source of the worker.\n */\nexport async function spawnAsyncModelRunner(workerSpec: { path: string } | { source: string }): Promise<ModelRunner> {\n  if (workerSpec['path']) {\n    return spawnAsyncModelRunnerWithWorker(new Worker(workerSpec['path']))\n  } else {\n    return spawnAsyncModelRunnerWithWorker(BlobWorker.fromText(workerSpec['source']))\n  }\n}\n\n/**\n * @hidden For internal use only\n */\nasync function spawnAsyncModelRunnerWithWorker(worker: Worker): Promise<ModelRunner> {\n  // Spawn the given Worker that contains the `ModelWorker`\n  const modelWorker = await spawn(worker)\n\n  // Wait for the worker to initialize the wasm model (in the worker thread)\n  const initResult = await modelWorker.initModel()\n\n  // Create a `ModelListing` instance if the listing was defined in the generated model\n  const modelListing = initResult.modelListing ? new ModelListing(initResult.modelListing) : undefined\n\n  // Maintain a `BufferedRunModelParams` instance that holds the I/O parameters\n  const params = new BufferedRunModelParams(modelListing)\n\n  // Use a flag to ensure that only one request is made at a time\n  let running = false\n\n  // Disallow `runModel` after the runner has been terminated\n  let terminated = false\n\n  return {\n    createOutputs: () => {\n      return new Outputs(initResult.outputVarIds, initResult.startTime, initResult.endTime, initResult.saveFreq)\n    },\n\n    runModel: async (inputs, outputs, options) => {\n      if (terminated) {\n        throw new Error('Async model runner has already been terminated')\n      } else if (running) {\n        throw new Error('Async model runner only supports one `runModel` call at a time')\n      } else {\n        running = true\n      }\n\n      // Update the I/O parameters\n      params.updateFromParams(inputs, outputs, options)\n\n      // Run the model in the worker. We pass the underlying `ArrayBuffer`\n      // instance back to the worker wrapped in a `Transfer` to make it\n      // no-copy transferable, and then the worker will return it back\n      // to us.\n      let ioBuffer: ArrayBuffer\n      try {\n        ioBuffer = await modelWorker.runModel(Transfer(params.getEncodedBuffer()))\n      } finally {\n        running = false\n      }\n\n      // Once the buffer is transferred to the worker, the buffer in the\n      // `BufferedRunModelParams` becomes \"detached\" and is no longer usable.\n      // After the buffer is transferred back from the worker, we need to\n      // restore the state of the object to use the new buffer.\n      params.updateFromEncodedBuffer(ioBuffer)\n\n      // Copy the output values and elapsed time from the buffer to the\n      // `Outputs` instance\n      params.finalizeOutputs(outputs)\n\n      return outputs\n    },\n\n    terminate: () => {\n      if (terminated) {\n        return Promise.resolve()\n      } else {\n        terminated = true\n        return Thread.terminate(modelWorker)\n      }\n    }\n  }\n}\n"],"mappings":";AAEA,SAAS,YAAY,OAAO,QAAQ,UAAU,cAAc;AAG5D,SAAS,wBAAwB,cAAc,eAAe;AAkC9D,eAAsB,sBAAsB,YAAyE;AACnH,MAAI,WAAW,MAAM,GAAG;AACtB,WAAO,gCAAgC,IAAI,OAAO,WAAW,MAAM,CAAC,CAAC;AAAA,EACvE,OAAO;AACL,WAAO,gCAAgC,WAAW,SAAS,WAAW,QAAQ,CAAC,CAAC;AAAA,EAClF;AACF;AAKA,eAAe,gCAAgC,QAAsC;AAEnF,QAAM,cAAc,MAAM,MAAM,MAAM;AAGtC,QAAM,aAAa,MAAM,YAAY,UAAU;AAG/C,QAAM,eAAe,WAAW,eAAe,IAAI,aAAa,WAAW,YAAY,IAAI;AAG3F,QAAM,SAAS,IAAI,uBAAuB,YAAY;AAGtD,MAAI,UAAU;AAGd,MAAI,aAAa;AAEjB,SAAO;AAAA,IACL,eAAe,MAAM;AACnB,aAAO,IAAI,QAAQ,WAAW,cAAc,WAAW,WAAW,WAAW,SAAS,WAAW,QAAQ;AAAA,IAC3G;AAAA,IAEA,UAAU,OAAO,QAAQ,SAAS,YAAY;AAC5C,UAAI,YAAY;AACd,cAAM,IAAI,MAAM,gDAAgD;AAAA,MAClE,WAAW,SAAS;AAClB,cAAM,IAAI,MAAM,gEAAgE;AAAA,MAClF,OAAO;AACL,kBAAU;AAAA,MACZ;AAGA,aAAO,iBAAiB,QAAQ,SAAS,OAAO;AAMhD,UAAI;AACJ,UAAI;AACF,mBAAW,MAAM,YAAY,SAAS,SAAS,OAAO,iBAAiB,CAAC,CAAC;AAAA,MAC3E,UAAE;AACA,kBAAU;AAAA,MACZ;AAMA,aAAO,wBAAwB,QAAQ;AAIvC,aAAO,gBAAgB,OAAO;AAE9B,aAAO;AAAA,IACT;AAAA,IAEA,WAAW,MAAM;AACf,UAAI,YAAY;AACd,eAAO,QAAQ,QAAQ;AAAA,MACzB,OAAO;AACL,qBAAa;AACb,eAAO,OAAO,UAAU,WAAW;AAAA,MACrC;AAAA,IACF;AAAA,EACF;AACF;","names":[]}

package/dist/worker.cjs

@@ -24,58 +24,36 @@ __export(worker_exports, {
 module.exports = __toCommonJS(worker_exports);
 var import_worker = require("threads/worker");
 var import_runtime = require("@sdeverywhere/runtime");
-var initWasmModel;
-var wasmModel;
-var inputsWasmBuffer;
-var outputsWasmBuffer;
+var initGeneratedModel;
+var runnableModel;
+var params = new import_runtime.BufferedRunModelParams();
 var modelWorker = {
   async initModel() {
-    if (wasmModel) {
-      throw new Error("WasmModel was already initialized");
+    if (runnableModel) {
+      throw new Error("RunnableModel was already initialized");
     }
-    const wasmResult = await initWasmModel();
-    wasmModel = wasmResult.model;
-    inputsWasmBuffer = wasmResult.inputsBuffer;
-    outputsWasmBuffer = wasmResult.outputsBuffer;
-    const runTimeLength = 8;
-    const inputsLength = inputsWasmBuffer.getArrayView().length;
-    const outputsLength = outputsWasmBuffer.getArrayView().length;
-    const ioArray = new Float64Array(runTimeLength + inputsLength + outputsLength);
-    const ioBuffer = ioArray.buffer;
-    const initResult = {
-      outputVarIds: wasmResult.outputVarIds,
-      startTime: wasmModel.startTime,
-      endTime: wasmModel.endTime,
-      saveFreq: wasmModel.saveFreq,
-      rowLength: wasmModel.numSavePoints,
-      ioBuffer
+    const generatedModel = await initGeneratedModel();
+    runnableModel = (0, import_runtime.createRunnableModel)(generatedModel);
+    return {
+      outputVarIds: runnableModel.outputVarIds,
+      modelListing: runnableModel.modelListing,
+      startTime: runnableModel.startTime,
+      endTime: runnableModel.endTime,
+      saveFreq: runnableModel.saveFreq,
+      outputRowLength: runnableModel.numSavePoints
     };
-    return (0, import_worker.Transfer)(initResult, [ioBuffer]);
   },
   runModel(ioBuffer) {
-    if (!wasmModel) {
-      throw new Error("WasmModel must be initialized before running the model in worker");
+    if (!runnableModel) {
+      throw new Error("RunnableModel must be initialized before running the model in worker");
     }
-    const runTimeLengthInElements = 1;
-    const runTimeLengthInBytes = runTimeLengthInElements * 8;
-    const inputsWasmArray = inputsWasmBuffer.getArrayView();
-    const inputsLengthInElements = inputsWasmArray.length;
-    const inputsLengthInBytes = inputsLengthInElements * 8;
-    const inputsBufferArray = new Float64Array(ioBuffer, runTimeLengthInBytes, inputsLengthInElements);
-    inputsWasmArray.set(inputsBufferArray);
-    const t0 = (0, import_runtime.perfNow)();
-    wasmModel.runModel(inputsWasmBuffer, outputsWasmBuffer);
-    const elapsed = (0, import_runtime.perfElapsed)(t0);
-    const runTimeBufferArray = new Float64Array(ioBuffer, 0, runTimeLengthInElements);
-    runTimeBufferArray[0] = elapsed;
-    const outputsOffsetInBytes = runTimeLengthInBytes + inputsLengthInBytes;
-    const outputsBufferArray = new Float64Array(ioBuffer, outputsOffsetInBytes);
-    outputsBufferArray.set(outputsWasmBuffer.getArrayView());
+    params.updateFromEncodedBuffer(ioBuffer);
+    runnableModel.runModel(params);
     return (0, import_worker.Transfer)(ioBuffer);
   }
 };
 function exposeModelWorker(init) {
-  initWasmModel = init;
+  initGeneratedModel = init;
   (0, import_worker.expose)(modelWorker);
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/worker.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/worker.ts"],"sourcesContent":["// Copyright (c) 2020-2022 Climate Interactive / New Venture Fund\n\nimport type { TransferDescriptor } from 'threads'\nimport { expose, Transfer } from 'threads/worker'\n\nimport type { WasmBuffer, WasmModel, WasmModelInitResult } from '@sdeverywhere/runtime'\nimport { perfElapsed, perfNow } from '@sdeverywhere/runtime'\n\n/** @hidden */\nlet initWasmModel: () => Promise<WasmModelInitResult>\n/** @hidden */\nlet wasmModel: WasmModel\n/** @hidden */\nlet inputsWasmBuffer: WasmBuffer\n/** @hidden */\nlet outputsWasmBuffer: WasmBuffer\n\ninterface InitResult {\n  outputVarIds: string[]\n  startTime: number\n  endTime: number\n  saveFreq: number\n  rowLength: number\n  ioBuffer: ArrayBuffer\n}\n\n/** @hidden */\nconst modelWorker = {\n  async initModel(): Promise<TransferDescriptor<InitResult>> {\n    if (wasmModel) {\n      throw new Error('WasmModel was already initialized')\n    }\n\n    // Initialize the wasm model and associated buffers\n    const wasmResult = await initWasmModel()\n\n    // Capture the `WasmModel` instance and `WasmBuffer` instances\n    wasmModel = wasmResult.model\n    inputsWasmBuffer = wasmResult.inputsBuffer\n    outputsWasmBuffer = wasmResult.outputsBuffer\n\n    // Create a combined array that will hold a copy of the inputs and outputs\n    // wasm buffers; this buffer is no-copy transferable, whereas the wasm ones\n    // are not allowed to be transferred\n    const runTimeLength = 8\n    const inputsLength = inputsWasmBuffer.getArrayView().length\n    const outputsLength = outputsWasmBuffer.getArrayView().length\n    const ioArray = new Float64Array(runTimeLength + inputsLength + outputsLength)\n\n    // Transfer the underlying buffer to the runner\n    const ioBuffer = ioArray.buffer\n    const initResult: InitResult = {\n      outputVarIds: wasmResult.outputVarIds,\n      startTime: wasmModel.startTime,\n      endTime: wasmModel.endTime,\n      saveFreq: wasmModel.saveFreq,\n      rowLength: wasmModel.numSavePoints,\n      ioBuffer\n    }\n    return Transfer(initResult, [ioBuffer])\n  },\n\n  runModel(ioBuffer: ArrayBuffer): TransferDescriptor<ArrayBuffer> {\n    if (!wasmModel) {\n      throw new Error('WasmModel must be initialized before running the model in worker')\n    }\n\n    // The run time is stored in the first 8 bytes\n    const runTimeLengthInElements = 1\n    const runTimeLengthInBytes = runTimeLengthInElements * 8\n\n    // Copy the inputs into the wasm inputs buffer\n    const inputsWasmArray = inputsWasmBuffer.getArrayView()\n    const inputsLengthInElements = inputsWasmArray.length\n    const inputsLengthInBytes = inputsLengthInElements * 8\n    const inputsBufferArray = new Float64Array(ioBuffer, runTimeLengthInBytes, inputsLengthInElements)\n    inputsWasmArray.set(inputsBufferArray)\n\n    // Run the model using the wasm buffers\n    const t0 = perfNow()\n    wasmModel.runModel(inputsWasmBuffer, outputsWasmBuffer)\n    const elapsed = perfElapsed(t0)\n\n    // Write the model run time to the buffer\n    const runTimeBufferArray = new Float64Array(ioBuffer, 0, runTimeLengthInElements)\n    runTimeBufferArray[0] = elapsed\n\n    // Copy the outputs from the wasm outputs buffer\n    const outputsOffsetInBytes = runTimeLengthInBytes + inputsLengthInBytes\n    const outputsBufferArray = new Float64Array(ioBuffer, outputsOffsetInBytes)\n    outputsBufferArray.set(outputsWasmBuffer.getArrayView())\n\n    // Transfer the buffer back to the runner\n    return Transfer(ioBuffer)\n  }\n}\n\n/**\n * Expose an object in the current worker thread that communicates with the\n * `ModelRunner` instance running in the main thread.  The exposed worker\n * object will take care of running the `WasmModel` on the worker thread\n * and sending the outputs back to the main process.\n *\n * @param init The function that initializes the `WasmModel` instance that\n * is used in the worker thread.\n */\nexport function exposeModelWorker(init: () => Promise<WasmModelInitResult>): void {\n  // Save the initializer, which will be used when the runner calls `initModel`\n  // on the worker\n  initWasmModel = init\n\n  // Expose the worker implementation to `threads.js`\n  expose(modelWorker)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,oBAAiC;AAGjC,qBAAqC;AAGrC,IAAI;AAEJ,IAAI;AAEJ,IAAI;AAEJ,IAAI;AAYJ,IAAM,cAAc;AAAA,EAClB,MAAM,YAAqD;AACzD,QAAI,WAAW;AACb,YAAM,IAAI,MAAM,mCAAmC;AAAA,IACrD;AAGA,UAAM,aAAa,MAAM,cAAc;AAGvC,gBAAY,WAAW;AACvB,uBAAmB,WAAW;AAC9B,wBAAoB,WAAW;AAK/B,UAAM,gBAAgB;AACtB,UAAM,eAAe,iBAAiB,aAAa,EAAE;AACrD,UAAM,gBAAgB,kBAAkB,aAAa,EAAE;AACvD,UAAM,UAAU,IAAI,aAAa,gBAAgB,eAAe,aAAa;AAG7E,UAAM,WAAW,QAAQ;AACzB,UAAM,aAAyB;AAAA,MAC7B,cAAc,WAAW;AAAA,MACzB,WAAW,UAAU;AAAA,MACrB,SAAS,UAAU;AAAA,MACnB,UAAU,UAAU;AAAA,MACpB,WAAW,UAAU;AAAA,MACrB;AAAA,IACF;AACA,eAAO,wBAAS,YAAY,CAAC,QAAQ,CAAC;AAAA,EACxC;AAAA,EAEA,SAAS,UAAwD;AAC/D,QAAI,CAAC,WAAW;AACd,YAAM,IAAI,MAAM,kEAAkE;AAAA,IACpF;AAGA,UAAM,0BAA0B;AAChC,UAAM,uBAAuB,0BAA0B;AAGvD,UAAM,kBAAkB,iBAAiB,aAAa;AACtD,UAAM,yBAAyB,gBAAgB;AAC/C,UAAM,sBAAsB,yBAAyB;AACrD,UAAM,oBAAoB,IAAI,aAAa,UAAU,sBAAsB,sBAAsB;AACjG,oBAAgB,IAAI,iBAAiB;AAGrC,UAAM,SAAK,wBAAQ;AACnB,cAAU,SAAS,kBAAkB,iBAAiB;AACtD,UAAM,cAAU,4BAAY,EAAE;AAG9B,UAAM,qBAAqB,IAAI,aAAa,UAAU,GAAG,uBAAuB;AAChF,uBAAmB,KAAK;AAGxB,UAAM,uBAAuB,uBAAuB;AACpD,UAAM,qBAAqB,IAAI,aAAa,UAAU,oBAAoB;AAC1E,uBAAmB,IAAI,kBAAkB,aAAa,CAAC;AAGvD,eAAO,wBAAS,QAAQ;AAAA,EAC1B;AACF;AAWO,SAAS,kBAAkB,MAAgD;AAGhF,kBAAgB;AAGhB,4BAAO,WAAW;AACpB;","names":[]}
+{"version":3,"sources":["../src/worker.ts"],"sourcesContent":["// Copyright (c) 2020-2022 Climate Interactive / New Venture Fund\n\nimport type { TransferDescriptor } from 'threads'\nimport { expose, Transfer } from 'threads/worker'\n\nimport type { GeneratedModel, RunnableModel } from '@sdeverywhere/runtime'\nimport { BufferedRunModelParams, createRunnableModel } from '@sdeverywhere/runtime'\n\n/** @hidden */\nlet initGeneratedModel: () => Promise<GeneratedModel>\n\n/** @hidden */\nlet runnableModel: RunnableModel\n\n/**\n * Maintain a `BufferedRunModelParams` instance that wraps the transferable buffer\n * containing the I/O parameters.\n * @hidden\n */\nconst params = new BufferedRunModelParams()\n\ninterface InitResult {\n  outputVarIds: string[]\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  modelListing?: /*ModelListingSpecs*/ any\n  startTime: number\n  endTime: number\n  saveFreq: number\n  outputRowLength: number\n}\n\n/** @hidden */\nconst modelWorker = {\n  async initModel(): Promise<InitResult> {\n    if (runnableModel) {\n      throw new Error('RunnableModel was already initialized')\n    }\n\n    // Initialize the runnable model\n    const generatedModel = await initGeneratedModel()\n    runnableModel = createRunnableModel(generatedModel)\n\n    // Transfer the model metadata to the runner\n    return {\n      outputVarIds: runnableModel.outputVarIds,\n      modelListing: runnableModel.modelListing,\n      startTime: runnableModel.startTime,\n      endTime: runnableModel.endTime,\n      saveFreq: runnableModel.saveFreq,\n      outputRowLength: runnableModel.numSavePoints\n    }\n  },\n\n  runModel(ioBuffer: ArrayBuffer): TransferDescriptor<ArrayBuffer> {\n    if (!runnableModel) {\n      throw new Error('RunnableModel must be initialized before running the model in worker')\n    }\n\n    // Update the `BufferedRunModelParams` to use the values in the buffer that was transferred\n    // from the runner to the worker\n    params.updateFromEncodedBuffer(ioBuffer)\n\n    // Run the model synchronously on the worker thread using those I/O parameters\n    runnableModel.runModel(params)\n\n    // Transfer the buffer back to the runner\n    return Transfer(ioBuffer)\n  }\n}\n\n/**\n * Expose an object in the current worker thread that communicates with the\n * `ModelRunner` instance running in the main thread.  The exposed worker\n * object will take care of running the model on the worker thread and\n * sending the outputs back to the main thread.\n *\n * @param init The function that initializes the generated model instance that\n * is used in the worker thread.\n */\nexport function exposeModelWorker(init: () => Promise<GeneratedModel>): void {\n  // Save the initializer, which will be used when the runner calls `initModel`\n  // on the worker\n  initGeneratedModel = init\n\n  // Expose the worker implementation to `threads.js`\n  expose(modelWorker)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,oBAAiC;AAGjC,qBAA4D;AAG5D,IAAI;AAGJ,IAAI;AAOJ,IAAM,SAAS,IAAI,sCAAuB;AAa1C,IAAM,cAAc;AAAA,EAClB,MAAM,YAAiC;AACrC,QAAI,eAAe;AACjB,YAAM,IAAI,MAAM,uCAAuC;AAAA,IACzD;AAGA,UAAM,iBAAiB,MAAM,mBAAmB;AAChD,wBAAgB,oCAAoB,cAAc;AAGlD,WAAO;AAAA,MACL,cAAc,cAAc;AAAA,MAC5B,cAAc,cAAc;AAAA,MAC5B,WAAW,cAAc;AAAA,MACzB,SAAS,cAAc;AAAA,MACvB,UAAU,cAAc;AAAA,MACxB,iBAAiB,cAAc;AAAA,IACjC;AAAA,EACF;AAAA,EAEA,SAAS,UAAwD;AAC/D,QAAI,CAAC,eAAe;AAClB,YAAM,IAAI,MAAM,sEAAsE;AAAA,IACxF;AAIA,WAAO,wBAAwB,QAAQ;AAGvC,kBAAc,SAAS,MAAM;AAG7B,eAAO,wBAAS,QAAQ;AAAA,EAC1B;AACF;AAWO,SAAS,kBAAkB,MAA2C;AAG3E,uBAAqB;AAGrB,4BAAO,WAAW;AACpB;","names":[]}

package/dist/worker.d.cts

@@ -0,0 +1,14 @@
+import { GeneratedModel } from '@sdeverywhere/runtime';
+
+/**
+ * Expose an object in the current worker thread that communicates with the
+ * `ModelRunner` instance running in the main thread.  The exposed worker
+ * object will take care of running the model on the worker thread and
+ * sending the outputs back to the main thread.
+ *
+ * @param init The function that initializes the generated model instance that
+ * is used in the worker thread.
+ */
+declare function exposeModelWorker(init: () => Promise<GeneratedModel>): void;
+
+export { exposeModelWorker };

package/dist/worker.d.ts

@@ -1,14 +1,14 @@
-import { WasmModelInitResult } from '@sdeverywhere/runtime';
+import { GeneratedModel } from '@sdeverywhere/runtime';
 
 /**
  * Expose an object in the current worker thread that communicates with the
  * `ModelRunner` instance running in the main thread.  The exposed worker
- * object will take care of running the `WasmModel` on the worker thread
- * and sending the outputs back to the main process.
+ * object will take care of running the model on the worker thread and
+ * sending the outputs back to the main thread.
  *
- * @param init The function that initializes the `WasmModel` instance that
+ * @param init The function that initializes the generated model instance that
  * is used in the worker thread.
  */
-declare function exposeModelWorker(init: () => Promise<WasmModelInitResult>): void;
+declare function exposeModelWorker(init: () => Promise<GeneratedModel>): void;
 
 export { exposeModelWorker };

package/dist/worker.js

@@ -1,58 +1,36 @@
 // src/worker.ts
 import { expose, Transfer } from "threads/worker";
-import { perfElapsed, perfNow } from "@sdeverywhere/runtime";
-var initWasmModel;
-var wasmModel;
-var inputsWasmBuffer;
-var outputsWasmBuffer;
+import { BufferedRunModelParams, createRunnableModel } from "@sdeverywhere/runtime";
+var initGeneratedModel;
+var runnableModel;
+var params = new BufferedRunModelParams();
 var modelWorker = {
   async initModel() {
-    if (wasmModel) {
-      throw new Error("WasmModel was already initialized");
+    if (runnableModel) {
+      throw new Error("RunnableModel was already initialized");
     }
-    const wasmResult = await initWasmModel();
-    wasmModel = wasmResult.model;
-    inputsWasmBuffer = wasmResult.inputsBuffer;
-    outputsWasmBuffer = wasmResult.outputsBuffer;
-    const runTimeLength = 8;
-    const inputsLength = inputsWasmBuffer.getArrayView().length;
-    const outputsLength = outputsWasmBuffer.getArrayView().length;
-    const ioArray = new Float64Array(runTimeLength + inputsLength + outputsLength);
-    const ioBuffer = ioArray.buffer;
-    const initResult = {
-      outputVarIds: wasmResult.outputVarIds,
-      startTime: wasmModel.startTime,
-      endTime: wasmModel.endTime,
-      saveFreq: wasmModel.saveFreq,
-      rowLength: wasmModel.numSavePoints,
-      ioBuffer
+    const generatedModel = await initGeneratedModel();
+    runnableModel = createRunnableModel(generatedModel);
+    return {
+      outputVarIds: runnableModel.outputVarIds,
+      modelListing: runnableModel.modelListing,
+      startTime: runnableModel.startTime,
+      endTime: runnableModel.endTime,
+      saveFreq: runnableModel.saveFreq,
+      outputRowLength: runnableModel.numSavePoints
     };
-    return Transfer(initResult, [ioBuffer]);
   },
   runModel(ioBuffer) {
-    if (!wasmModel) {
-      throw new Error("WasmModel must be initialized before running the model in worker");
+    if (!runnableModel) {
+      throw new Error("RunnableModel must be initialized before running the model in worker");
     }
-    const runTimeLengthInElements = 1;
-    const runTimeLengthInBytes = runTimeLengthInElements * 8;
-    const inputsWasmArray = inputsWasmBuffer.getArrayView();
-    const inputsLengthInElements = inputsWasmArray.length;
-    const inputsLengthInBytes = inputsLengthInElements * 8;
-    const inputsBufferArray = new Float64Array(ioBuffer, runTimeLengthInBytes, inputsLengthInElements);
-    inputsWasmArray.set(inputsBufferArray);
-    const t0 = perfNow();
-    wasmModel.runModel(inputsWasmBuffer, outputsWasmBuffer);
-    const elapsed = perfElapsed(t0);
-    const runTimeBufferArray = new Float64Array(ioBuffer, 0, runTimeLengthInElements);
-    runTimeBufferArray[0] = elapsed;
-    const outputsOffsetInBytes = runTimeLengthInBytes + inputsLengthInBytes;
-    const outputsBufferArray = new Float64Array(ioBuffer, outputsOffsetInBytes);
-    outputsBufferArray.set(outputsWasmBuffer.getArrayView());
+    params.updateFromEncodedBuffer(ioBuffer);
+    runnableModel.runModel(params);
     return Transfer(ioBuffer);
   }
 };
 function exposeModelWorker(init) {
-  initWasmModel = init;
+  initGeneratedModel = init;
   expose(modelWorker);
 }
 export {

package/dist/worker.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/worker.ts"],"sourcesContent":["// Copyright (c) 2020-2022 Climate Interactive / New Venture Fund\n\nimport type { TransferDescriptor } from 'threads'\nimport { expose, Transfer } from 'threads/worker'\n\nimport type { WasmBuffer, WasmModel, WasmModelInitResult } from '@sdeverywhere/runtime'\nimport { perfElapsed, perfNow } from '@sdeverywhere/runtime'\n\n/** @hidden */\nlet initWasmModel: () => Promise<WasmModelInitResult>\n/** @hidden */\nlet wasmModel: WasmModel\n/** @hidden */\nlet inputsWasmBuffer: WasmBuffer\n/** @hidden */\nlet outputsWasmBuffer: WasmBuffer\n\ninterface InitResult {\n  outputVarIds: string[]\n  startTime: number\n  endTime: number\n  saveFreq: number\n  rowLength: number\n  ioBuffer: ArrayBuffer\n}\n\n/** @hidden */\nconst modelWorker = {\n  async initModel(): Promise<TransferDescriptor<InitResult>> {\n    if (wasmModel) {\n      throw new Error('WasmModel was already initialized')\n    }\n\n    // Initialize the wasm model and associated buffers\n    const wasmResult = await initWasmModel()\n\n    // Capture the `WasmModel` instance and `WasmBuffer` instances\n    wasmModel = wasmResult.model\n    inputsWasmBuffer = wasmResult.inputsBuffer\n    outputsWasmBuffer = wasmResult.outputsBuffer\n\n    // Create a combined array that will hold a copy of the inputs and outputs\n    // wasm buffers; this buffer is no-copy transferable, whereas the wasm ones\n    // are not allowed to be transferred\n    const runTimeLength = 8\n    const inputsLength = inputsWasmBuffer.getArrayView().length\n    const outputsLength = outputsWasmBuffer.getArrayView().length\n    const ioArray = new Float64Array(runTimeLength + inputsLength + outputsLength)\n\n    // Transfer the underlying buffer to the runner\n    const ioBuffer = ioArray.buffer\n    const initResult: InitResult = {\n      outputVarIds: wasmResult.outputVarIds,\n      startTime: wasmModel.startTime,\n      endTime: wasmModel.endTime,\n      saveFreq: wasmModel.saveFreq,\n      rowLength: wasmModel.numSavePoints,\n      ioBuffer\n    }\n    return Transfer(initResult, [ioBuffer])\n  },\n\n  runModel(ioBuffer: ArrayBuffer): TransferDescriptor<ArrayBuffer> {\n    if (!wasmModel) {\n      throw new Error('WasmModel must be initialized before running the model in worker')\n    }\n\n    // The run time is stored in the first 8 bytes\n    const runTimeLengthInElements = 1\n    const runTimeLengthInBytes = runTimeLengthInElements * 8\n\n    // Copy the inputs into the wasm inputs buffer\n    const inputsWasmArray = inputsWasmBuffer.getArrayView()\n    const inputsLengthInElements = inputsWasmArray.length\n    const inputsLengthInBytes = inputsLengthInElements * 8\n    const inputsBufferArray = new Float64Array(ioBuffer, runTimeLengthInBytes, inputsLengthInElements)\n    inputsWasmArray.set(inputsBufferArray)\n\n    // Run the model using the wasm buffers\n    const t0 = perfNow()\n    wasmModel.runModel(inputsWasmBuffer, outputsWasmBuffer)\n    const elapsed = perfElapsed(t0)\n\n    // Write the model run time to the buffer\n    const runTimeBufferArray = new Float64Array(ioBuffer, 0, runTimeLengthInElements)\n    runTimeBufferArray[0] = elapsed\n\n    // Copy the outputs from the wasm outputs buffer\n    const outputsOffsetInBytes = runTimeLengthInBytes + inputsLengthInBytes\n    const outputsBufferArray = new Float64Array(ioBuffer, outputsOffsetInBytes)\n    outputsBufferArray.set(outputsWasmBuffer.getArrayView())\n\n    // Transfer the buffer back to the runner\n    return Transfer(ioBuffer)\n  }\n}\n\n/**\n * Expose an object in the current worker thread that communicates with the\n * `ModelRunner` instance running in the main thread.  The exposed worker\n * object will take care of running the `WasmModel` on the worker thread\n * and sending the outputs back to the main process.\n *\n * @param init The function that initializes the `WasmModel` instance that\n * is used in the worker thread.\n */\nexport function exposeModelWorker(init: () => Promise<WasmModelInitResult>): void {\n  // Save the initializer, which will be used when the runner calls `initModel`\n  // on the worker\n  initWasmModel = init\n\n  // Expose the worker implementation to `threads.js`\n  expose(modelWorker)\n}\n"],"mappings":";AAGA,SAAS,QAAQ,gBAAgB;AAGjC,SAAS,aAAa,eAAe;AAGrC,IAAI;AAEJ,IAAI;AAEJ,IAAI;AAEJ,IAAI;AAYJ,IAAM,cAAc;AAAA,EAClB,MAAM,YAAqD;AACzD,QAAI,WAAW;AACb,YAAM,IAAI,MAAM,mCAAmC;AAAA,IACrD;AAGA,UAAM,aAAa,MAAM,cAAc;AAGvC,gBAAY,WAAW;AACvB,uBAAmB,WAAW;AAC9B,wBAAoB,WAAW;AAK/B,UAAM,gBAAgB;AACtB,UAAM,eAAe,iBAAiB,aAAa,EAAE;AACrD,UAAM,gBAAgB,kBAAkB,aAAa,EAAE;AACvD,UAAM,UAAU,IAAI,aAAa,gBAAgB,eAAe,aAAa;AAG7E,UAAM,WAAW,QAAQ;AACzB,UAAM,aAAyB;AAAA,MAC7B,cAAc,WAAW;AAAA,MACzB,WAAW,UAAU;AAAA,MACrB,SAAS,UAAU;AAAA,MACnB,UAAU,UAAU;AAAA,MACpB,WAAW,UAAU;AAAA,MACrB;AAAA,IACF;AACA,WAAO,SAAS,YAAY,CAAC,QAAQ,CAAC;AAAA,EACxC;AAAA,EAEA,SAAS,UAAwD;AAC/D,QAAI,CAAC,WAAW;AACd,YAAM,IAAI,MAAM,kEAAkE;AAAA,IACpF;AAGA,UAAM,0BAA0B;AAChC,UAAM,uBAAuB,0BAA0B;AAGvD,UAAM,kBAAkB,iBAAiB,aAAa;AACtD,UAAM,yBAAyB,gBAAgB;AAC/C,UAAM,sBAAsB,yBAAyB;AACrD,UAAM,oBAAoB,IAAI,aAAa,UAAU,sBAAsB,sBAAsB;AACjG,oBAAgB,IAAI,iBAAiB;AAGrC,UAAM,KAAK,QAAQ;AACnB,cAAU,SAAS,kBAAkB,iBAAiB;AACtD,UAAM,UAAU,YAAY,EAAE;AAG9B,UAAM,qBAAqB,IAAI,aAAa,UAAU,GAAG,uBAAuB;AAChF,uBAAmB,KAAK;AAGxB,UAAM,uBAAuB,uBAAuB;AACpD,UAAM,qBAAqB,IAAI,aAAa,UAAU,oBAAoB;AAC1E,uBAAmB,IAAI,kBAAkB,aAAa,CAAC;AAGvD,WAAO,SAAS,QAAQ;AAAA,EAC1B;AACF;AAWO,SAAS,kBAAkB,MAAgD;AAGhF,kBAAgB;AAGhB,SAAO,WAAW;AACpB;","names":[]}
+{"version":3,"sources":["../src/worker.ts"],"sourcesContent":["// Copyright (c) 2020-2022 Climate Interactive / New Venture Fund\n\nimport type { TransferDescriptor } from 'threads'\nimport { expose, Transfer } from 'threads/worker'\n\nimport type { GeneratedModel, RunnableModel } from '@sdeverywhere/runtime'\nimport { BufferedRunModelParams, createRunnableModel } from '@sdeverywhere/runtime'\n\n/** @hidden */\nlet initGeneratedModel: () => Promise<GeneratedModel>\n\n/** @hidden */\nlet runnableModel: RunnableModel\n\n/**\n * Maintain a `BufferedRunModelParams` instance that wraps the transferable buffer\n * containing the I/O parameters.\n * @hidden\n */\nconst params = new BufferedRunModelParams()\n\ninterface InitResult {\n  outputVarIds: string[]\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  modelListing?: /*ModelListingSpecs*/ any\n  startTime: number\n  endTime: number\n  saveFreq: number\n  outputRowLength: number\n}\n\n/** @hidden */\nconst modelWorker = {\n  async initModel(): Promise<InitResult> {\n    if (runnableModel) {\n      throw new Error('RunnableModel was already initialized')\n    }\n\n    // Initialize the runnable model\n    const generatedModel = await initGeneratedModel()\n    runnableModel = createRunnableModel(generatedModel)\n\n    // Transfer the model metadata to the runner\n    return {\n      outputVarIds: runnableModel.outputVarIds,\n      modelListing: runnableModel.modelListing,\n      startTime: runnableModel.startTime,\n      endTime: runnableModel.endTime,\n      saveFreq: runnableModel.saveFreq,\n      outputRowLength: runnableModel.numSavePoints\n    }\n  },\n\n  runModel(ioBuffer: ArrayBuffer): TransferDescriptor<ArrayBuffer> {\n    if (!runnableModel) {\n      throw new Error('RunnableModel must be initialized before running the model in worker')\n    }\n\n    // Update the `BufferedRunModelParams` to use the values in the buffer that was transferred\n    // from the runner to the worker\n    params.updateFromEncodedBuffer(ioBuffer)\n\n    // Run the model synchronously on the worker thread using those I/O parameters\n    runnableModel.runModel(params)\n\n    // Transfer the buffer back to the runner\n    return Transfer(ioBuffer)\n  }\n}\n\n/**\n * Expose an object in the current worker thread that communicates with the\n * `ModelRunner` instance running in the main thread.  The exposed worker\n * object will take care of running the model on the worker thread and\n * sending the outputs back to the main thread.\n *\n * @param init The function that initializes the generated model instance that\n * is used in the worker thread.\n */\nexport function exposeModelWorker(init: () => Promise<GeneratedModel>): void {\n  // Save the initializer, which will be used when the runner calls `initModel`\n  // on the worker\n  initGeneratedModel = init\n\n  // Expose the worker implementation to `threads.js`\n  expose(modelWorker)\n}\n"],"mappings":";AAGA,SAAS,QAAQ,gBAAgB;AAGjC,SAAS,wBAAwB,2BAA2B;AAG5D,IAAI;AAGJ,IAAI;AAOJ,IAAM,SAAS,IAAI,uBAAuB;AAa1C,IAAM,cAAc;AAAA,EAClB,MAAM,YAAiC;AACrC,QAAI,eAAe;AACjB,YAAM,IAAI,MAAM,uCAAuC;AAAA,IACzD;AAGA,UAAM,iBAAiB,MAAM,mBAAmB;AAChD,oBAAgB,oBAAoB,cAAc;AAGlD,WAAO;AAAA,MACL,cAAc,cAAc;AAAA,MAC5B,cAAc,cAAc;AAAA,MAC5B,WAAW,cAAc;AAAA,MACzB,SAAS,cAAc;AAAA,MACvB,UAAU,cAAc;AAAA,MACxB,iBAAiB,cAAc;AAAA,IACjC;AAAA,EACF;AAAA,EAEA,SAAS,UAAwD;AAC/D,QAAI,CAAC,eAAe;AAClB,YAAM,IAAI,MAAM,sEAAsE;AAAA,IACxF;AAIA,WAAO,wBAAwB,QAAQ;AAGvC,kBAAc,SAAS,MAAM;AAG7B,WAAO,SAAS,QAAQ;AAAA,EAC1B;AACF;AAWO,SAAS,kBAAkB,MAA2C;AAG3E,uBAAqB;AAGrB,SAAO,WAAW;AACpB;","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sdeverywhere/runtime-async",
-  "version": "0.2.0",
+  "version": "0.2.3",
   "files": [
     "dist/**"
   ],
@@ -26,7 +26,7 @@
     }
   },
   "dependencies": {
-    "@sdeverywhere/runtime": "^0.2.0",
+    "@sdeverywhere/runtime": "^0.2.3",
     "threads": "1.7.0"
   },
   "author": "Climate Interactive",
@@ -49,7 +49,7 @@
     "test": "vitest run",
     "test:watch": "vitest",
     "test:ci": "vitest run",
-    "type-check": "tsc --noEmit -p tsconfig-build.json",
+    "type-check": "tsc --noEmit -p tsconfig-test.json",
     "build": "tsup",
     "docs": "../../scripts/gen-docs.js",
     "ci:build": "run-s clean lint prettier:check type-check build test:ci docs"