@sdeverywhere/runtime-async 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020-2022 Climate Interactive / New Venture Fund
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,50 @@
+# @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.
+
+## Usage
+
+### 1. Initialize the `WasmModel` in a Web Worker
+
+In your app project, define a separate JavaScript file, called
+`worker.js` for example, that initializes the model worker in the
+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)
+```
+
+### 2. Spawn the worker
+
+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' })
+  // ...
+}
+```
+
+## Documentation
+
+API documentation is available in the [`docs`](./docs/index.md) directory.
+
+## License
+
+SDEverywhere is distributed under the MIT license. See `LICENSE` for more details.

package/dist/index.cjs

@@ -0,0 +1,138 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  exposeModelWorker: () => exposeModelWorker,
+  spawnAsyncModelRunner: () => spawnAsyncModelRunner
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/runner.ts
+var import_threads = require("threads");
+async function spawnAsyncModelRunner(workerSpec) {
+  if (workerSpec["path"]) {
+    return spawnAsyncModelRunnerWithWorker(new import_threads.Worker(workerSpec["path"]));
+  } else {
+    return spawnAsyncModelRunnerWithWorker(import_threads.BlobWorker.fromText(workerSpec["source"]));
+  }
+}
+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;
+  let running = false;
+  let terminated = false;
+  return {
+    runModel: async (inputs, outputs) => {
+      if (terminated) {
+        throw new Error("Async model runner has already been terminated");
+      } else if (running) {
+        throw new Error("Async model runner only supports one `runModel` call at a time");
+      } else {
+        running = true;
+      }
+      const runTimeLengthInElements = 1;
+      const runTimeLengthInBytes = runTimeLengthInElements * 8;
+      const inputsLengthInElements = inputs.length;
+      const inputsLengthInBytes = inputsLengthInElements * 8;
+      const inputsArray = new Float64Array(ioBuffer, runTimeLengthInBytes, inputsLengthInElements);
+      for (let i = 0; i < inputs.length; i++) {
+        inputsArray[i] = inputs[i].get();
+      }
+      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);
+      return outputs;
+    },
+    terminate: () => {
+      if (terminated) {
+        return Promise.resolve();
+      } else {
+        terminated = true;
+        return import_threads.Thread.terminate(modelWorker2);
+      }
+    }
+  };
+}
+
+// src/worker.ts
+var import_worker = require("threads/worker");
+var import_runtime = require("@sdeverywhere/runtime");
+var initWasmModel;
+var wasmModel;
+var inputsWasmBuffer;
+var outputsWasmBuffer;
+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 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 ioBuffer = ioArray.buffer;
+    return (0, import_worker.Transfer)({ rowLength, ioBuffer }, [ioBuffer]);
+  },
+  runModel(ioBuffer) {
+    if (!wasmModel) {
+      throw new Error("WasmModel must be initialized before running the model in worker");
+    }
+    const runTimeLengthInElements = 1;
+    const runTimeLengthInBytes = runTimeLengthInElements * 8;
+    const inputsWasmArray = inputsWasmBuffer.getArrayView();
+    const inputsLengthInElements = inputsWasmArray.length;
+    const inputsLengthInBytes = inputsLengthInElements * 8;
+    const inputsBufferArray = new Float64Array(ioBuffer, runTimeLengthInBytes, inputsLengthInElements);
+    inputsWasmArray.set(inputsBufferArray);
+    const t0 = (0, import_runtime.perfNow)();
+    wasmModel.runModel(inputsWasmBuffer, outputsWasmBuffer);
+    const elapsed = (0, import_runtime.perfElapsed)(t0);
+    const runTimeBufferArray = new Float64Array(ioBuffer, 0, runTimeLengthInElements);
+    runTimeBufferArray[0] = elapsed;
+    const outputsOffsetInBytes = runTimeLengthInBytes + inputsLengthInBytes;
+    const outputsBufferArray = new Float64Array(ioBuffer, outputsOffsetInBytes);
+    outputsBufferArray.set(outputsWasmBuffer.getArrayView());
+    return (0, import_worker.Transfer)(ioBuffer);
+  }
+};
+function exposeModelWorker(init) {
+  initWasmModel = init;
+  (0, import_worker.expose)(modelWorker);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  exposeModelWorker,
+  spawnAsyncModelRunner
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +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":[]}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,111 @@
+// src/runner.ts
+import { BlobWorker, spawn, Thread, Transfer, Worker } from "threads";
+async function spawnAsyncModelRunner(workerSpec) {
+  if (workerSpec["path"]) {
+    return spawnAsyncModelRunnerWithWorker(new Worker(workerSpec["path"]));
+  } else {
+    return spawnAsyncModelRunnerWithWorker(BlobWorker.fromText(workerSpec["source"]));
+  }
+}
+async function spawnAsyncModelRunnerWithWorker(worker) {
+  const modelWorker2 = await spawn(worker);
+  const initResult = await modelWorker2.initModel();
+  const rowLength = initResult.rowLength;
+  let ioBuffer = initResult.ioBuffer;
+  let running = false;
+  let terminated = false;
+  return {
+    runModel: async (inputs, outputs) => {
+      if (terminated) {
+        throw new Error("Async model runner has already been terminated");
+      } else if (running) {
+        throw new Error("Async model runner only supports one `runModel` call at a time");
+      } else {
+        running = true;
+      }
+      const runTimeLengthInElements = 1;
+      const runTimeLengthInBytes = runTimeLengthInElements * 8;
+      const inputsLengthInElements = inputs.length;
+      const inputsLengthInBytes = inputsLengthInElements * 8;
+      const inputsArray = new Float64Array(ioBuffer, runTimeLengthInBytes, inputsLengthInElements);
+      for (let i = 0; i < inputs.length; i++) {
+        inputsArray[i] = inputs[i].get();
+      }
+      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);
+      return outputs;
+    },
+    terminate: () => {
+      if (terminated) {
+        return Promise.resolve();
+      } else {
+        terminated = true;
+        return Thread.terminate(modelWorker2);
+      }
+    }
+  };
+}
+
+// src/worker.ts
+import { expose, Transfer as Transfer2 } from "threads/worker";
+import { perfElapsed, perfNow } from "@sdeverywhere/runtime";
+var initWasmModel;
+var wasmModel;
+var inputsWasmBuffer;
+var outputsWasmBuffer;
+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 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 ioBuffer = ioArray.buffer;
+    return Transfer2({ rowLength, ioBuffer }, [ioBuffer]);
+  },
+  runModel(ioBuffer) {
+    if (!wasmModel) {
+      throw new Error("WasmModel must be initialized before running the model in worker");
+    }
+    const runTimeLengthInElements = 1;
+    const runTimeLengthInBytes = runTimeLengthInElements * 8;
+    const inputsWasmArray = inputsWasmBuffer.getArrayView();
+    const inputsLengthInElements = inputsWasmArray.length;
+    const inputsLengthInBytes = inputsLengthInElements * 8;
+    const inputsBufferArray = new Float64Array(ioBuffer, runTimeLengthInBytes, inputsLengthInElements);
+    inputsWasmArray.set(inputsBufferArray);
+    const t0 = perfNow();
+    wasmModel.runModel(inputsWasmBuffer, outputsWasmBuffer);
+    const elapsed = perfElapsed(t0);
+    const runTimeBufferArray = new Float64Array(ioBuffer, 0, runTimeLengthInElements);
+    runTimeBufferArray[0] = elapsed;
+    const outputsOffsetInBytes = runTimeLengthInBytes + inputsLengthInBytes;
+    const outputsBufferArray = new Float64Array(ioBuffer, outputsOffsetInBytes);
+    outputsBufferArray.set(outputsWasmBuffer.getArrayView());
+    return Transfer2(ioBuffer);
+  }
+};
+function exposeModelWorker(init) {
+  initWasmModel = init;
+  expose(modelWorker);
+}
+export {
+  exposeModelWorker,
+  spawnAsyncModelRunner
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +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":[]}

package/dist/runner.cjs

@@ -0,0 +1,83 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/runner.ts
+var runner_exports = {};
+__export(runner_exports, {
+  spawnAsyncModelRunner: () => spawnAsyncModelRunner
+});
+module.exports = __toCommonJS(runner_exports);
+var import_threads = require("threads");
+async function spawnAsyncModelRunner(workerSpec) {
+  if (workerSpec["path"]) {
+    return spawnAsyncModelRunnerWithWorker(new import_threads.Worker(workerSpec["path"]));
+  } else {
+    return spawnAsyncModelRunnerWithWorker(import_threads.BlobWorker.fromText(workerSpec["source"]));
+  }
+}
+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;
+  let running = false;
+  let terminated = false;
+  return {
+    runModel: async (inputs, outputs) => {
+      if (terminated) {
+        throw new Error("Async model runner has already been terminated");
+      } else if (running) {
+        throw new Error("Async model runner only supports one `runModel` call at a time");
+      } else {
+        running = true;
+      }
+      const runTimeLengthInElements = 1;
+      const runTimeLengthInBytes = runTimeLengthInElements * 8;
+      const inputsLengthInElements = inputs.length;
+      const inputsLengthInBytes = inputsLengthInElements * 8;
+      const inputsArray = new Float64Array(ioBuffer, runTimeLengthInBytes, inputsLengthInElements);
+      for (let i = 0; i < inputs.length; i++) {
+        inputsArray[i] = inputs[i].get();
+      }
+      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);
+      return outputs;
+    },
+    terminate: () => {
+      if (terminated) {
+        return Promise.resolve();
+      } else {
+        terminated = true;
+        return import_threads.Thread.terminate(modelWorker);
+      }
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  spawnAsyncModelRunner
+});
+//# sourceMappingURL=runner.cjs.map

