@sdeverywhere/runtime-async 0.1.0 → 0.2.2

package/README.md

@@ -1,12 +1,32 @@
 # @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
 
+_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 the `WasmModel` in a Web Worker
 
 In your app project, define a separate JavaScript file, called

package/dist/index.cjs

@@ -26,6 +26,7 @@ module.exports = __toCommonJS(src_exports);
 
 // src/runner.ts
 var import_threads = require("threads");
+var import_runtime = require("@sdeverywhere/runtime");
 async function spawnAsyncModelRunner(workerSpec) {
   if (workerSpec["path"]) {
     return spawnAsyncModelRunnerWithWorker(new import_threads.Worker(workerSpec["path"]));
@@ -36,11 +37,25 @@ async function spawnAsyncModelRunner(workerSpec) {
 async function spawnAsyncModelRunnerWithWorker(worker) {
   const modelWorker2 = await (0, import_threads.spawn)(worker);
   const initResult = await modelWorker2.initModel();
-  const rowLength = initResult.rowLength;
   let ioBuffer = initResult.ioBuffer;
+  const runTimeOffsetInBytes = 0;
+  const runTimeLengthInElements = 1;
+  const runTimeLengthInBytes = runTimeLengthInElements * 8;
+  const inputsOffsetInBytes = runTimeOffsetInBytes + runTimeLengthInBytes;
+  const inputsLengthInElements = initResult.inputsLength;
+  const inputsLengthInBytes = inputsLengthInElements * 8;
+  const outputsOffsetInBytes = inputsOffsetInBytes + inputsLengthInBytes;
+  const outputsLengthInElements = initResult.outputsLength;
+  const outputsLengthInBytes = outputsLengthInElements * 8;
+  const indicesOffsetInBytes = outputsOffsetInBytes + outputsLengthInBytes;
+  const indicesLengthInElements = initResult.outputIndicesLength;
+  const outputRowLength = initResult.outputRowLength;
   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) => {
       if (terminated) {
         throw new Error("Async model runner has already been terminated");
@@ -49,24 +64,24 @@ 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);
+      const inputsArray = new Float64Array(ioBuffer, inputsOffsetInBytes, inputsLengthInElements);
       for (let i = 0; i < inputs.length; i++) {
         inputsArray[i] = inputs[i].get();
       }
+      if (indicesLengthInElements > 0) {
+        const outputSpecs = outputs.varSpecs || [];
+        const indicesArray = new Int32Array(ioBuffer, indicesOffsetInBytes, indicesLengthInElements);
+        (0, import_runtime.updateOutputIndices)(indicesArray, outputSpecs);
+      }
       try {
         ioBuffer = await modelWorker2.runModel((0, import_threads.Transfer)(ioBuffer));
       } 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);
+      const runTimeArray = new Float64Array(ioBuffer, runTimeOffsetInBytes, runTimeLengthInElements);
+      outputs.runTimeInMillis = runTimeArray[0];
+      const outputsArray = new Float64Array(ioBuffer, outputsOffsetInBytes, outputsLengthInElements);
+      outputs.updateFromBuffer(outputsArray, outputRowLength);
       return outputs;
     },
     terminate: () => {
@@ -82,47 +97,77 @@ async function spawnAsyncModelRunnerWithWorker(worker) {
 
 // src/worker.ts
 var import_worker = require("threads/worker");
-var import_runtime = require("@sdeverywhere/runtime");
+var import_runtime2 = require("@sdeverywhere/runtime");
 var initWasmModel;
 var wasmModel;
 var inputsWasmBuffer;
 var outputsWasmBuffer;
+var outputIndicesWasmBuffer;
 var modelWorker = {
   async initModel() {
     if (wasmModel) {
       throw new Error("WasmModel was already initialized");
     }
-    const result = await initWasmModel();
-    wasmModel = result.model;
-    inputsWasmBuffer = result.inputsBuffer;
-    outputsWasmBuffer = result.outputsBuffer;
+    const wasmResult = await initWasmModel();
+    wasmModel = wasmResult.model;
+    inputsWasmBuffer = wasmResult.inputsBuffer;
+    outputsWasmBuffer = wasmResult.outputsBuffer;
+    outputIndicesWasmBuffer = wasmResult.outputIndicesBuffer;
     const runTimeLength = 8;
     const inputsLength = inputsWasmBuffer.getArrayView().length;
     const outputsLength = outputsWasmBuffer.getArrayView().length;
-    const ioArray = new Float64Array(runTimeLength + inputsLength + outputsLength);
-    const rowLength = result.endTime - result.startTime + 1;
+    const outputIndicesLength = (outputIndicesWasmBuffer == null ? void 0 : outputIndicesWasmBuffer.getArrayView().length) || 0;
+    const totalLength = runTimeLength + inputsLength + outputsLength + outputIndicesLength;
+    const ioArray = new Float64Array(totalLength);
     const ioBuffer = ioArray.buffer;
-    return (0, import_worker.Transfer)({ rowLength, ioBuffer }, [ioBuffer]);
+    const initResult = {
+      outputVarIds: wasmResult.outputVarIds,
+      startTime: wasmModel.startTime,
+      endTime: wasmModel.endTime,
+      saveFreq: wasmModel.saveFreq,
+      inputsLength,
+      outputsLength,
+      outputIndicesLength,
+      outputRowLength: wasmModel.numSavePoints,
+      ioBuffer
+    };
+    return (0, import_worker.Transfer)(initResult, [ioBuffer]);
   },
   runModel(ioBuffer) {
     if (!wasmModel) {
       throw new Error("WasmModel must be initialized before running the model in worker");
     }
+    const runTimeOffsetInBytes = 0;
     const runTimeLengthInElements = 1;
     const runTimeLengthInBytes = runTimeLengthInElements * 8;
     const inputsWasmArray = inputsWasmBuffer.getArrayView();
+    const inputsOffsetInBytes = runTimeOffsetInBytes + runTimeLengthInBytes;
     const inputsLengthInElements = inputsWasmArray.length;
-    const inputsLengthInBytes = inputsLengthInElements * 8;
-    const inputsBufferArray = new Float64Array(ioBuffer, runTimeLengthInBytes, inputsLengthInElements);
+    const inputsLengthInBytes = inputsWasmArray.byteLength;
+    const inputsBufferArray = new Float64Array(ioBuffer, inputsOffsetInBytes, 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 outputsWasmArray = outputsWasmBuffer.getArrayView();
     const outputsOffsetInBytes = runTimeLengthInBytes + inputsLengthInBytes;
-    const outputsBufferArray = new Float64Array(ioBuffer, outputsOffsetInBytes);
-    outputsBufferArray.set(outputsWasmBuffer.getArrayView());
+    const outputsLengthInBytes = outputsWasmArray.byteLength;
+    let useIndices = false;
+    if (outputIndicesWasmBuffer) {
+      const indicesWasmArray = outputIndicesWasmBuffer.getArrayView();
+      const indicesLengthInElements = indicesWasmArray.length;
+      const indicesOffsetInBytes = outputsOffsetInBytes + outputsLengthInBytes;
+      const indicesBufferArray = new Int32Array(ioBuffer, indicesOffsetInBytes, indicesLengthInElements);
+      if (indicesBufferArray[0] !== 0) {
+        indicesWasmArray.set(indicesBufferArray);
+        useIndices = true;
+      }
+    }
+    const t0 = (0, import_runtime2.perfNow)();
+    wasmModel.runModel(inputsWasmBuffer, outputsWasmBuffer, useIndices ? outputIndicesWasmBuffer : void 0);
+    const elapsed = (0, import_runtime2.perfElapsed)(t0);
+    const runTimeBufferArray = new Float64Array(ioBuffer, runTimeOffsetInBytes, runTimeLengthInElements);
+    runTimeBufferArray[0] = elapsed;
+    const outputsLengthInElements = outputsWasmArray.length;
+    const outputsBufferArray = new Float64Array(ioBuffer, outputsOffsetInBytes, outputsLengthInElements);
+    outputsBufferArray.set(outputsWasmArray);
     return (0, import_worker.Transfer)(ioBuffer);
   }
 };

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'\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  const rowLength: number = initResult.rowLength\n  let ioBuffer: ArrayBuffer = initResult.ioBuffer\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    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  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 result = await initWasmModel()\n\n    // Capture the `WasmModel` instance and `WasmBuffer` instances\n    wasmModel = result.model\n    inputsWasmBuffer = result.inputsBuffer\n    outputsWasmBuffer = result.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    // The row length is the number of elements in each row of the outputs buffer\n    const rowLength = result.endTime - result.startTime + 1\n\n    // Transfer the underlying buffer to the runner\n    const ioBuffer = ioArray.buffer\n    return Transfer({ rowLength, ioBuffer }, [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":[]}
+{"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, updateOutputIndices } 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 run time is stored in the first 8 bytes of the shared buffer\n  const runTimeOffsetInBytes = 0\n  const runTimeLengthInElements = 1\n  const runTimeLengthInBytes = runTimeLengthInElements * 8\n\n  // The inputs are stored after the run time in the shared buffer\n  const inputsOffsetInBytes = runTimeOffsetInBytes + runTimeLengthInBytes\n  const inputsLengthInElements: number = initResult.inputsLength\n  const inputsLengthInBytes = inputsLengthInElements * 8\n\n  // The outputs are stored after the inputs in the shared buffer\n  const outputsOffsetInBytes = inputsOffsetInBytes + inputsLengthInBytes\n  const outputsLengthInElements: number = initResult.outputsLength\n  const outputsLengthInBytes = outputsLengthInElements * 8\n\n  // The output indices are (optionally) stored after the outputs in the shared buffer\n  const indicesOffsetInBytes = outputsOffsetInBytes + outputsLengthInBytes\n  const indicesLengthInElements: number = initResult.outputIndicesLength\n\n  // The row length is the number of elements in each row of the outputs buffer\n  const outputRowLength: number = initResult.outputRowLength\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      // Capture the current set of input values into the reusable buffer\n      const inputsArray = new Float64Array(ioBuffer, inputsOffsetInBytes, inputsLengthInElements)\n      for (let i = 0; i < inputs.length; i++) {\n        inputsArray[i] = inputs[i].get()\n      }\n\n      // Update the output indices, if needed\n      if (indicesLengthInElements > 0) {\n        const outputSpecs = outputs.varSpecs || []\n        const indicesArray = new Int32Array(ioBuffer, indicesOffsetInBytes, indicesLengthInElements)\n        updateOutputIndices(indicesArray, outputSpecs)\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 runTimeArray = new Float64Array(ioBuffer, runTimeOffsetInBytes, runTimeLengthInElements)\n      outputs.runTimeInMillis = runTimeArray[0]\n\n      // Capture the outputs array by copying the data into the given `Outputs`\n      // data structure\n      const outputsArray = new Float64Array(ioBuffer, outputsOffsetInBytes, outputsLengthInElements)\n      outputs.updateFromBuffer(outputsArray, outputRowLength)\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<Float64Array>\n/** @hidden */\nlet outputsWasmBuffer: WasmBuffer<Float64Array>\n/** @hidden */\nlet outputIndicesWasmBuffer: WasmBuffer<Int32Array>\n\ninterface InitResult {\n  outputVarIds: string[]\n  startTime: number\n  endTime: number\n  saveFreq: number\n  inputsLength: number\n  outputsLength: number\n  outputIndicesLength: number\n  outputRowLength: 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    outputIndicesWasmBuffer = wasmResult.outputIndicesBuffer\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 outputIndicesLength = outputIndicesWasmBuffer?.getArrayView().length || 0\n    const totalLength = runTimeLength + inputsLength + outputsLength + outputIndicesLength\n    const ioArray = new Float64Array(totalLength)\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      inputsLength,\n      outputsLength,\n      outputIndicesLength,\n      outputRowLength: 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 runTimeOffsetInBytes = 0\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 inputsOffsetInBytes = runTimeOffsetInBytes + runTimeLengthInBytes\n    const inputsLengthInElements = inputsWasmArray.length\n    const inputsLengthInBytes = inputsWasmArray.byteLength\n    const inputsBufferArray = new Float64Array(ioBuffer, inputsOffsetInBytes, inputsLengthInElements)\n    inputsWasmArray.set(inputsBufferArray)\n\n    // Copy the output indices into the wasm buffer, if needed\n    const outputsWasmArray = outputsWasmBuffer.getArrayView()\n    const outputsOffsetInBytes = runTimeLengthInBytes + inputsLengthInBytes\n    const outputsLengthInBytes = outputsWasmArray.byteLength\n    let useIndices = false\n    if (outputIndicesWasmBuffer) {\n      const indicesWasmArray = outputIndicesWasmBuffer.getArrayView()\n      const indicesLengthInElements = indicesWasmArray.length\n      const indicesOffsetInBytes = outputsOffsetInBytes + outputsLengthInBytes\n      const indicesBufferArray = new Int32Array(ioBuffer, indicesOffsetInBytes, indicesLengthInElements)\n      if (indicesBufferArray[0] !== 0) {\n        // Only use the indices if the first index is non-zero\n        indicesWasmArray.set(indicesBufferArray)\n        useIndices = true\n      }\n    }\n\n    // Run the model using the wasm buffers\n    const t0 = perfNow()\n    wasmModel.runModel(inputsWasmBuffer, outputsWasmBuffer, useIndices ? outputIndicesWasmBuffer : undefined)\n    const elapsed = perfElapsed(t0)\n\n    // Write the model run time to the buffer\n    const runTimeBufferArray = new Float64Array(ioBuffer, runTimeOffsetInBytes, runTimeLengthInElements)\n    runTimeBufferArray[0] = elapsed\n\n    // Copy the outputs from the wasm outputs buffer\n    const outputsLengthInElements = outputsWasmArray.length\n    const outputsBufferArray = new Float64Array(ioBuffer, outputsOffsetInBytes, outputsLengthInElements)\n    outputsBufferArray.set(outputsWasmArray)\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;AAAA;;;ACEA,qBAA4D;AAG5D,qBAA6C;AAqC7C,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;AAC/C,MAAI,WAAwB,WAAW;AAGvC,QAAM,uBAAuB;AAC7B,QAAM,0BAA0B;AAChC,QAAM,uBAAuB,0BAA0B;AAGvD,QAAM,sBAAsB,uBAAuB;AACnD,QAAM,yBAAiC,WAAW;AAClD,QAAM,sBAAsB,yBAAyB;AAGrD,QAAM,uBAAuB,sBAAsB;AACnD,QAAM,0BAAkC,WAAW;AACnD,QAAM,uBAAuB,0BAA0B;AAGvD,QAAM,uBAAuB,uBAAuB;AACpD,QAAM,0BAAkC,WAAW;AAGnD,QAAM,kBAA0B,WAAW;AAG3C,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,cAAc,IAAI,aAAa,UAAU,qBAAqB,sBAAsB;AAC1F,eAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;AACtC,oBAAY,CAAC,IAAI,OAAO,CAAC,EAAE,IAAI;AAAA,MACjC;AAGA,UAAI,0BAA0B,GAAG;AAC/B,cAAM,cAAc,QAAQ,YAAY,CAAC;AACzC,cAAM,eAAe,IAAI,WAAW,UAAU,sBAAsB,uBAAuB;AAC3F,gDAAoB,cAAc,WAAW;AAAA,MAC/C;AAMA,UAAI;AACF,mBAAW,MAAMA,aAAY,aAAS,yBAAS,QAAQ,CAAC;AAAA,MAC1D,UAAE;AACA,kBAAU;AAAA,MACZ;AAGA,YAAM,eAAe,IAAI,aAAa,UAAU,sBAAsB,uBAAuB;AAC7F,cAAQ,kBAAkB,aAAa,CAAC;AAIxC,YAAM,eAAe,IAAI,aAAa,UAAU,sBAAsB,uBAAuB;AAC7F,cAAQ,iBAAiB,cAAc,eAAe;AAEtD,aAAO;AAAA,IACT;AAAA,IAEA,WAAW,MAAM;AACf,UAAI,YAAY;AACd,eAAO,QAAQ,QAAQ;AAAA,MACzB,OAAO;AACL,qBAAa;AACb,eAAO,sBAAO,UAAUA,YAAW;AAAA,MACrC;AAAA,IACF;AAAA,EACF;AACF;;;AChJA,oBAAiC;AAGjC,IAAAC,kBAAqC;AAGrC,IAAI;AAEJ,IAAI;AAEJ,IAAI;AAEJ,IAAI;AAEJ,IAAI;AAeJ,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;AAC/B,8BAA0B,WAAW;AAKrC,UAAM,gBAAgB;AACtB,UAAM,eAAe,iBAAiB,aAAa,EAAE;AACrD,UAAM,gBAAgB,kBAAkB,aAAa,EAAE;AACvD,UAAM,uBAAsB,mEAAyB,eAAe,WAAU;AAC9E,UAAM,cAAc,gBAAgB,eAAe,gBAAgB;AACnE,UAAM,UAAU,IAAI,aAAa,WAAW;AAG5C,UAAM,WAAW,QAAQ;AACzB,UAAM,aAAyB;AAAA,MAC7B,cAAc,WAAW;AAAA,MACzB,WAAW,UAAU;AAAA,MACrB,SAAS,UAAU;AAAA,MACnB,UAAU,UAAU;AAAA,MACpB;AAAA,MACA;AAAA,MACA;AAAA,MACA,iBAAiB,UAAU;AAAA,MAC3B;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,uBAAuB;AAC7B,UAAM,0BAA0B;AAChC,UAAM,uBAAuB,0BAA0B;AAGvD,UAAM,kBAAkB,iBAAiB,aAAa;AACtD,UAAM,sBAAsB,uBAAuB;AACnD,UAAM,yBAAyB,gBAAgB;AAC/C,UAAM,sBAAsB,gBAAgB;AAC5C,UAAM,oBAAoB,IAAI,aAAa,UAAU,qBAAqB,sBAAsB;AAChG,oBAAgB,IAAI,iBAAiB;AAGrC,UAAM,mBAAmB,kBAAkB,aAAa;AACxD,UAAM,uBAAuB,uBAAuB;AACpD,UAAM,uBAAuB,iBAAiB;AAC9C,QAAI,aAAa;AACjB,QAAI,yBAAyB;AAC3B,YAAM,mBAAmB,wBAAwB,aAAa;AAC9D,YAAM,0BAA0B,iBAAiB;AACjD,YAAM,uBAAuB,uBAAuB;AACpD,YAAM,qBAAqB,IAAI,WAAW,UAAU,sBAAsB,uBAAuB;AACjG,UAAI,mBAAmB,CAAC,MAAM,GAAG;AAE/B,yBAAiB,IAAI,kBAAkB;AACvC,qBAAa;AAAA,MACf;AAAA,IACF;AAGA,UAAM,SAAK,yBAAQ;AACnB,cAAU,SAAS,kBAAkB,mBAAmB,aAAa,0BAA0B,MAAS;AACxG,UAAM,cAAU,6BAAY,EAAE;AAG9B,UAAM,qBAAqB,IAAI,aAAa,UAAU,sBAAsB,uBAAuB;AACnG,uBAAmB,CAAC,IAAI;AAGxB,UAAM,0BAA0B,iBAAiB;AACjD,UAAM,qBAAqB,IAAI,aAAa,UAAU,sBAAsB,uBAAuB;AACnG,uBAAmB,IAAI,gBAAgB;AAGvC,eAAO,wBAAS,QAAQ;AAAA,EAC1B;AACF;AAWO,SAAS,kBAAkB,MAAgD;AAGhF,kBAAgB;AAGhB,4BAAO,WAAW;AACpB;","names":["modelWorker","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,5 +1,6 @@
 // src/runner.ts
 import { BlobWorker, spawn, Thread, Transfer, Worker } from "threads";
+import { Outputs, updateOutputIndices } from "@sdeverywhere/runtime";
 async function spawnAsyncModelRunner(workerSpec) {
   if (workerSpec["path"]) {
     return spawnAsyncModelRunnerWithWorker(new Worker(workerSpec["path"]));
@@ -10,11 +11,25 @@ async function spawnAsyncModelRunner(workerSpec) {
 async function spawnAsyncModelRunnerWithWorker(worker) {
   const modelWorker2 = await spawn(worker);
   const initResult = await modelWorker2.initModel();
-  const rowLength = initResult.rowLength;
   let ioBuffer = initResult.ioBuffer;
+  const runTimeOffsetInBytes = 0;
+  const runTimeLengthInElements = 1;
+  const runTimeLengthInBytes = runTimeLengthInElements * 8;
+  const inputsOffsetInBytes = runTimeOffsetInBytes + runTimeLengthInBytes;
+  const inputsLengthInElements = initResult.inputsLength;
+  const inputsLengthInBytes = inputsLengthInElements * 8;
+  const outputsOffsetInBytes = inputsOffsetInBytes + inputsLengthInBytes;
+  const outputsLengthInElements = initResult.outputsLength;
+  const outputsLengthInBytes = outputsLengthInElements * 8;
+  const indicesOffsetInBytes = outputsOffsetInBytes + outputsLengthInBytes;
+  const indicesLengthInElements = initResult.outputIndicesLength;
+  const outputRowLength = initResult.outputRowLength;
   let running = false;
   let terminated = false;
   return {
+    createOutputs: () => {
+      return new Outputs(initResult.outputVarIds, initResult.startTime, initResult.endTime, initResult.saveFreq);
+    },
     runModel: async (inputs, outputs) => {
       if (terminated) {
         throw new Error("Async model runner has already been terminated");
@@ -23,24 +38,24 @@ 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);
+      const inputsArray = new Float64Array(ioBuffer, inputsOffsetInBytes, inputsLengthInElements);
       for (let i = 0; i < inputs.length; i++) {
         inputsArray[i] = inputs[i].get();
       }
+      if (indicesLengthInElements > 0) {
+        const outputSpecs = outputs.varSpecs || [];
+        const indicesArray = new Int32Array(ioBuffer, indicesOffsetInBytes, indicesLengthInElements);
+        updateOutputIndices(indicesArray, outputSpecs);
+      }
       try {
         ioBuffer = await modelWorker2.runModel(Transfer(ioBuffer));
       } 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);
+      const runTimeArray = new Float64Array(ioBuffer, runTimeOffsetInBytes, runTimeLengthInElements);
+      outputs.runTimeInMillis = runTimeArray[0];
+      const outputsArray = new Float64Array(ioBuffer, outputsOffsetInBytes, outputsLengthInElements);
+      outputs.updateFromBuffer(outputsArray, outputRowLength);
       return outputs;
     },
     terminate: () => {
@@ -61,42 +76,72 @@ var initWasmModel;
 var wasmModel;
 var inputsWasmBuffer;
 var outputsWasmBuffer;
+var outputIndicesWasmBuffer;
 var modelWorker = {
   async initModel() {
     if (wasmModel) {
       throw new Error("WasmModel was already initialized");
     }
-    const result = await initWasmModel();
-    wasmModel = result.model;
-    inputsWasmBuffer = result.inputsBuffer;
-    outputsWasmBuffer = result.outputsBuffer;
+    const wasmResult = await initWasmModel();
+    wasmModel = wasmResult.model;
+    inputsWasmBuffer = wasmResult.inputsBuffer;
+    outputsWasmBuffer = wasmResult.outputsBuffer;
+    outputIndicesWasmBuffer = wasmResult.outputIndicesBuffer;
     const runTimeLength = 8;
     const inputsLength = inputsWasmBuffer.getArrayView().length;
     const outputsLength = outputsWasmBuffer.getArrayView().length;
-    const ioArray = new Float64Array(runTimeLength + inputsLength + outputsLength);
-    const rowLength = result.endTime - result.startTime + 1;
+    const outputIndicesLength = (outputIndicesWasmBuffer == null ? void 0 : outputIndicesWasmBuffer.getArrayView().length) || 0;
+    const totalLength = runTimeLength + inputsLength + outputsLength + outputIndicesLength;
+    const ioArray = new Float64Array(totalLength);
     const ioBuffer = ioArray.buffer;
-    return Transfer2({ rowLength, ioBuffer }, [ioBuffer]);
+    const initResult = {
+      outputVarIds: wasmResult.outputVarIds,
+      startTime: wasmModel.startTime,
+      endTime: wasmModel.endTime,
+      saveFreq: wasmModel.saveFreq,
+      inputsLength,
+      outputsLength,
+      outputIndicesLength,
+      outputRowLength: wasmModel.numSavePoints,
+      ioBuffer
+    };
+    return Transfer2(initResult, [ioBuffer]);
   },
   runModel(ioBuffer) {
     if (!wasmModel) {
       throw new Error("WasmModel must be initialized before running the model in worker");
     }
+    const runTimeOffsetInBytes = 0;
     const runTimeLengthInElements = 1;
     const runTimeLengthInBytes = runTimeLengthInElements * 8;
     const inputsWasmArray = inputsWasmBuffer.getArrayView();
+    const inputsOffsetInBytes = runTimeOffsetInBytes + runTimeLengthInBytes;
     const inputsLengthInElements = inputsWasmArray.length;
-    const inputsLengthInBytes = inputsLengthInElements * 8;
-    const inputsBufferArray = new Float64Array(ioBuffer, runTimeLengthInBytes, inputsLengthInElements);
+    const inputsLengthInBytes = inputsWasmArray.byteLength;
+    const inputsBufferArray = new Float64Array(ioBuffer, inputsOffsetInBytes, inputsLengthInElements);
     inputsWasmArray.set(inputsBufferArray);
+    const outputsWasmArray = outputsWasmBuffer.getArrayView();
+    const outputsOffsetInBytes = runTimeLengthInBytes + inputsLengthInBytes;
+    const outputsLengthInBytes = outputsWasmArray.byteLength;
+    let useIndices = false;
+    if (outputIndicesWasmBuffer) {
+      const indicesWasmArray = outputIndicesWasmBuffer.getArrayView();
+      const indicesLengthInElements = indicesWasmArray.length;
+      const indicesOffsetInBytes = outputsOffsetInBytes + outputsLengthInBytes;
+      const indicesBufferArray = new Int32Array(ioBuffer, indicesOffsetInBytes, indicesLengthInElements);
+      if (indicesBufferArray[0] !== 0) {
+        indicesWasmArray.set(indicesBufferArray);
+        useIndices = true;
+      }
+    }
     const t0 = perfNow();
-    wasmModel.runModel(inputsWasmBuffer, outputsWasmBuffer);
+    wasmModel.runModel(inputsWasmBuffer, outputsWasmBuffer, useIndices ? outputIndicesWasmBuffer : void 0);
     const elapsed = perfElapsed(t0);
-    const runTimeBufferArray = new Float64Array(ioBuffer, 0, runTimeLengthInElements);
+    const runTimeBufferArray = new Float64Array(ioBuffer, runTimeOffsetInBytes, runTimeLengthInElements);
     runTimeBufferArray[0] = elapsed;
-    const outputsOffsetInBytes = runTimeLengthInBytes + inputsLengthInBytes;
-    const outputsBufferArray = new Float64Array(ioBuffer, outputsOffsetInBytes);
-    outputsBufferArray.set(outputsWasmBuffer.getArrayView());
+    const outputsLengthInElements = outputsWasmArray.length;
+    const outputsBufferArray = new Float64Array(ioBuffer, outputsOffsetInBytes, outputsLengthInElements);
+    outputsBufferArray.set(outputsWasmArray);
     return Transfer2(ioBuffer);
   }
 };

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'\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  const rowLength: number = initResult.rowLength\n  let ioBuffer: ArrayBuffer = initResult.ioBuffer\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    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  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 result = await initWasmModel()\n\n    // Capture the `WasmModel` instance and `WasmBuffer` instances\n    wasmModel = result.model\n    inputsWasmBuffer = result.inputsBuffer\n    outputsWasmBuffer = result.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    // The row length is the number of elements in each row of the outputs buffer\n    const rowLength = result.endTime - result.startTime + 1\n\n    // Transfer the underlying buffer to the runner\n    const ioBuffer = ioArray.buffer\n    return Transfer({ rowLength, ioBuffer }, [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":[]}
+{"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, updateOutputIndices } 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 run time is stored in the first 8 bytes of the shared buffer\n  const runTimeOffsetInBytes = 0\n  const runTimeLengthInElements = 1\n  const runTimeLengthInBytes = runTimeLengthInElements * 8\n\n  // The inputs are stored after the run time in the shared buffer\n  const inputsOffsetInBytes = runTimeOffsetInBytes + runTimeLengthInBytes\n  const inputsLengthInElements: number = initResult.inputsLength\n  const inputsLengthInBytes = inputsLengthInElements * 8\n\n  // The outputs are stored after the inputs in the shared buffer\n  const outputsOffsetInBytes = inputsOffsetInBytes + inputsLengthInBytes\n  const outputsLengthInElements: number = initResult.outputsLength\n  const outputsLengthInBytes = outputsLengthInElements * 8\n\n  // The output indices are (optionally) stored after the outputs in the shared buffer\n  const indicesOffsetInBytes = outputsOffsetInBytes + outputsLengthInBytes\n  const indicesLengthInElements: number = initResult.outputIndicesLength\n\n  // The row length is the number of elements in each row of the outputs buffer\n  const outputRowLength: number = initResult.outputRowLength\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      // Capture the current set of input values into the reusable buffer\n      const inputsArray = new Float64Array(ioBuffer, inputsOffsetInBytes, inputsLengthInElements)\n      for (let i = 0; i < inputs.length; i++) {\n        inputsArray[i] = inputs[i].get()\n      }\n\n      // Update the output indices, if needed\n      if (indicesLengthInElements > 0) {\n        const outputSpecs = outputs.varSpecs || []\n        const indicesArray = new Int32Array(ioBuffer, indicesOffsetInBytes, indicesLengthInElements)\n        updateOutputIndices(indicesArray, outputSpecs)\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 runTimeArray = new Float64Array(ioBuffer, runTimeOffsetInBytes, runTimeLengthInElements)\n      outputs.runTimeInMillis = runTimeArray[0]\n\n      // Capture the outputs array by copying the data into the given `Outputs`\n      // data structure\n      const outputsArray = new Float64Array(ioBuffer, outputsOffsetInBytes, outputsLengthInElements)\n      outputs.updateFromBuffer(outputsArray, outputRowLength)\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<Float64Array>\n/** @hidden */\nlet outputsWasmBuffer: WasmBuffer<Float64Array>\n/** @hidden */\nlet outputIndicesWasmBuffer: WasmBuffer<Int32Array>\n\ninterface InitResult {\n  outputVarIds: string[]\n  startTime: number\n  endTime: number\n  saveFreq: number\n  inputsLength: number\n  outputsLength: number\n  outputIndicesLength: number\n  outputRowLength: 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    outputIndicesWasmBuffer = wasmResult.outputIndicesBuffer\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 outputIndicesLength = outputIndicesWasmBuffer?.getArrayView().length || 0\n    const totalLength = runTimeLength + inputsLength + outputsLength + outputIndicesLength\n    const ioArray = new Float64Array(totalLength)\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      inputsLength,\n      outputsLength,\n      outputIndicesLength,\n      outputRowLength: 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 runTimeOffsetInBytes = 0\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 inputsOffsetInBytes = runTimeOffsetInBytes + runTimeLengthInBytes\n    const inputsLengthInElements = inputsWasmArray.length\n    const inputsLengthInBytes = inputsWasmArray.byteLength\n    const inputsBufferArray = new Float64Array(ioBuffer, inputsOffsetInBytes, inputsLengthInElements)\n    inputsWasmArray.set(inputsBufferArray)\n\n    // Copy the output indices into the wasm buffer, if needed\n    const outputsWasmArray = outputsWasmBuffer.getArrayView()\n    const outputsOffsetInBytes = runTimeLengthInBytes + inputsLengthInBytes\n    const outputsLengthInBytes = outputsWasmArray.byteLength\n    let useIndices = false\n    if (outputIndicesWasmBuffer) {\n      const indicesWasmArray = outputIndicesWasmBuffer.getArrayView()\n      const indicesLengthInElements = indicesWasmArray.length\n      const indicesOffsetInBytes = outputsOffsetInBytes + outputsLengthInBytes\n      const indicesBufferArray = new Int32Array(ioBuffer, indicesOffsetInBytes, indicesLengthInElements)\n      if (indicesBufferArray[0] !== 0) {\n        // Only use the indices if the first index is non-zero\n        indicesWasmArray.set(indicesBufferArray)\n        useIndices = true\n      }\n    }\n\n    // Run the model using the wasm buffers\n    const t0 = perfNow()\n    wasmModel.runModel(inputsWasmBuffer, outputsWasmBuffer, useIndices ? outputIndicesWasmBuffer : undefined)\n    const elapsed = perfElapsed(t0)\n\n    // Write the model run time to the buffer\n    const runTimeBufferArray = new Float64Array(ioBuffer, runTimeOffsetInBytes, runTimeLengthInElements)\n    runTimeBufferArray[0] = elapsed\n\n    // Copy the outputs from the wasm outputs buffer\n    const outputsLengthInElements = outputsWasmArray.length\n    const outputsBufferArray = new Float64Array(ioBuffer, outputsOffsetInBytes, outputsLengthInElements)\n    outputsBufferArray.set(outputsWasmArray)\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"]}

package/dist/runner.cjs

@@ -23,6 +23,7 @@ __export(runner_exports, {
 });
 module.exports = __toCommonJS(runner_exports);
 var import_threads = require("threads");
+var import_runtime = require("@sdeverywhere/runtime");
 async function spawnAsyncModelRunner(workerSpec) {
   if (workerSpec["path"]) {
     return spawnAsyncModelRunnerWithWorker(new import_threads.Worker(workerSpec["path"]));
@@ -33,11 +34,25 @@ async function spawnAsyncModelRunner(workerSpec) {
 async function spawnAsyncModelRunnerWithWorker(worker) {
   const modelWorker = await (0, import_threads.spawn)(worker);
   const initResult = await modelWorker.initModel();
-  const rowLength = initResult.rowLength;
   let ioBuffer = initResult.ioBuffer;
+  const runTimeOffsetInBytes = 0;
+  const runTimeLengthInElements = 1;
+  const runTimeLengthInBytes = runTimeLengthInElements * 8;
+  const inputsOffsetInBytes = runTimeOffsetInBytes + runTimeLengthInBytes;
+  const inputsLengthInElements = initResult.inputsLength;
+  const inputsLengthInBytes = inputsLengthInElements * 8;
+  const outputsOffsetInBytes = inputsOffsetInBytes + inputsLengthInBytes;
+  const outputsLengthInElements = initResult.outputsLength;
+  const outputsLengthInBytes = outputsLengthInElements * 8;
+  const indicesOffsetInBytes = outputsOffsetInBytes + outputsLengthInBytes;
+  const indicesLengthInElements = initResult.outputIndicesLength;
+  const outputRowLength = initResult.outputRowLength;
   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) => {
       if (terminated) {
         throw new Error("Async model runner has already been terminated");
@@ -46,24 +61,24 @@ 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);
+      const inputsArray = new Float64Array(ioBuffer, inputsOffsetInBytes, inputsLengthInElements);
       for (let i = 0; i < inputs.length; i++) {
         inputsArray[i] = inputs[i].get();
       }
+      if (indicesLengthInElements > 0) {
+        const outputSpecs = outputs.varSpecs || [];
+        const indicesArray = new Int32Array(ioBuffer, indicesOffsetInBytes, indicesLengthInElements);
+        (0, import_runtime.updateOutputIndices)(indicesArray, outputSpecs);
+      }
       try {
         ioBuffer = await modelWorker.runModel((0, import_threads.Transfer)(ioBuffer));
       } 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);
+      const runTimeArray = new Float64Array(ioBuffer, runTimeOffsetInBytes, runTimeLengthInElements);
+      outputs.runTimeInMillis = runTimeArray[0];
+      const outputsArray = new Float64Array(ioBuffer, outputsOffsetInBytes, outputsLengthInElements);
+      outputs.updateFromBuffer(outputsArray, outputRowLength);
       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'\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  const rowLength: number = initResult.rowLength\n  let ioBuffer: ArrayBuffer = initResult.ioBuffer\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    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;AAuC5D,qCAA4C,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,+CAA+C,QAAsC;AAEnF,QAAM,cAAc,MAAM,0BAAM,MAAM;AAGtC,QAAM,aAAa,MAAM,YAAY,UAAU;AAC/C,QAAM,YAAoB,WAAW;AACrC,MAAI,WAAwB,WAAW;AAGvC,MAAI,UAAU;AAGd,MAAI,aAAa;AAEjB,SAAO;AAAA,IACL,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,6BAAS,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 { Outputs, updateOutputIndices } 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 run time is stored in the first 8 bytes of the shared buffer\n  const runTimeOffsetInBytes = 0\n  const runTimeLengthInElements = 1\n  const runTimeLengthInBytes = runTimeLengthInElements * 8\n\n  // The inputs are stored after the run time in the shared buffer\n  const inputsOffsetInBytes = runTimeOffsetInBytes + runTimeLengthInBytes\n  const inputsLengthInElements: number = initResult.inputsLength\n  const inputsLengthInBytes = inputsLengthInElements * 8\n\n  // The outputs are stored after the inputs in the shared buffer\n  const outputsOffsetInBytes = inputsOffsetInBytes + inputsLengthInBytes\n  const outputsLengthInElements: number = initResult.outputsLength\n  const outputsLengthInBytes = outputsLengthInElements * 8\n\n  // The output indices are (optionally) stored after the outputs in the shared buffer\n  const indicesOffsetInBytes = outputsOffsetInBytes + outputsLengthInBytes\n  const indicesLengthInElements: number = initResult.outputIndicesLength\n\n  // The row length is the number of elements in each row of the outputs buffer\n  const outputRowLength: number = initResult.outputRowLength\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      // Capture the current set of input values into the reusable buffer\n      const inputsArray = new Float64Array(ioBuffer, inputsOffsetInBytes, inputsLengthInElements)\n      for (let i = 0; i < inputs.length; i++) {\n        inputsArray[i] = inputs[i].get()\n      }\n\n      // Update the output indices, if needed\n      if (indicesLengthInElements > 0) {\n        const outputSpecs = outputs.varSpecs || []\n        const indicesArray = new Int32Array(ioBuffer, indicesOffsetInBytes, indicesLengthInElements)\n        updateOutputIndices(indicesArray, outputSpecs)\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 runTimeArray = new Float64Array(ioBuffer, runTimeOffsetInBytes, runTimeLengthInElements)\n      outputs.runTimeInMillis = runTimeArray[0]\n\n      // Capture the outputs array by copying the data into the given `Outputs`\n      // data structure\n      const outputsArray = new Float64Array(ioBuffer, outputsOffsetInBytes, outputsLengthInElements)\n      outputs.updateFromBuffer(outputsArray, outputRowLength)\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,qBAA6C;AAqC7C,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;AAC/C,MAAI,WAAwB,WAAW;AAGvC,QAAM,uBAAuB;AAC7B,QAAM,0BAA0B;AAChC,QAAM,uBAAuB,0BAA0B;AAGvD,QAAM,sBAAsB,uBAAuB;AACnD,QAAM,yBAAiC,WAAW;AAClD,QAAM,sBAAsB,yBAAyB;AAGrD,QAAM,uBAAuB,sBAAsB;AACnD,QAAM,0BAAkC,WAAW;AACnD,QAAM,uBAAuB,0BAA0B;AAGvD,QAAM,uBAAuB,uBAAuB;AACpD,QAAM,0BAAkC,WAAW;AAGnD,QAAM,kBAA0B,WAAW;AAG3C,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,cAAc,IAAI,aAAa,UAAU,qBAAqB,sBAAsB;AAC1F,eAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;AACtC,oBAAY,CAAC,IAAI,OAAO,CAAC,EAAE,IAAI;AAAA,MACjC;AAGA,UAAI,0BAA0B,GAAG;AAC/B,cAAM,cAAc,QAAQ,YAAY,CAAC;AACzC,cAAM,eAAe,IAAI,WAAW,UAAU,sBAAsB,uBAAuB;AAC3F,gDAAoB,cAAc,WAAW;AAAA,MAC/C;AAMA,UAAI;AACF,mBAAW,MAAM,YAAY,aAAS,yBAAS,QAAQ,CAAC;AAAA,MAC1D,UAAE;AACA,kBAAU;AAAA,MACZ;AAGA,YAAM,eAAe,IAAI,aAAa,UAAU,sBAAsB,uBAAuB;AAC7F,cAAQ,kBAAkB,aAAa,CAAC;AAIxC,YAAM,eAAe,IAAI,aAAa,UAAU,sBAAsB,uBAAuB;AAC7F,cAAQ,iBAAiB,cAAc,eAAe;AAEtD,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,44 @@
+import { ModelRunner } from '@sdeverywhere/runtime';
+
+/**
+ * Initialize a `ModelRunner` that runs the model asynchronously in a worker thread.
+ *
+ * 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:
+ *
+ * ```js
+ * import { initWasmModelAndBuffers } from '@sdeverywhere/runtime'
+ * import { exposeModelWorker } from '@sdeverywhere/runtime-async/worker'
+ *
+ * async function initWasmModel() {
+ *   const wasmModules = loadWasm()
+ *   return initWasmModelAndBuffers(...)
+ * }
+ *
+ * exposeModelWorker(initWasmModel)
+ * ```
+ *
+ * Then, in your web app, call the `spawnAsyncModelRunner` function, which
+ * will spawn the Web Worker 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.js

@@ -1,5 +1,6 @@
 // src/runner.ts
 import { BlobWorker, spawn, Thread, Transfer, Worker } from "threads";
+import { Outputs, updateOutputIndices } from "@sdeverywhere/runtime";
 async function spawnAsyncModelRunner(workerSpec) {
   if (workerSpec["path"]) {
     return spawnAsyncModelRunnerWithWorker(new Worker(workerSpec["path"]));
@@ -10,11 +11,25 @@ async function spawnAsyncModelRunner(workerSpec) {
 async function spawnAsyncModelRunnerWithWorker(worker) {
   const modelWorker = await spawn(worker);
   const initResult = await modelWorker.initModel();
-  const rowLength = initResult.rowLength;
   let ioBuffer = initResult.ioBuffer;
+  const runTimeOffsetInBytes = 0;
+  const runTimeLengthInElements = 1;
+  const runTimeLengthInBytes = runTimeLengthInElements * 8;
+  const inputsOffsetInBytes = runTimeOffsetInBytes + runTimeLengthInBytes;
+  const inputsLengthInElements = initResult.inputsLength;
+  const inputsLengthInBytes = inputsLengthInElements * 8;
+  const outputsOffsetInBytes = inputsOffsetInBytes + inputsLengthInBytes;
+  const outputsLengthInElements = initResult.outputsLength;
+  const outputsLengthInBytes = outputsLengthInElements * 8;
+  const indicesOffsetInBytes = outputsOffsetInBytes + outputsLengthInBytes;
+  const indicesLengthInElements = initResult.outputIndicesLength;
+  const outputRowLength = initResult.outputRowLength;
   let running = false;
   let terminated = false;
   return {
+    createOutputs: () => {
+      return new Outputs(initResult.outputVarIds, initResult.startTime, initResult.endTime, initResult.saveFreq);
+    },
     runModel: async (inputs, outputs) => {
       if (terminated) {
         throw new Error("Async model runner has already been terminated");
@@ -23,24 +38,24 @@ 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);
+      const inputsArray = new Float64Array(ioBuffer, inputsOffsetInBytes, inputsLengthInElements);
       for (let i = 0; i < inputs.length; i++) {
         inputsArray[i] = inputs[i].get();
       }
+      if (indicesLengthInElements > 0) {
+        const outputSpecs = outputs.varSpecs || [];
+        const indicesArray = new Int32Array(ioBuffer, indicesOffsetInBytes, indicesLengthInElements);
+        updateOutputIndices(indicesArray, outputSpecs);
+      }
       try {
         ioBuffer = await modelWorker.runModel(Transfer(ioBuffer));
       } 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);
+      const runTimeArray = new Float64Array(ioBuffer, runTimeOffsetInBytes, runTimeLengthInElements);
+      outputs.runTimeInMillis = runTimeArray[0];
+      const outputsArray = new Float64Array(ioBuffer, outputsOffsetInBytes, outputsLengthInElements);
+      outputs.updateFromBuffer(outputsArray, outputRowLength);
       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'\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  const rowLength: number = initResult.rowLength\n  let ioBuffer: ArrayBuffer = initResult.ioBuffer\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    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;AAuCA,qCAA4C,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,+CAA+C,QAAsC;AAEnF,QAAM,cAAc,MAAM,MAAM,MAAM;AAGtC,QAAM,aAAa,MAAM,YAAY,UAAU;AAC/C,QAAM,YAAoB,WAAW;AACrC,MAAI,WAAwB,WAAW;AAGvC,MAAI,UAAU;AAGd,MAAI,aAAa;AAEjB,SAAO;AAAA,IACL,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 { Outputs, updateOutputIndices } 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 run time is stored in the first 8 bytes of the shared buffer\n  const runTimeOffsetInBytes = 0\n  const runTimeLengthInElements = 1\n  const runTimeLengthInBytes = runTimeLengthInElements * 8\n\n  // The inputs are stored after the run time in the shared buffer\n  const inputsOffsetInBytes = runTimeOffsetInBytes + runTimeLengthInBytes\n  const inputsLengthInElements: number = initResult.inputsLength\n  const inputsLengthInBytes = inputsLengthInElements * 8\n\n  // The outputs are stored after the inputs in the shared buffer\n  const outputsOffsetInBytes = inputsOffsetInBytes + inputsLengthInBytes\n  const outputsLengthInElements: number = initResult.outputsLength\n  const outputsLengthInBytes = outputsLengthInElements * 8\n\n  // The output indices are (optionally) stored after the outputs in the shared buffer\n  const indicesOffsetInBytes = outputsOffsetInBytes + outputsLengthInBytes\n  const indicesLengthInElements: number = initResult.outputIndicesLength\n\n  // The row length is the number of elements in each row of the outputs buffer\n  const outputRowLength: number = initResult.outputRowLength\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      // Capture the current set of input values into the reusable buffer\n      const inputsArray = new Float64Array(ioBuffer, inputsOffsetInBytes, inputsLengthInElements)\n      for (let i = 0; i < inputs.length; i++) {\n        inputsArray[i] = inputs[i].get()\n      }\n\n      // Update the output indices, if needed\n      if (indicesLengthInElements > 0) {\n        const outputSpecs = outputs.varSpecs || []\n        const indicesArray = new Int32Array(ioBuffer, indicesOffsetInBytes, indicesLengthInElements)\n        updateOutputIndices(indicesArray, outputSpecs)\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 runTimeArray = new Float64Array(ioBuffer, runTimeOffsetInBytes, runTimeLengthInElements)\n      outputs.runTimeInMillis = runTimeArray[0]\n\n      // Capture the outputs array by copying the data into the given `Outputs`\n      // data structure\n      const outputsArray = new Float64Array(ioBuffer, outputsOffsetInBytes, outputsLengthInElements)\n      outputs.updateFromBuffer(outputsArray, outputRowLength)\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,SAAS,2BAA2B;AAqC7C,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;AAC/C,MAAI,WAAwB,WAAW;AAGvC,QAAM,uBAAuB;AAC7B,QAAM,0BAA0B;AAChC,QAAM,uBAAuB,0BAA0B;AAGvD,QAAM,sBAAsB,uBAAuB;AACnD,QAAM,yBAAiC,WAAW;AAClD,QAAM,sBAAsB,yBAAyB;AAGrD,QAAM,uBAAuB,sBAAsB;AACnD,QAAM,0BAAkC,WAAW;AACnD,QAAM,uBAAuB,0BAA0B;AAGvD,QAAM,uBAAuB,uBAAuB;AACpD,QAAM,0BAAkC,WAAW;AAGnD,QAAM,kBAA0B,WAAW;AAG3C,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,cAAc,IAAI,aAAa,UAAU,qBAAqB,sBAAsB;AAC1F,eAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;AACtC,oBAAY,CAAC,IAAI,OAAO,CAAC,EAAE,IAAI;AAAA,MACjC;AAGA,UAAI,0BAA0B,GAAG;AAC/B,cAAM,cAAc,QAAQ,YAAY,CAAC;AACzC,cAAM,eAAe,IAAI,WAAW,UAAU,sBAAsB,uBAAuB;AAC3F,4BAAoB,cAAc,WAAW;AAAA,MAC/C;AAMA,UAAI;AACF,mBAAW,MAAM,YAAY,SAAS,SAAS,QAAQ,CAAC;AAAA,MAC1D,UAAE;AACA,kBAAU;AAAA,MACZ;AAGA,YAAM,eAAe,IAAI,aAAa,UAAU,sBAAsB,uBAAuB;AAC7F,cAAQ,kBAAkB,aAAa,CAAC;AAIxC,YAAM,eAAe,IAAI,aAAa,UAAU,sBAAsB,uBAAuB;AAC7F,cAAQ,iBAAiB,cAAc,eAAe;AAEtD,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

@@ -28,42 +28,72 @@ var initWasmModel;
 var wasmModel;
 var inputsWasmBuffer;
 var outputsWasmBuffer;
+var outputIndicesWasmBuffer;
 var modelWorker = {
   async initModel() {
     if (wasmModel) {
       throw new Error("WasmModel was already initialized");
     }
-    const result = await initWasmModel();
-    wasmModel = result.model;
-    inputsWasmBuffer = result.inputsBuffer;
-    outputsWasmBuffer = result.outputsBuffer;
+    const wasmResult = await initWasmModel();
+    wasmModel = wasmResult.model;
+    inputsWasmBuffer = wasmResult.inputsBuffer;
+    outputsWasmBuffer = wasmResult.outputsBuffer;
+    outputIndicesWasmBuffer = wasmResult.outputIndicesBuffer;
     const runTimeLength = 8;
     const inputsLength = inputsWasmBuffer.getArrayView().length;
     const outputsLength = outputsWasmBuffer.getArrayView().length;
-    const ioArray = new Float64Array(runTimeLength + inputsLength + outputsLength);
-    const rowLength = result.endTime - result.startTime + 1;
+    const outputIndicesLength = (outputIndicesWasmBuffer == null ? void 0 : outputIndicesWasmBuffer.getArrayView().length) || 0;
+    const totalLength = runTimeLength + inputsLength + outputsLength + outputIndicesLength;
+    const ioArray = new Float64Array(totalLength);
     const ioBuffer = ioArray.buffer;
-    return (0, import_worker.Transfer)({ rowLength, ioBuffer }, [ioBuffer]);
+    const initResult = {
+      outputVarIds: wasmResult.outputVarIds,
+      startTime: wasmModel.startTime,
+      endTime: wasmModel.endTime,
+      saveFreq: wasmModel.saveFreq,
+      inputsLength,
+      outputsLength,
+      outputIndicesLength,
+      outputRowLength: wasmModel.numSavePoints,
+      ioBuffer
+    };
+    return (0, import_worker.Transfer)(initResult, [ioBuffer]);
   },
   runModel(ioBuffer) {
     if (!wasmModel) {
       throw new Error("WasmModel must be initialized before running the model in worker");
     }
+    const runTimeOffsetInBytes = 0;
     const runTimeLengthInElements = 1;
     const runTimeLengthInBytes = runTimeLengthInElements * 8;
     const inputsWasmArray = inputsWasmBuffer.getArrayView();
+    const inputsOffsetInBytes = runTimeOffsetInBytes + runTimeLengthInBytes;
     const inputsLengthInElements = inputsWasmArray.length;
-    const inputsLengthInBytes = inputsLengthInElements * 8;
-    const inputsBufferArray = new Float64Array(ioBuffer, runTimeLengthInBytes, inputsLengthInElements);
+    const inputsLengthInBytes = inputsWasmArray.byteLength;
+    const inputsBufferArray = new Float64Array(ioBuffer, inputsOffsetInBytes, inputsLengthInElements);
     inputsWasmArray.set(inputsBufferArray);
+    const outputsWasmArray = outputsWasmBuffer.getArrayView();
+    const outputsOffsetInBytes = runTimeLengthInBytes + inputsLengthInBytes;
+    const outputsLengthInBytes = outputsWasmArray.byteLength;
+    let useIndices = false;
+    if (outputIndicesWasmBuffer) {
+      const indicesWasmArray = outputIndicesWasmBuffer.getArrayView();
+      const indicesLengthInElements = indicesWasmArray.length;
+      const indicesOffsetInBytes = outputsOffsetInBytes + outputsLengthInBytes;
+      const indicesBufferArray = new Int32Array(ioBuffer, indicesOffsetInBytes, indicesLengthInElements);
+      if (indicesBufferArray[0] !== 0) {
+        indicesWasmArray.set(indicesBufferArray);
+        useIndices = true;
+      }
+    }
     const t0 = (0, import_runtime.perfNow)();
-    wasmModel.runModel(inputsWasmBuffer, outputsWasmBuffer);
+    wasmModel.runModel(inputsWasmBuffer, outputsWasmBuffer, useIndices ? outputIndicesWasmBuffer : void 0);
     const elapsed = (0, import_runtime.perfElapsed)(t0);
-    const runTimeBufferArray = new Float64Array(ioBuffer, 0, runTimeLengthInElements);
+    const runTimeBufferArray = new Float64Array(ioBuffer, runTimeOffsetInBytes, runTimeLengthInElements);
     runTimeBufferArray[0] = elapsed;
-    const outputsOffsetInBytes = runTimeLengthInBytes + inputsLengthInBytes;
-    const outputsBufferArray = new Float64Array(ioBuffer, outputsOffsetInBytes);
-    outputsBufferArray.set(outputsWasmBuffer.getArrayView());
+    const outputsLengthInElements = outputsWasmArray.length;
+    const outputsBufferArray = new Float64Array(ioBuffer, outputsOffsetInBytes, outputsLengthInElements);
+    outputsBufferArray.set(outputsWasmArray);
     return (0, import_worker.Transfer)(ioBuffer);
   }
 };

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  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 result = await initWasmModel()\n\n    // Capture the `WasmModel` instance and `WasmBuffer` instances\n    wasmModel = result.model\n    inputsWasmBuffer = result.inputsBuffer\n    outputsWasmBuffer = result.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    // The row length is the number of elements in each row of the outputs buffer\n    const rowLength = result.endTime - result.startTime + 1\n\n    // Transfer the underlying buffer to the runner\n    const ioBuffer = ioArray.buffer\n    return Transfer({ rowLength, ioBuffer }, [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;AAQJ,IAAM,cAAc;AAAA,EAClB,MAAM,YAAqD;AACzD,QAAI,WAAW;AACb,YAAM,IAAI,MAAM,mCAAmC;AAAA,IACrD;AAGA,UAAM,SAAS,MAAM,cAAc;AAGnC,gBAAY,OAAO;AACnB,uBAAmB,OAAO;AAC1B,wBAAoB,OAAO;AAK3B,UAAM,gBAAgB;AACtB,UAAM,eAAe,iBAAiB,aAAa,EAAE;AACrD,UAAM,gBAAgB,kBAAkB,aAAa,EAAE;AACvD,UAAM,UAAU,IAAI,aAAa,gBAAgB,eAAe,aAAa;AAG7E,UAAM,YAAY,OAAO,UAAU,OAAO,YAAY;AAGtD,UAAM,WAAW,QAAQ;AACzB,WAAO,4BAAS,EAAE,WAAW,SAAS,GAAG,CAAC,QAAQ,CAAC;AAAA,EACrD;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,4BAAQ;AACnB,cAAU,SAAS,kBAAkB,iBAAiB;AACtD,UAAM,UAAU,gCAAY,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,4BAAS,QAAQ;AAAA,EAC1B;AACF;AAWO,2BAA2B,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 { 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<Float64Array>\n/** @hidden */\nlet outputsWasmBuffer: WasmBuffer<Float64Array>\n/** @hidden */\nlet outputIndicesWasmBuffer: WasmBuffer<Int32Array>\n\ninterface InitResult {\n  outputVarIds: string[]\n  startTime: number\n  endTime: number\n  saveFreq: number\n  inputsLength: number\n  outputsLength: number\n  outputIndicesLength: number\n  outputRowLength: 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    outputIndicesWasmBuffer = wasmResult.outputIndicesBuffer\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 outputIndicesLength = outputIndicesWasmBuffer?.getArrayView().length || 0\n    const totalLength = runTimeLength + inputsLength + outputsLength + outputIndicesLength\n    const ioArray = new Float64Array(totalLength)\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      inputsLength,\n      outputsLength,\n      outputIndicesLength,\n      outputRowLength: 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 runTimeOffsetInBytes = 0\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 inputsOffsetInBytes = runTimeOffsetInBytes + runTimeLengthInBytes\n    const inputsLengthInElements = inputsWasmArray.length\n    const inputsLengthInBytes = inputsWasmArray.byteLength\n    const inputsBufferArray = new Float64Array(ioBuffer, inputsOffsetInBytes, inputsLengthInElements)\n    inputsWasmArray.set(inputsBufferArray)\n\n    // Copy the output indices into the wasm buffer, if needed\n    const outputsWasmArray = outputsWasmBuffer.getArrayView()\n    const outputsOffsetInBytes = runTimeLengthInBytes + inputsLengthInBytes\n    const outputsLengthInBytes = outputsWasmArray.byteLength\n    let useIndices = false\n    if (outputIndicesWasmBuffer) {\n      const indicesWasmArray = outputIndicesWasmBuffer.getArrayView()\n      const indicesLengthInElements = indicesWasmArray.length\n      const indicesOffsetInBytes = outputsOffsetInBytes + outputsLengthInBytes\n      const indicesBufferArray = new Int32Array(ioBuffer, indicesOffsetInBytes, indicesLengthInElements)\n      if (indicesBufferArray[0] !== 0) {\n        // Only use the indices if the first index is non-zero\n        indicesWasmArray.set(indicesBufferArray)\n        useIndices = true\n      }\n    }\n\n    // Run the model using the wasm buffers\n    const t0 = perfNow()\n    wasmModel.runModel(inputsWasmBuffer, outputsWasmBuffer, useIndices ? outputIndicesWasmBuffer : undefined)\n    const elapsed = perfElapsed(t0)\n\n    // Write the model run time to the buffer\n    const runTimeBufferArray = new Float64Array(ioBuffer, runTimeOffsetInBytes, runTimeLengthInElements)\n    runTimeBufferArray[0] = elapsed\n\n    // Copy the outputs from the wasm outputs buffer\n    const outputsLengthInElements = outputsWasmArray.length\n    const outputsBufferArray = new Float64Array(ioBuffer, outputsOffsetInBytes, outputsLengthInElements)\n    outputsBufferArray.set(outputsWasmArray)\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;AAEJ,IAAI;AAeJ,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;AAC/B,8BAA0B,WAAW;AAKrC,UAAM,gBAAgB;AACtB,UAAM,eAAe,iBAAiB,aAAa,EAAE;AACrD,UAAM,gBAAgB,kBAAkB,aAAa,EAAE;AACvD,UAAM,uBAAsB,mEAAyB,eAAe,WAAU;AAC9E,UAAM,cAAc,gBAAgB,eAAe,gBAAgB;AACnE,UAAM,UAAU,IAAI,aAAa,WAAW;AAG5C,UAAM,WAAW,QAAQ;AACzB,UAAM,aAAyB;AAAA,MAC7B,cAAc,WAAW;AAAA,MACzB,WAAW,UAAU;AAAA,MACrB,SAAS,UAAU;AAAA,MACnB,UAAU,UAAU;AAAA,MACpB;AAAA,MACA;AAAA,MACA;AAAA,MACA,iBAAiB,UAAU;AAAA,MAC3B;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,uBAAuB;AAC7B,UAAM,0BAA0B;AAChC,UAAM,uBAAuB,0BAA0B;AAGvD,UAAM,kBAAkB,iBAAiB,aAAa;AACtD,UAAM,sBAAsB,uBAAuB;AACnD,UAAM,yBAAyB,gBAAgB;AAC/C,UAAM,sBAAsB,gBAAgB;AAC5C,UAAM,oBAAoB,IAAI,aAAa,UAAU,qBAAqB,sBAAsB;AAChG,oBAAgB,IAAI,iBAAiB;AAGrC,UAAM,mBAAmB,kBAAkB,aAAa;AACxD,UAAM,uBAAuB,uBAAuB;AACpD,UAAM,uBAAuB,iBAAiB;AAC9C,QAAI,aAAa;AACjB,QAAI,yBAAyB;AAC3B,YAAM,mBAAmB,wBAAwB,aAAa;AAC9D,YAAM,0BAA0B,iBAAiB;AACjD,YAAM,uBAAuB,uBAAuB;AACpD,YAAM,qBAAqB,IAAI,WAAW,UAAU,sBAAsB,uBAAuB;AACjG,UAAI,mBAAmB,CAAC,MAAM,GAAG;AAE/B,yBAAiB,IAAI,kBAAkB;AACvC,qBAAa;AAAA,MACf;AAAA,IACF;AAGA,UAAM,SAAK,wBAAQ;AACnB,cAAU,SAAS,kBAAkB,mBAAmB,aAAa,0BAA0B,MAAS;AACxG,UAAM,cAAU,4BAAY,EAAE;AAG9B,UAAM,qBAAqB,IAAI,aAAa,UAAU,sBAAsB,uBAAuB;AACnG,uBAAmB,CAAC,IAAI;AAGxB,UAAM,0BAA0B,iBAAiB;AACjD,UAAM,qBAAqB,IAAI,aAAa,UAAU,sBAAsB,uBAAuB;AACnG,uBAAmB,IAAI,gBAAgB;AAGvC,eAAO,wBAAS,QAAQ;AAAA,EAC1B;AACF;AAWO,SAAS,kBAAkB,MAAgD;AAGhF,kBAAgB;AAGhB,4BAAO,WAAW;AACpB;","names":[]}

package/dist/worker.d.cts

@@ -0,0 +1,14 @@
+import { WasmModelInitResult } 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.
+ *
+ * @param init The function that initializes the `WasmModel` instance that
+ * is used in the worker thread.
+ */
+declare function exposeModelWorker(init: () => Promise<WasmModelInitResult>): void;
+
+export { exposeModelWorker };

package/dist/worker.js

@@ -5,42 +5,72 @@ var initWasmModel;
 var wasmModel;
 var inputsWasmBuffer;
 var outputsWasmBuffer;
+var outputIndicesWasmBuffer;
 var modelWorker = {
   async initModel() {
     if (wasmModel) {
       throw new Error("WasmModel was already initialized");
     }
-    const result = await initWasmModel();
-    wasmModel = result.model;
-    inputsWasmBuffer = result.inputsBuffer;
-    outputsWasmBuffer = result.outputsBuffer;
+    const wasmResult = await initWasmModel();
+    wasmModel = wasmResult.model;
+    inputsWasmBuffer = wasmResult.inputsBuffer;
+    outputsWasmBuffer = wasmResult.outputsBuffer;
+    outputIndicesWasmBuffer = wasmResult.outputIndicesBuffer;
     const runTimeLength = 8;
     const inputsLength = inputsWasmBuffer.getArrayView().length;
     const outputsLength = outputsWasmBuffer.getArrayView().length;
-    const ioArray = new Float64Array(runTimeLength + inputsLength + outputsLength);
-    const rowLength = result.endTime - result.startTime + 1;
+    const outputIndicesLength = (outputIndicesWasmBuffer == null ? void 0 : outputIndicesWasmBuffer.getArrayView().length) || 0;
+    const totalLength = runTimeLength + inputsLength + outputsLength + outputIndicesLength;
+    const ioArray = new Float64Array(totalLength);
     const ioBuffer = ioArray.buffer;
-    return Transfer({ rowLength, ioBuffer }, [ioBuffer]);
+    const initResult = {
+      outputVarIds: wasmResult.outputVarIds,
+      startTime: wasmModel.startTime,
+      endTime: wasmModel.endTime,
+      saveFreq: wasmModel.saveFreq,
+      inputsLength,
+      outputsLength,
+      outputIndicesLength,
+      outputRowLength: wasmModel.numSavePoints,
+      ioBuffer
+    };
+    return Transfer(initResult, [ioBuffer]);
   },
   runModel(ioBuffer) {
     if (!wasmModel) {
       throw new Error("WasmModel must be initialized before running the model in worker");
     }
+    const runTimeOffsetInBytes = 0;
     const runTimeLengthInElements = 1;
     const runTimeLengthInBytes = runTimeLengthInElements * 8;
     const inputsWasmArray = inputsWasmBuffer.getArrayView();
+    const inputsOffsetInBytes = runTimeOffsetInBytes + runTimeLengthInBytes;
     const inputsLengthInElements = inputsWasmArray.length;
-    const inputsLengthInBytes = inputsLengthInElements * 8;
-    const inputsBufferArray = new Float64Array(ioBuffer, runTimeLengthInBytes, inputsLengthInElements);
+    const inputsLengthInBytes = inputsWasmArray.byteLength;
+    const inputsBufferArray = new Float64Array(ioBuffer, inputsOffsetInBytes, inputsLengthInElements);
     inputsWasmArray.set(inputsBufferArray);
+    const outputsWasmArray = outputsWasmBuffer.getArrayView();
+    const outputsOffsetInBytes = runTimeLengthInBytes + inputsLengthInBytes;
+    const outputsLengthInBytes = outputsWasmArray.byteLength;
+    let useIndices = false;
+    if (outputIndicesWasmBuffer) {
+      const indicesWasmArray = outputIndicesWasmBuffer.getArrayView();
+      const indicesLengthInElements = indicesWasmArray.length;
+      const indicesOffsetInBytes = outputsOffsetInBytes + outputsLengthInBytes;
+      const indicesBufferArray = new Int32Array(ioBuffer, indicesOffsetInBytes, indicesLengthInElements);
+      if (indicesBufferArray[0] !== 0) {
+        indicesWasmArray.set(indicesBufferArray);
+        useIndices = true;
+      }
+    }
     const t0 = perfNow();
-    wasmModel.runModel(inputsWasmBuffer, outputsWasmBuffer);
+    wasmModel.runModel(inputsWasmBuffer, outputsWasmBuffer, useIndices ? outputIndicesWasmBuffer : void 0);
     const elapsed = perfElapsed(t0);
-    const runTimeBufferArray = new Float64Array(ioBuffer, 0, runTimeLengthInElements);
+    const runTimeBufferArray = new Float64Array(ioBuffer, runTimeOffsetInBytes, runTimeLengthInElements);
     runTimeBufferArray[0] = elapsed;
-    const outputsOffsetInBytes = runTimeLengthInBytes + inputsLengthInBytes;
-    const outputsBufferArray = new Float64Array(ioBuffer, outputsOffsetInBytes);
-    outputsBufferArray.set(outputsWasmBuffer.getArrayView());
+    const outputsLengthInElements = outputsWasmArray.length;
+    const outputsBufferArray = new Float64Array(ioBuffer, outputsOffsetInBytes, outputsLengthInElements);
+    outputsBufferArray.set(outputsWasmArray);
     return Transfer(ioBuffer);
   }
 };

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  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 result = await initWasmModel()\n\n    // Capture the `WasmModel` instance and `WasmBuffer` instances\n    wasmModel = result.model\n    inputsWasmBuffer = result.inputsBuffer\n    outputsWasmBuffer = result.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    // The row length is the number of elements in each row of the outputs buffer\n    const rowLength = result.endTime - result.startTime + 1\n\n    // Transfer the underlying buffer to the runner\n    const ioBuffer = ioArray.buffer\n    return Transfer({ rowLength, ioBuffer }, [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;AAGA;AAGA,IAAI;AAEJ,IAAI;AAEJ,IAAI;AAEJ,IAAI;AAQJ,IAAM,cAAc;AAAA,EAClB,MAAM,YAAqD;AACzD,QAAI,WAAW;AACb,YAAM,IAAI,MAAM,mCAAmC;AAAA,IACrD;AAGA,UAAM,SAAS,MAAM,cAAc;AAGnC,gBAAY,OAAO;AACnB,uBAAmB,OAAO;AAC1B,wBAAoB,OAAO;AAK3B,UAAM,gBAAgB;AACtB,UAAM,eAAe,iBAAiB,aAAa,EAAE;AACrD,UAAM,gBAAgB,kBAAkB,aAAa,EAAE;AACvD,UAAM,UAAU,IAAI,aAAa,gBAAgB,eAAe,aAAa;AAG7E,UAAM,YAAY,OAAO,UAAU,OAAO,YAAY;AAGtD,UAAM,WAAW,QAAQ;AACzB,WAAO,SAAS,EAAE,WAAW,SAAS,GAAG,CAAC,QAAQ,CAAC;AAAA,EACrD;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,2BAA2B,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 { 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<Float64Array>\n/** @hidden */\nlet outputsWasmBuffer: WasmBuffer<Float64Array>\n/** @hidden */\nlet outputIndicesWasmBuffer: WasmBuffer<Int32Array>\n\ninterface InitResult {\n  outputVarIds: string[]\n  startTime: number\n  endTime: number\n  saveFreq: number\n  inputsLength: number\n  outputsLength: number\n  outputIndicesLength: number\n  outputRowLength: 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    outputIndicesWasmBuffer = wasmResult.outputIndicesBuffer\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 outputIndicesLength = outputIndicesWasmBuffer?.getArrayView().length || 0\n    const totalLength = runTimeLength + inputsLength + outputsLength + outputIndicesLength\n    const ioArray = new Float64Array(totalLength)\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      inputsLength,\n      outputsLength,\n      outputIndicesLength,\n      outputRowLength: 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 runTimeOffsetInBytes = 0\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 inputsOffsetInBytes = runTimeOffsetInBytes + runTimeLengthInBytes\n    const inputsLengthInElements = inputsWasmArray.length\n    const inputsLengthInBytes = inputsWasmArray.byteLength\n    const inputsBufferArray = new Float64Array(ioBuffer, inputsOffsetInBytes, inputsLengthInElements)\n    inputsWasmArray.set(inputsBufferArray)\n\n    // Copy the output indices into the wasm buffer, if needed\n    const outputsWasmArray = outputsWasmBuffer.getArrayView()\n    const outputsOffsetInBytes = runTimeLengthInBytes + inputsLengthInBytes\n    const outputsLengthInBytes = outputsWasmArray.byteLength\n    let useIndices = false\n    if (outputIndicesWasmBuffer) {\n      const indicesWasmArray = outputIndicesWasmBuffer.getArrayView()\n      const indicesLengthInElements = indicesWasmArray.length\n      const indicesOffsetInBytes = outputsOffsetInBytes + outputsLengthInBytes\n      const indicesBufferArray = new Int32Array(ioBuffer, indicesOffsetInBytes, indicesLengthInElements)\n      if (indicesBufferArray[0] !== 0) {\n        // Only use the indices if the first index is non-zero\n        indicesWasmArray.set(indicesBufferArray)\n        useIndices = true\n      }\n    }\n\n    // Run the model using the wasm buffers\n    const t0 = perfNow()\n    wasmModel.runModel(inputsWasmBuffer, outputsWasmBuffer, useIndices ? outputIndicesWasmBuffer : undefined)\n    const elapsed = perfElapsed(t0)\n\n    // Write the model run time to the buffer\n    const runTimeBufferArray = new Float64Array(ioBuffer, runTimeOffsetInBytes, runTimeLengthInElements)\n    runTimeBufferArray[0] = elapsed\n\n    // Copy the outputs from the wasm outputs buffer\n    const outputsLengthInElements = outputsWasmArray.length\n    const outputsBufferArray = new Float64Array(ioBuffer, outputsOffsetInBytes, outputsLengthInElements)\n    outputsBufferArray.set(outputsWasmArray)\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;AAEJ,IAAI;AAeJ,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;AAC/B,8BAA0B,WAAW;AAKrC,UAAM,gBAAgB;AACtB,UAAM,eAAe,iBAAiB,aAAa,EAAE;AACrD,UAAM,gBAAgB,kBAAkB,aAAa,EAAE;AACvD,UAAM,uBAAsB,mEAAyB,eAAe,WAAU;AAC9E,UAAM,cAAc,gBAAgB,eAAe,gBAAgB;AACnE,UAAM,UAAU,IAAI,aAAa,WAAW;AAG5C,UAAM,WAAW,QAAQ;AACzB,UAAM,aAAyB;AAAA,MAC7B,cAAc,WAAW;AAAA,MACzB,WAAW,UAAU;AAAA,MACrB,SAAS,UAAU;AAAA,MACnB,UAAU,UAAU;AAAA,MACpB;AAAA,MACA;AAAA,MACA;AAAA,MACA,iBAAiB,UAAU;AAAA,MAC3B;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,uBAAuB;AAC7B,UAAM,0BAA0B;AAChC,UAAM,uBAAuB,0BAA0B;AAGvD,UAAM,kBAAkB,iBAAiB,aAAa;AACtD,UAAM,sBAAsB,uBAAuB;AACnD,UAAM,yBAAyB,gBAAgB;AAC/C,UAAM,sBAAsB,gBAAgB;AAC5C,UAAM,oBAAoB,IAAI,aAAa,UAAU,qBAAqB,sBAAsB;AAChG,oBAAgB,IAAI,iBAAiB;AAGrC,UAAM,mBAAmB,kBAAkB,aAAa;AACxD,UAAM,uBAAuB,uBAAuB;AACpD,UAAM,uBAAuB,iBAAiB;AAC9C,QAAI,aAAa;AACjB,QAAI,yBAAyB;AAC3B,YAAM,mBAAmB,wBAAwB,aAAa;AAC9D,YAAM,0BAA0B,iBAAiB;AACjD,YAAM,uBAAuB,uBAAuB;AACpD,YAAM,qBAAqB,IAAI,WAAW,UAAU,sBAAsB,uBAAuB;AACjG,UAAI,mBAAmB,CAAC,MAAM,GAAG;AAE/B,yBAAiB,IAAI,kBAAkB;AACvC,qBAAa;AAAA,MACf;AAAA,IACF;AAGA,UAAM,KAAK,QAAQ;AACnB,cAAU,SAAS,kBAAkB,mBAAmB,aAAa,0BAA0B,MAAS;AACxG,UAAM,UAAU,YAAY,EAAE;AAG9B,UAAM,qBAAqB,IAAI,aAAa,UAAU,sBAAsB,uBAAuB;AACnG,uBAAmB,CAAC,IAAI;AAGxB,UAAM,0BAA0B,iBAAiB;AACjD,UAAM,qBAAqB,IAAI,aAAa,UAAU,sBAAsB,uBAAuB;AACnG,uBAAmB,IAAI,gBAAgB;AAGvC,WAAO,SAAS,QAAQ;AAAA,EAC1B;AACF;AAWO,SAAS,kBAAkB,MAAgD;AAGhF,kBAAgB;AAGhB,SAAO,WAAW;AACpB;","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sdeverywhere/runtime-async",
-  "version": "0.1.0",
+  "version": "0.2.2",
   "files": [
     "dist/**"
   ],
@@ -26,7 +26,7 @@
     }
   },
   "dependencies": {
-    "@sdeverywhere/runtime": "^0.1.0",
+    "@sdeverywhere/runtime": "^0.2.2",
     "threads": "1.7.0"
   },
   "author": "Climate Interactive",