package/dist/runner.cjs.map

@@ -0,0 +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":[]}

package/dist/runner.d.ts

@@ -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

@@ -0,0 +1,59 @@
+// src/runner.ts
+import { BlobWorker, spawn, Thread, Transfer, Worker } from "threads";
+async function spawnAsyncModelRunner(workerSpec) {
+  if (workerSpec["path"]) {
+    return spawnAsyncModelRunnerWithWorker(new Worker(workerSpec["path"]));
+  } else {
+    return spawnAsyncModelRunnerWithWorker(BlobWorker.fromText(workerSpec["source"]));
+  }
+}
+async function spawnAsyncModelRunnerWithWorker(worker) {
+  const modelWorker = await spawn(worker);
+  const initResult = await modelWorker.initModel();
+  const rowLength = initResult.rowLength;
+  let ioBuffer = initResult.ioBuffer;
+  let running = false;
+  let terminated = false;
+  return {
+    runModel: async (inputs, outputs) => {
+      if (terminated) {
+        throw new Error("Async model runner has already been terminated");
+      } else if (running) {
+        throw new Error("Async model runner only supports one `runModel` call at a time");
+      } else {
+        running = true;
+      }
+      const runTimeLengthInElements = 1;
+      const runTimeLengthInBytes = runTimeLengthInElements * 8;
+      const inputsLengthInElements = inputs.length;
+      const inputsLengthInBytes = inputsLengthInElements * 8;
+      const inputsArray = new Float64Array(ioBuffer, runTimeLengthInBytes, inputsLengthInElements);
+      for (let i = 0; i < inputs.length; i++) {
+        inputsArray[i] = inputs[i].get();
+      }
+      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);
+      return outputs;
+    },
+    terminate: () => {
+      if (terminated) {
+        return Promise.resolve();
+      } else {
+        terminated = true;
+        return Thread.terminate(modelWorker);
+      }
+    }
+  };
+}
+export {
+  spawnAsyncModelRunner
+};
+//# sourceMappingURL=runner.js.map

package/dist/runner.js.map

@@ -0,0 +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":[]}

package/dist/worker.cjs

@@ -0,0 +1,78 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/worker.ts
+var worker_exports = {};
+__export(worker_exports, {
+  exposeModelWorker: () => exposeModelWorker
+});
+module.exports = __toCommonJS(worker_exports);
+var import_worker = require("threads/worker");
+var import_runtime = require("@sdeverywhere/runtime");
+var initWasmModel;
+var wasmModel;
+var inputsWasmBuffer;
+var outputsWasmBuffer;
+var 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 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 ioBuffer = ioArray.buffer;
+    return (0, import_worker.Transfer)({ rowLength, ioBuffer }, [ioBuffer]);
+  },
+  runModel(ioBuffer) {
+    if (!wasmModel) {
+      throw new Error("WasmModel must be initialized before running the model in worker");
+    }
+    const runTimeLengthInElements = 1;
+    const runTimeLengthInBytes = runTimeLengthInElements * 8;
+    const inputsWasmArray = inputsWasmBuffer.getArrayView();
+    const inputsLengthInElements = inputsWasmArray.length;
+    const inputsLengthInBytes = inputsLengthInElements * 8;
+    const inputsBufferArray = new Float64Array(ioBuffer, runTimeLengthInBytes, inputsLengthInElements);
+    inputsWasmArray.set(inputsBufferArray);
+    const t0 = (0, import_runtime.perfNow)();
+    wasmModel.runModel(inputsWasmBuffer, outputsWasmBuffer);
+    const elapsed = (0, import_runtime.perfElapsed)(t0);
+    const runTimeBufferArray = new Float64Array(ioBuffer, 0, runTimeLengthInElements);
+    runTimeBufferArray[0] = elapsed;
+    const outputsOffsetInBytes = runTimeLengthInBytes + inputsLengthInBytes;
+    const outputsBufferArray = new Float64Array(ioBuffer, outputsOffsetInBytes);
+    outputsBufferArray.set(outputsWasmBuffer.getArrayView());
+    return (0, import_worker.Transfer)(ioBuffer);
+  }
+};
+function exposeModelWorker(init) {
+  initWasmModel = init;
+  (0, import_worker.expose)(modelWorker);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  exposeModelWorker
+});
+//# sourceMappingURL=worker.cjs.map

package/dist/worker.cjs.map

@@ -0,0 +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":[]}

package/dist/worker.d.ts

@@ -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

@@ -0,0 +1,54 @@
+// src/worker.ts
+import { expose, Transfer } from "threads/worker";
+import { perfElapsed, perfNow } from "@sdeverywhere/runtime";
+var initWasmModel;
+var wasmModel;
+var inputsWasmBuffer;
+var outputsWasmBuffer;
+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 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 ioBuffer = ioArray.buffer;
+    return Transfer({ rowLength, ioBuffer }, [ioBuffer]);
+  },
+  runModel(ioBuffer) {
+    if (!wasmModel) {
+      throw new Error("WasmModel must be initialized before running the model in worker");
+    }
+    const runTimeLengthInElements = 1;
+    const runTimeLengthInBytes = runTimeLengthInElements * 8;
+    const inputsWasmArray = inputsWasmBuffer.getArrayView();
+    const inputsLengthInElements = inputsWasmArray.length;
+    const inputsLengthInBytes = inputsLengthInElements * 8;
+    const inputsBufferArray = new Float64Array(ioBuffer, runTimeLengthInBytes, inputsLengthInElements);
+    inputsWasmArray.set(inputsBufferArray);
+    const t0 = perfNow();
+    wasmModel.runModel(inputsWasmBuffer, outputsWasmBuffer);
+    const elapsed = perfElapsed(t0);
+    const runTimeBufferArray = new Float64Array(ioBuffer, 0, runTimeLengthInElements);
+    runTimeBufferArray[0] = elapsed;
+    const outputsOffsetInBytes = runTimeLengthInBytes + inputsLengthInBytes;
+    const outputsBufferArray = new Float64Array(ioBuffer, outputsOffsetInBytes);
+    outputsBufferArray.set(outputsWasmBuffer.getArrayView());
+    return Transfer(ioBuffer);
+  }
+};
+function exposeModelWorker(init) {
+  initWasmModel = init;
+  expose(modelWorker);
+}
+export {
+  exposeModelWorker
+};
+//# sourceMappingURL=worker.js.map

package/dist/worker.js.map

@@ -0,0 +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":[]}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@sdeverywhere/runtime-async",
+  "version": "0.1.0",
+  "files": [
+    "dist/**"
+  ],
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./runner": {
+      "types": "./dist/runner.d.ts",
+      "import": "./dist/runner.js",
+      "require": "./dist/runner.cjs"
+    },
+    "./worker": {
+      "types": "./dist/worker.d.ts",
+      "import": "./dist/worker.js",
+      "require": "./dist/worker.cjs"
+    }
+  },
+  "dependencies": {
+    "@sdeverywhere/runtime": "^0.1.0",
+    "threads": "1.7.0"
+  },
+  "author": "Climate Interactive",
+  "license": "MIT",
+  "homepage": "https://sdeverywhere.org",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/climateinteractive/SDEverywhere.git",
+    "directory": "packages/runtime-async"
+  },
+  "bugs": {
+    "url": "https://github.com/climateinteractive/SDEverywhere/issues"
+  },
+  "scripts": {
+    "clean": "rm -rf dist",
+    "lint": "eslint src --ext .ts --max-warnings 0",
+    "prettier:check": "prettier --check .",
+    "prettier:fix": "prettier --write .",
+    "precommit": "../../scripts/precommit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:ci": "vitest run",
+    "type-check": "tsc --noEmit -p tsconfig-build.json",
+    "build": "tsup",
+    "docs": "../../scripts/gen-docs.js",
+    "ci:build": "run-s clean lint prettier:check type-check build test:ci docs"
+  }
+}