@sdeverywhere/runtime-async 0.2.9 → 0.2.11

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-export { spawnAsyncModelRunner } from './runner.js';
-export { exposeModelWorker } from './worker.js';
-import '@sdeverywhere/runtime';
+import { n as WorkerSpec, t as spawnAsyncModelRunner } from "./runner-DcPcKf0C.js";
+import { exposeModelWorker } from "./worker.js";
+export { type WorkerSpec, exposeModelWorker, spawnAsyncModelRunner };

package/dist/index.js

@@ -1,91 +1,3 @@
-// src/runner.ts
-import { BlobWorker, spawn, Thread, Transfer, Worker } from "threads";
-import { BufferedRunModelParams, ModelListing, Outputs } from "@sdeverywhere/runtime";
-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 modelListing = initResult.modelListing ? new ModelListing(initResult.modelListing) : void 0;
-  const params2 = new BufferedRunModelParams(modelListing);
-  let running = false;
-  let terminated = false;
-  return {
-    createOutputs: () => {
-      return new Outputs(initResult.outputVarIds, initResult.startTime, initResult.endTime, initResult.saveFreq);
-    },
-    runModel: async (inputs, outputs, options) => {
-      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;
-      }
-      params2.updateFromParams(inputs, outputs, options);
-      let ioBuffer;
-      try {
-        ioBuffer = await modelWorker2.runModel(Transfer(params2.getEncodedBuffer()));
-      } finally {
-        running = false;
-      }
-      params2.updateFromEncodedBuffer(ioBuffer);
-      params2.finalizeOutputs(outputs);
-      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 { BufferedRunModelParams as BufferedRunModelParams2, createRunnableModel } from "@sdeverywhere/runtime";
-var initGeneratedModel;
-var runnableModel;
-var params = new BufferedRunModelParams2();
-var modelWorker = {
-  async initModel() {
-    if (runnableModel) {
-      throw new Error("RunnableModel was already initialized");
-    }
-    const generatedModel = await initGeneratedModel();
-    runnableModel = createRunnableModel(generatedModel);
-    return {
-      outputVarIds: runnableModel.outputVarIds,
-      modelListing: runnableModel.modelListing,
-      startTime: runnableModel.startTime,
-      endTime: runnableModel.endTime,
-      saveFreq: runnableModel.saveFreq,
-      outputRowLength: runnableModel.numSavePoints
-    };
-  },
-  runModel(ioBuffer) {
-    if (!runnableModel) {
-      throw new Error("RunnableModel must be initialized before running the model in worker");
-    }
-    params.updateFromEncodedBuffer(ioBuffer);
-    runnableModel.runModel(params);
-    return Transfer2(ioBuffer);
-  }
-};
-function exposeModelWorker(init) {
-  initGeneratedModel = init;
-  expose(modelWorker);
-}
-export {
-  exposeModelWorker,
-  spawnAsyncModelRunner
-};
-//# sourceMappingURL=index.js.map
+import { t as spawnAsyncModelRunner } from "./runner-DWs69cGp.js";
+import { t as exposeModelWorker } from "./worker-CVxcTQod.js";
+export { exposeModelWorker, spawnAsyncModelRunner };

package/dist/node-runtime-CQ0b2ThB.js

@@ -0,0 +1,159 @@
+//#region src/worker-rpc/model-worker-rpc.ts
+/** Return whether the message is a model worker request. */
+function isModelWorkerRequest(message) {
+	const kind = message?.kind;
+	return kind === "init" || kind === "run";
+}
+/** Return whether the message is a model worker response. */
+function isModelWorkerResponse(message) {
+	const kind = message?.kind;
+	return kind === "initialized" || kind === "ran" || kind === "error";
+}
+/**
+* Create a client for the model worker connected to the given handle.
+*
+* @param port The handle for the spawned model worker.
+* @returns The model worker client.
+*/
+function createModelWorkerClient(port) {
+	let pending;
+	let terminalError;
+	/** Reject the pending request, without making the client terminal. */
+	function rejectPending(error) {
+		const request = pending;
+		pending = void 0;
+		request?.reject(error);
+	}
+	/** Make the client terminal and reject its pending request. */
+	function fail(error) {
+		if (terminalError === void 0) {
+			terminalError = error;
+			rejectPending(error);
+		}
+	}
+	/** Send one request to the worker and wait for its response. */
+	function send(request, transferables) {
+		if (terminalError !== void 0) return Promise.reject(terminalError);
+		if (pending !== void 0) return Promise.reject(/* @__PURE__ */ new Error("Model worker only supports one request at a time"));
+		const response = new Promise((resolve, reject) => {
+			pending = {
+				resolve,
+				reject
+			};
+		});
+		try {
+			port.postMessage(request, transferables);
+		} catch (error) {
+			rejectPending(error instanceof Error ? error : new Error(String(error)));
+		}
+		return response;
+	}
+	port.onMessage((message) => {
+		if (!isModelWorkerResponse(message)) return;
+		const request = pending;
+		if (request === void 0) return;
+		pending = void 0;
+		if (message.kind === "error") request.reject(new Error(message.message));
+		else request.resolve(message);
+	});
+	port.onError((error) => fail(error));
+	port.onClose((error) => fail(error));
+	/** Make the client terminal with an unexpected-response error and return the error. */
+	function unexpectedResponse(kind, requestName) {
+		const error = /* @__PURE__ */ new Error(`Unexpected '${kind}' response to ${requestName} request`);
+		fail(error);
+		return error;
+	}
+	return {
+		async initModel() {
+			const response = await send({ kind: "init" });
+			if (response.kind !== "initialized") throw unexpectedResponse(response.kind, "model initialization");
+			return response.result;
+		},
+		async runModel(buffer) {
+			const response = await send({
+				kind: "run",
+				buffer
+			}, [buffer]);
+			if (response.kind !== "ran") throw unexpectedResponse(response.kind, "model run");
+			return response.buffer;
+		},
+		dispose(error) {
+			fail(error);
+		}
+	};
+}
+/**
+* Serve model worker requests received on the given port.
+*
+* @param port The port connected to the runner.
+* @param methods The model worker operations.
+*/
+function serveModelWorker(port, methods) {
+	port.onMessage((message) => {
+		if (!isModelWorkerRequest(message)) return;
+		const request = message;
+		/** Handle the received request and post its response. */
+		async function handleRequest() {
+			try {
+				if (request.kind === "init") {
+					const result = await methods.initModel();
+					port.postMessage({
+						kind: "initialized",
+						result
+					});
+				} else {
+					const buffer = await methods.runModel(request.buffer);
+					port.postMessage({
+						kind: "ran",
+						buffer
+					}, [buffer]);
+				}
+			} catch (error) {
+				const errorMessage = error instanceof Error ? error.message : String(error);
+				try {
+					port.postMessage({
+						kind: "error",
+						message: errorMessage
+					});
+				} catch {}
+			}
+		}
+		handleRequest();
+	});
+}
+//#endregion
+//#region src/worker-rpc/node-runtime.ts
+/**
+* Return the Node.js `process` object, or undefined if not running in Node.js.
+* @hidden
+*/
+function nodeProcess() {
+	const process = globalThis.process;
+	return process?.versions?.node !== void 0 ? process : void 0;
+}
+/**
+* Return true if the current context is running in a Node.js environment (as
+* opposed to a browser environment).
+* @hidden
+*/
+function isNodeEnvironment() {
+	return nodeProcess() !== void 0;
+}
+/**
+* Return the `node:worker_threads` module.
+*
+* @returns The `node:worker_threads` module.
+* @throws An error if the module cannot be accessed (for example, when running
+* in a version of Node.js that does not support `process.getBuiltinModule`).
+* @hidden
+*/
+function nodeWorkerThreads() {
+	const getBuiltinModule = nodeProcess()?.getBuiltinModule;
+	if (getBuiltinModule === void 0) throw new Error("Failed to access the `node:worker_threads` module; @sdeverywhere/runtime-async requires Node.js 22.3 or later");
+	return getBuiltinModule("node:worker_threads");
+}
+//#endregion
+export { serveModelWorker as i, nodeWorkerThreads as n, createModelWorkerClient as r, isNodeEnvironment as t };
+
+//# sourceMappingURL=node-runtime-CQ0b2ThB.js.map

package/dist/node-runtime-CQ0b2ThB.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-runtime-CQ0b2ThB.js","names":[],"sources":["../src/worker-rpc/model-worker-rpc.ts","../src/worker-rpc/node-runtime.ts"],"sourcesContent":["// Copyright (c) 2026 Climate Interactive / New Venture Fund\n\nimport type { WorkerHandle, WorkerPort } from './worker-port'\n\n/** The model metadata returned after the worker initializes the model. */\nexport interface InitResult {\n  /** The IDs of the output variables, in output-buffer order. */\n  outputVarIds: string[]\n  /** The model listing, if it was included in the generated model. */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  modelListing?: /*ModelListingSpecs*/ any\n  /** The start time of the model. */\n  startTime: number\n  /** The end time of the model. */\n  endTime: number\n  /** The frequency at which output values are saved. */\n  saveFreq: number\n}\n\n/** A request sent from the runner to the model worker. */\ntype ModelWorkerRequest = { kind: 'init' } | { kind: 'run'; buffer: ArrayBuffer }\n\n/** A response sent from the model worker to the runner. */\ntype ModelWorkerResponse =\n  | { kind: 'initialized'; result: InitResult }\n  | { kind: 'ran'; buffer: ArrayBuffer }\n  | { kind: 'error'; message: string }\n\n/** The operations that can be performed by the model worker. */\nexport interface ModelWorkerMethods {\n  /** Initialize the model and return its metadata. */\n  initModel(): InitResult | Promise<InitResult>\n  /** Run the model using the parameters encoded in the given buffer. */\n  runModel(buffer: ArrayBuffer): ArrayBuffer | Promise<ArrayBuffer>\n}\n\n/** A client for the operations exposed by the model worker. */\nexport interface ModelWorkerClient {\n  /** Initialize the model and return its metadata. */\n  initModel(): Promise<InitResult>\n  /** Run the model using the parameters encoded in the given buffer. */\n  runModel(buffer: ArrayBuffer): Promise<ArrayBuffer>\n  /** Make the client terminal and reject its pending request. */\n  dispose(error: Error): void\n}\n\n/** The callbacks for the single request that is currently pending. */\ninterface PendingRequest {\n  /** Resolve the request with a worker response. */\n  resolve(response: ModelWorkerResponse): void\n  /** Reject the request with an error. */\n  reject(error: Error): void\n}\n\n/** Return whether the message is a model worker request. */\nfunction isModelWorkerRequest(message: unknown): message is ModelWorkerRequest {\n  const kind = (message as Partial<ModelWorkerRequest>)?.kind\n  return kind === 'init' || kind === 'run'\n}\n\n/** Return whether the message is a model worker response. */\nfunction isModelWorkerResponse(message: unknown): message is ModelWorkerResponse {\n  const kind = (message as Partial<ModelWorkerResponse>)?.kind\n  return kind === 'initialized' || kind === 'ran' || kind === 'error'\n}\n\n/**\n * Create a client for the model worker connected to the given handle.\n *\n * @param port The handle for the spawned model worker.\n * @returns The model worker client.\n */\nexport function createModelWorkerClient(port: WorkerHandle): ModelWorkerClient {\n  let pending: PendingRequest | undefined\n  let terminalError: Error | undefined\n\n  /** Reject the pending request, without making the client terminal. */\n  function rejectPending(error: Error): void {\n    const request = pending\n    pending = undefined\n    request?.reject(error)\n  }\n\n  /** Make the client terminal and reject its pending request. */\n  function fail(error: Error): void {\n    if (terminalError === undefined) {\n      terminalError = error\n      rejectPending(error)\n    }\n  }\n\n  /** Send one request to the worker and wait for its response. */\n  function send(request: ModelWorkerRequest, transferables?: Transferable[]): Promise<ModelWorkerResponse> {\n    if (terminalError !== undefined) {\n      return Promise.reject(terminalError)\n    }\n    if (pending !== undefined) {\n      return Promise.reject(new Error('Model worker only supports one request at a time'))\n    }\n\n    const response = new Promise<ModelWorkerResponse>((resolve, reject) => {\n      pending = { resolve, reject }\n    })\n    try {\n      port.postMessage(request, transferables)\n    } catch (error) {\n      rejectPending(error instanceof Error ? error : new Error(String(error)))\n    }\n    return response\n  }\n\n  port.onMessage(message => {\n    if (!isModelWorkerResponse(message)) {\n      return\n    }\n\n    const request = pending\n    if (request === undefined) {\n      return\n    }\n    pending = undefined\n\n    if (message.kind === 'error') {\n      request.reject(new Error(message.message))\n    } else {\n      request.resolve(message)\n    }\n  })\n  port.onError(error => fail(error))\n  port.onClose(error => fail(error))\n\n  /** Make the client terminal with an unexpected-response error and return the error. */\n  function unexpectedResponse(kind: string, requestName: string): Error {\n    // A response that does not match its request means the protocol state is\n    // corrupt, so make the client terminal rather than allow further requests\n    const error = new Error(`Unexpected '${kind}' response to ${requestName} request`)\n    fail(error)\n    return error\n  }\n\n  return {\n    async initModel(): Promise<InitResult> {\n      const response = await send({ kind: 'init' })\n      if (response.kind !== 'initialized') {\n        throw unexpectedResponse(response.kind, 'model initialization')\n      }\n      return response.result\n    },\n\n    async runModel(buffer: ArrayBuffer): Promise<ArrayBuffer> {\n      const response = await send({ kind: 'run', buffer }, [buffer])\n      if (response.kind !== 'ran') {\n        throw unexpectedResponse(response.kind, 'model run')\n      }\n      return response.buffer\n    },\n\n    dispose(error: Error): void {\n      fail(error)\n    }\n  }\n}\n\n/**\n * Serve model worker requests received on the given port.\n *\n * @param port The port connected to the runner.\n * @param methods The model worker operations.\n */\nexport function serveModelWorker(port: WorkerPort, methods: ModelWorkerMethods): void {\n  port.onMessage(message => {\n    if (!isModelWorkerRequest(message)) {\n      return\n    }\n    const request = message\n\n    /** Handle the received request and post its response. */\n    async function handleRequest(): Promise<void> {\n      try {\n        if (request.kind === 'init') {\n          const result = await methods.initModel()\n          port.postMessage({ kind: 'initialized', result } satisfies ModelWorkerResponse)\n        } else {\n          const buffer = await methods.runModel(request.buffer)\n          port.postMessage({ kind: 'ran', buffer } satisfies ModelWorkerResponse, [buffer])\n        }\n      } catch (error) {\n        const errorMessage = error instanceof Error ? error.message : String(error)\n        try {\n          port.postMessage({ kind: 'error', message: errorMessage } satisfies ModelWorkerResponse)\n        } catch {\n          // Nothing more can be done if the error response also cannot be posted\n          // (for example, when the port is already closed); swallow the failure\n          // rather than crash the worker with an unhandled rejection.  The runner\n          // side will observe the problem through worker error/exit events.\n        }\n      }\n    }\n\n    void handleRequest()\n  })\n}\n","// Copyright (c) 2026 Climate Interactive / New Venture Fund\n\n//\n// This module provides access to the Node.js APIs that are needed to run the model\n// in a worker thread.  Note that we deliberately avoid a static (or dynamic) import\n// of `node:worker_threads` here, and instead use `process.getBuiltinModule`, which\n// is a plain property access that bundlers do not need to resolve.  This allows a\n// single bundle to work in both browser and Node.js environments without any\n// bundler-specific configuration or polyfills.\n//\n// Note also that we declare only the small structural subset of the Node.js API\n// that we actually use, so that this package does not depend on `@types/node`.\n//\n\n/**\n * The subset of the Node.js `MessagePort` API that is used by this package.\n * @hidden\n */\nexport interface NodeMessagePort {\n  postMessage(message: unknown, transferList?: Transferable[]): void\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  on(event: string, listener: (arg: any) => void): void\n}\n\n/**\n * The subset of the Node.js `Worker` API that is used by this package.\n * @hidden\n */\nexport interface NodeWorker extends NodeMessagePort {\n  terminate(): Promise<number>\n}\n\n/**\n * The subset of the `node:worker_threads` module that is used by this package.\n * @hidden\n */\nexport interface NodeWorkerThreads {\n  Worker: new (source: string | URL, options?: { eval?: boolean }) => NodeWorker\n  parentPort?: NodeMessagePort\n}\n\n/**\n * The subset of the Node.js `process` object that is used by this package.\n * @hidden\n */\ninterface NodeProcess {\n  versions?: { node?: string }\n  getBuiltinModule?(id: string): unknown\n}\n\n/**\n * Return the Node.js `process` object, or undefined if not running in Node.js.\n * @hidden\n */\nfunction nodeProcess(): NodeProcess | undefined {\n  const process = (globalThis as { process?: NodeProcess }).process\n  return process?.versions?.node !== undefined ? process : undefined\n}\n\n/**\n * Return true if the current context is running in a Node.js environment (as\n * opposed to a browser environment).\n * @hidden\n */\nexport function isNodeEnvironment(): boolean {\n  return nodeProcess() !== undefined\n}\n\n/**\n * Return the `node:worker_threads` module.\n *\n * @returns The `node:worker_threads` module.\n * @throws An error if the module cannot be accessed (for example, when running\n * in a version of Node.js that does not support `process.getBuiltinModule`).\n * @hidden\n */\nexport function nodeWorkerThreads(): NodeWorkerThreads {\n  const getBuiltinModule = nodeProcess()?.getBuiltinModule\n  if (getBuiltinModule === undefined) {\n    throw new Error(\n      'Failed to access the `node:worker_threads` module; @sdeverywhere/runtime-async requires Node.js 22.3 or later'\n    )\n  }\n  return getBuiltinModule('node:worker_threads') as NodeWorkerThreads\n}\n"],"mappings":"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"}

package/dist/runner-DWs69cGp.js

@@ -0,0 +1,165 @@
+import { n as nodeWorkerThreads, r as createModelWorkerClient, t as isNodeEnvironment } from "./node-runtime-CQ0b2ThB.js";
+import { BufferedRunModelParams, ModelListing, Outputs } from "@sdeverywhere/runtime";
+//#region src/worker-rpc/spawn-worker.ts
+/**
+* Adapt the given Web Worker to the `WorkerHandle` interface.
+*
+* @param worker The Web Worker instance.
+* @param onTerminate An optional function that is called after the worker is terminated.
+* @returns The handle for the given worker.
+* @hidden For internal use only.
+*/
+function portForWebWorker(worker, onTerminate) {
+	return {
+		postMessage: (message, transferables) => worker.postMessage(message, transferables ?? []),
+		onMessage: (handler) => worker.addEventListener("message", (event) => handler(event.data)),
+		onError: (handler) => {
+			worker.addEventListener("error", (event) => handler(event.error ?? new Error(event.message)));
+			worker.addEventListener("messageerror", () => {
+				handler(/* @__PURE__ */ new Error("Failed to deserialize message received from worker"));
+			});
+		},
+		onClose: () => void 0,
+		terminate: () => {
+			worker.terminate();
+			onTerminate?.();
+			return Promise.resolve();
+		}
+	};
+}
+/**
+* Adapt the given Node.js worker to the `WorkerHandle` interface.
+*
+* @param worker The Node.js worker instance.
+* @returns The handle for the given worker.
+* @hidden For internal use only.
+*/
+function portForNodeWorker(worker) {
+	return {
+		postMessage: (message, transferables) => worker.postMessage(message, transferables ?? []),
+		onMessage: (handler) => worker.on("message", handler),
+		onError: (handler) => {
+			worker.on("error", handler);
+			worker.on("messageerror", handler);
+		},
+		onClose: (handler) => {
+			worker.on("exit", (exitCode) => handler(/* @__PURE__ */ new Error(`Worker exited with code ${exitCode}`)));
+		},
+		terminate: async () => {
+			await worker.terminate();
+		}
+	};
+}
+/**
+* Spawn a worker for the given spec.  This uses a Web Worker when running in a
+* browser environment, or a `worker_threads` worker when running in a Node.js
+* environment.
+*
+* @param spec Either a `path` to the worker JavaScript file, or the `source`
+* containing the full JavaScript source of the worker.
+* @returns The handle for the spawned worker.
+* @hidden For internal use only.
+*/
+function spawnWorker(spec) {
+	if (isNodeEnvironment()) {
+		const { Worker } = nodeWorkerThreads();
+		if ("source" in spec) return portForNodeWorker(new Worker(spec.source, { eval: true }));
+		else return portForNodeWorker(new Worker(spec.path));
+	} else if ("source" in spec) {
+		const blob = new Blob([spec.source], { type: "text/javascript" });
+		const url = URL.createObjectURL(blob);
+		return portForWebWorker(new Worker(url), () => URL.revokeObjectURL(url));
+	} else return portForWebWorker(new Worker(spec.path));
+}
+//#endregion
+//#region src/runner.ts
+/**
+* Initialize a `ModelRunner` that runs the model asynchronously in a worker
+* (a Web Worker when running in a browser environment, or a worker thread
+* when running in a Node.js environment).
+*
+* In your app project, define a JavaScript file, called `worker.js` for example,
+* that initializes the generated model in the context of a worker thread:
+*
+* ```js
+* import { exposeModelWorker } from '@sdeverywhere/runtime-async/worker'
+* import loadGeneratedModel from './sde-prep/generated-model.js'
+*
+* exposeModelWorker(loadGeneratedModel)
+* ```
+*
+* Then, in your web app, call the `spawnAsyncModelRunner` function, which
+* will spawn the worker thread and initialize the `ModelRunner` that communicates
+* with the worker:
+*
+* ```js
+* import { spawnAsyncModelRunner } from '@sdeverywhere/runtime-async/runner'
+*
+* async function initApp() {
+*   // ...
+*   const runner = await spawnAsyncModelRunner({ path: './worker.js' })
+*   // ...
+* }
+* ```
+*
+* The returned promise rejects if the worker fails to initialize the model or
+* exits unexpectedly.
+*
+* @param workerSpec Either a `path` to the worker JavaScript file, or the `source`
+* containing the full JavaScript source of the worker.
+*/
+async function spawnAsyncModelRunner(workerSpec) {
+	return spawnAsyncModelRunnerWithWorker(spawnWorker(workerSpec));
+}
+/**
+* @hidden For internal use only
+*/
+async function spawnAsyncModelRunnerWithWorker(worker) {
+	const client = createModelWorkerClient(worker);
+	let initResult;
+	try {
+		initResult = await client.initModel();
+	} catch (error) {
+		try {
+			await worker.terminate();
+		} catch {}
+		throw error;
+	}
+	const modelListing = initResult.modelListing ? new ModelListing(initResult.modelListing) : void 0;
+	const params = new BufferedRunModelParams(modelListing);
+	let running = false;
+	let terminated = false;
+	return {
+		createOutputs: () => {
+			return new Outputs(initResult.outputVarIds, initResult.startTime, initResult.endTime, initResult.saveFreq);
+		},
+		runModel: async (inputs, outputs, options) => {
+			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;
+			params.updateFromParams(inputs, outputs, options);
+			let ioBuffer;
+			try {
+				const buffer = params.getEncodedBuffer();
+				ioBuffer = await client.runModel(buffer);
+			} finally {
+				running = false;
+			}
+			params.updateFromEncodedBuffer(ioBuffer);
+			params.finalizeOutputs(outputs);
+			return outputs;
+		},
+		terminate: () => {
+			if (terminated) return Promise.resolve();
+			else {
+				terminated = true;
+				client.dispose(/* @__PURE__ */ new Error("Async model runner has already been terminated"));
+				return worker.terminate();
+			}
+		}
+	};
+}
+//#endregion
+export { spawnAsyncModelRunner as t };
+
+//# sourceMappingURL=runner-DWs69cGp.js.map

package/dist/runner-DWs69cGp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner-DWs69cGp.js","names":[],"sources":["../src/worker-rpc/spawn-worker.ts","../src/runner.ts"],"sourcesContent":["// Copyright (c) 2026 Climate Interactive / New Venture Fund\n\nimport type { NodeWorker } from './node-runtime'\nimport { isNodeEnvironment, nodeWorkerThreads } from './node-runtime'\nimport type { WorkerHandle } from './worker-port'\n\n/**\n * Specifies the worker to be spawned; either a `path` to the worker JavaScript\n * file, or the `source` containing the full JavaScript source of the worker.\n */\nexport type WorkerSpec = { path: string } | { source: string }\n\n/**\n * The subset of the browser `Worker` API that is used by this package.\n * @hidden\n */\ninterface WebWorker {\n  postMessage(message: unknown, transferables?: Transferable[]): void\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  addEventListener(type: string, listener: (event: any) => void): void\n  terminate(): void\n}\n\n/**\n * Adapt the given Web Worker to the `WorkerHandle` interface.\n *\n * @param worker The Web Worker instance.\n * @param onTerminate An optional function that is called after the worker is terminated.\n * @returns The handle for the given worker.\n * @hidden For internal use only.\n */\nexport function portForWebWorker(worker: WebWorker, onTerminate?: () => void): WorkerHandle {\n  return {\n    postMessage: (message, transferables) => worker.postMessage(message, transferables ?? []),\n\n    onMessage: handler => worker.addEventListener('message', event => handler(event.data)),\n\n    onError: handler => {\n      worker.addEventListener('error', event => handler(event.error ?? new Error(event.message)))\n      // A `messageerror` event fires when a message received from the worker fails\n      // deserialization; report it as an error so that a pending request settles\n      // instead of hanging\n      worker.addEventListener('messageerror', () => {\n        handler(new Error('Failed to deserialize message received from worker'))\n      })\n    },\n\n    // Web Workers do not expose an event when they close themselves (for example,\n    // by calling `self.close()` or by running to completion without installing a\n    // message listener), so unlike the Node adapter, this cannot report an\n    // unexpected close and a pending request would remain unsettled in that case.\n    // This is acceptable because worker scripts are expected to call\n    // `exposeModelWorker`, which installs a message listener that keeps the\n    // worker alive (the scripts generated by `plugin-worker` always do).\n    onClose: () => undefined,\n\n    terminate: () => {\n      worker.terminate()\n      onTerminate?.()\n      return Promise.resolve()\n    }\n  }\n}\n\n/**\n * Adapt the given Node.js worker to the `WorkerHandle` interface.\n *\n * @param worker The Node.js worker instance.\n * @returns The handle for the given worker.\n * @hidden For internal use only.\n */\nexport function portForNodeWorker(worker: NodeWorker): WorkerHandle {\n  return {\n    postMessage: (message, transferables) => worker.postMessage(message, transferables ?? []),\n\n    onMessage: handler => worker.on('message', handler),\n\n    onError: handler => {\n      worker.on('error', handler)\n      // A `messageerror` event fires when a message received from the worker fails\n      // deserialization; report it as an error so that a pending request settles\n      // instead of hanging\n      worker.on('messageerror', handler)\n    },\n\n    onClose: handler => {\n      worker.on('exit', exitCode => handler(new Error(`Worker exited with code ${exitCode}`)))\n    },\n\n    terminate: async () => {\n      await worker.terminate()\n    }\n  }\n}\n\n/**\n * Spawn a worker for the given spec.  This uses a Web Worker when running in a\n * browser environment, or a `worker_threads` worker when running in a Node.js\n * environment.\n *\n * @param spec Either a `path` to the worker JavaScript file, or the `source`\n * containing the full JavaScript source of the worker.\n * @returns The handle for the spawned worker.\n * @hidden For internal use only.\n */\nexport function spawnWorker(spec: WorkerSpec): WorkerHandle {\n  if (isNodeEnvironment()) {\n    const { Worker } = nodeWorkerThreads()\n    if ('source' in spec) {\n      // Note that `eval` mode runs the source as CommonJS, which is compatible with\n      // the `iife` format bundles produced by `plugin-worker`\n      return portForNodeWorker(new Worker(spec.source, { eval: true }))\n    } else {\n      return portForNodeWorker(new Worker(spec.path))\n    }\n  } else {\n    if ('source' in spec) {\n      // Wrap the source in a blob so that it can be loaded as a worker.  Note that we\n      // hold on to the URL and revoke it only after the worker is terminated, since\n      // the worker is not guaranteed to have fetched the source by the time the\n      // `Worker` constructor returns.\n      const blob = new Blob([spec.source], { type: 'text/javascript' })\n      const url = URL.createObjectURL(blob)\n      return portForWebWorker(new Worker(url), () => URL.revokeObjectURL(url))\n    } else {\n      return portForWebWorker(new Worker(spec.path))\n    }\n  }\n}\n","// Copyright (c) 2020-2022 Climate Interactive / New Venture Fund\n\nimport type { ModelRunner } from '@sdeverywhere/runtime'\nimport { BufferedRunModelParams, ModelListing, Outputs } from '@sdeverywhere/runtime'\n\nimport { createModelWorkerClient } from './worker-rpc/model-worker-rpc'\nimport type { InitResult } from './worker-rpc/model-worker-rpc'\nimport type { WorkerSpec } from './worker-rpc/spawn-worker'\nimport { spawnWorker } from './worker-rpc/spawn-worker'\nimport type { WorkerHandle } from './worker-rpc/worker-port'\n\nexport type { WorkerSpec }\n\n/**\n * Initialize a `ModelRunner` that runs the model asynchronously in a worker\n * (a Web Worker when running in a browser environment, or a worker thread\n * when running in a Node.js environment).\n *\n * In your app project, define a JavaScript file, called `worker.js` for example,\n * that initializes the generated model in the context of a worker thread:\n *\n * ```js\n * import { exposeModelWorker } from '@sdeverywhere/runtime-async/worker'\n * import loadGeneratedModel from './sde-prep/generated-model.js'\n *\n * exposeModelWorker(loadGeneratedModel)\n * ```\n *\n * Then, in your web app, call the `spawnAsyncModelRunner` function, which\n * will spawn the worker thread and initialize the `ModelRunner` that communicates\n * with the worker:\n *\n * ```js\n * import { spawnAsyncModelRunner } from '@sdeverywhere/runtime-async/runner'\n *\n * async function initApp() {\n *   // ...\n *   const runner = await spawnAsyncModelRunner({ path: './worker.js' })\n *   // ...\n * }\n * ```\n *\n * The returned promise rejects if the worker fails to initialize the model or\n * exits unexpectedly.\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: WorkerSpec): Promise<ModelRunner> {\n  return spawnAsyncModelRunnerWithWorker(spawnWorker(workerSpec))\n}\n\n/**\n * @hidden For internal use only\n */\nasync function spawnAsyncModelRunnerWithWorker(worker: WorkerHandle): Promise<ModelRunner> {\n  // Create the client that communicates with the `ModelWorker` running in the worker\n  const client = createModelWorkerClient(worker)\n\n  // Wait for the worker to initialize the model (in the worker thread). If\n  // initialization fails, make sure the worker and any associated resources are\n  // released before propagating the original error.\n  let initResult: InitResult\n  try {\n    initResult = await client.initModel()\n  } catch (error) {\n    try {\n      await worker.terminate()\n    } catch {\n      // Preserve the model initialization error if worker termination also fails\n    }\n    throw error\n  }\n\n  // Create a `ModelListing` instance if the listing was defined in the generated model\n  const modelListing = initResult.modelListing ? new ModelListing(initResult.modelListing) : undefined\n\n  // Maintain a `BufferedRunModelParams` instance that holds the I/O parameters\n  const params = new BufferedRunModelParams(modelListing)\n\n  // Use a flag to ensure that only one request is made at a time\n  let running = false\n\n  // Disallow `runModel` after the runner has been terminated\n  let terminated = false\n\n  return {\n    createOutputs: () => {\n      return new Outputs(initResult.outputVarIds, initResult.startTime, initResult.endTime, initResult.saveFreq)\n    },\n\n    runModel: async (inputs, outputs, options) => {\n      if (terminated) {\n        throw new Error('Async model runner has already been terminated')\n      } else if (running) {\n        throw new Error('Async model runner only supports one `runModel` call at a time')\n      } else {\n        running = true\n      }\n\n      // Update the I/O parameters\n      params.updateFromParams(inputs, outputs, options)\n\n      // Run the model in the worker. We transfer the underlying `ArrayBuffer`\n      // instance to the worker to make it no-copy transferable, and then the\n      // worker will transfer it back to us.\n      let ioBuffer: ArrayBuffer\n      try {\n        const buffer = params.getEncodedBuffer()\n        ioBuffer = await client.runModel(buffer)\n      } finally {\n        running = false\n      }\n\n      // Once the buffer is transferred to the worker, the buffer in the\n      // `BufferedRunModelParams` becomes \"detached\" and is no longer usable.\n      // After the buffer is transferred back from the worker, we need to\n      // restore the state of the object to use the new buffer.\n      params.updateFromEncodedBuffer(ioBuffer)\n\n      // Copy the output values and elapsed time from the buffer to the\n      // `Outputs` instance\n      params.finalizeOutputs(outputs)\n\n      return outputs\n    },\n\n    terminate: () => {\n      if (terminated) {\n        return Promise.resolve()\n      } else {\n        terminated = true\n        client.dispose(new Error('Async model runner has already been terminated'))\n        return worker.terminate()\n      }\n    }\n  }\n}\n"],"mappings":"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"}

package/dist/{runner.d.cts → runner-DcPcKf0C.d.ts}

@@ -1,5 +1,16 @@
-import { ModelRunner } from '@sdeverywhere/runtime';
-
+import { ModelRunner } from "@sdeverywhere/runtime";
+//#region src/worker-rpc/spawn-worker.d.ts
+/**
+ * Specifies the worker to be spawned; either a `path` to the worker JavaScript
+ * file, or the `source` containing the full JavaScript source of the worker.
+ */
+type WorkerSpec = {
+  path: string;
+} | {
+  source: string;
+};
+//#endregion
+//#region src/runner.d.ts
 /**
  * Initialize a `ModelRunner` that runs the model asynchronously in a worker
  * (a Web Worker when running in a browser environment, or a worker thread
@@ -29,13 +40,13 @@ import { ModelRunner } from '@sdeverywhere/runtime';
  * }
  * ```
  *
+ * The returned promise rejects if the worker fails to initialize the model or
+ * exits unexpectedly.
+ *
  * @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 };
+declare function spawnAsyncModelRunner(workerSpec: WorkerSpec): Promise<ModelRunner>;
+//#endregion
+export { WorkerSpec as n, spawnAsyncModelRunner as t };
+//# sourceMappingURL=runner-DcPcKf0C.d.ts.map

package/dist/runner-DcPcKf0C.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner-DcPcKf0C.d.ts","names":[],"sources":["../src/worker-rpc/spawn-worker.d.ts","../src/runner.d.ts"],"mappings":";;;;;;KAMY;EACR;;EAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBC6BoB,sBAAsB,YAAY,aAAa,QAAQ"}

package/dist/runner.d.ts

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

package/dist/runner.js

@@ -1,54 +1,2 @@
-// src/runner.ts
-import { BlobWorker, spawn, Thread, Transfer, Worker } from "threads";
-import { BufferedRunModelParams, ModelListing, Outputs } from "@sdeverywhere/runtime";
-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 modelListing = initResult.modelListing ? new ModelListing(initResult.modelListing) : void 0;
-  const params = new BufferedRunModelParams(modelListing);
-  let running = false;
-  let terminated = false;
-  return {
-    createOutputs: () => {
-      return new Outputs(initResult.outputVarIds, initResult.startTime, initResult.endTime, initResult.saveFreq);
-    },
-    runModel: async (inputs, outputs, options) => {
-      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;
-      }
-      params.updateFromParams(inputs, outputs, options);
-      let ioBuffer;
-      try {
-        ioBuffer = await modelWorker.runModel(Transfer(params.getEncodedBuffer()));
-      } finally {
-        running = false;
-      }
-      params.updateFromEncodedBuffer(ioBuffer);
-      params.finalizeOutputs(outputs);
-      return outputs;
-    },
-    terminate: () => {
-      if (terminated) {
-        return Promise.resolve();
-      } else {
-        terminated = true;
-        return Thread.terminate(modelWorker);
-      }
-    }
-  };
-}
-export {
-  spawnAsyncModelRunner
-};
-//# sourceMappingURL=runner.js.map
+import { t as spawnAsyncModelRunner } from "./runner-DWs69cGp.js";
+export { spawnAsyncModelRunner };

package/dist/worker-CVxcTQod.js

@@ -0,0 +1,97 @@
+import { i as serveModelWorker, n as nodeWorkerThreads, t as isNodeEnvironment } from "./node-runtime-CQ0b2ThB.js";
+import { BufferedRunModelParams, createRunnableModel } from "@sdeverywhere/runtime";
+//#region src/worker-rpc/parent-port.ts
+/**
+* Adapt the `parentPort` from `node:worker_threads` to the `WorkerPort` interface.
+*
+* @param parentPort The port that is connected to the parent (runner) thread.
+* @returns The port for communicating with the runner.
+* @hidden For internal use only.
+*/
+function portForNodeParentPort(parentPort) {
+	return {
+		postMessage: (message, transferables) => parentPort.postMessage(message, transferables ?? []),
+		onMessage: (handler) => parentPort.on("message", handler)
+	};
+}
+/**
+* Adapt the global scope of a Web Worker to the `WorkerPort` interface.
+*
+* @param scope The global scope of the Web Worker.
+* @returns The port for communicating with the runner.
+* @hidden For internal use only.
+*/
+function portForWorkerGlobalScope(scope) {
+	return {
+		postMessage: (message, transferables) => scope.postMessage(message, transferables ?? []),
+		onMessage: (handler) => scope.addEventListener("message", (event) => handler(event.data))
+	};
+}
+/**
+* Return the port that connects this worker to the runner running in the main thread.
+*
+* @returns The port for communicating with the runner.
+* @throws An error if the current context is not a worker.
+* @hidden For internal use only.
+*/
+function parentWorkerPort() {
+	if (isNodeEnvironment()) {
+		const { parentPort } = nodeWorkerThreads();
+		if (parentPort === void 0) throw new Error("The `exposeModelWorker` function must be called from a worker thread");
+		return portForNodeParentPort(parentPort);
+	} else {
+		const scope = globalThis;
+		if ("document" in globalThis || typeof scope.postMessage !== "function") throw new Error("The `exposeModelWorker` function must be called from a worker thread");
+		return portForWorkerGlobalScope(scope);
+	}
+}
+//#endregion
+//#region src/worker.ts
+/** @hidden */
+let initGeneratedModel;
+/** @hidden */
+let runnableModel;
+/**
+* Maintain a `BufferedRunModelParams` instance that wraps the transferable buffer
+* containing the I/O parameters.
+* @hidden
+*/
+const params = new BufferedRunModelParams();
+/** @hidden */
+const modelWorker = {
+	async initModel() {
+		if (runnableModel) throw new Error("RunnableModel was already initialized");
+		const generatedModel = await initGeneratedModel();
+		runnableModel = createRunnableModel(generatedModel);
+		return {
+			outputVarIds: runnableModel.outputVarIds,
+			modelListing: runnableModel.modelListing,
+			startTime: runnableModel.startTime,
+			endTime: runnableModel.endTime,
+			saveFreq: runnableModel.saveFreq
+		};
+	},
+	runModel(ioBuffer) {
+		if (!runnableModel) throw new Error("RunnableModel must be initialized before running the model in worker");
+		params.updateFromEncodedBuffer(ioBuffer);
+		runnableModel.runModel(params);
+		return ioBuffer;
+	}
+};
+/**
+* Expose an object in the current worker thread that communicates with the
+* `ModelRunner` instance running in the main thread.  The exposed worker
+* object will take care of running the model on the worker thread and
+* sending the outputs back to the main thread.
+*
+* @param init The function that initializes the generated model instance that
+* is used in the worker thread.
+*/
+function exposeModelWorker(init) {
+	initGeneratedModel = init;
+	serveModelWorker(parentWorkerPort(), modelWorker);
+}
+//#endregion
+export { exposeModelWorker as t };
+
+//# sourceMappingURL=worker-CVxcTQod.js.map

package/dist/worker-CVxcTQod.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-CVxcTQod.js","names":[],"sources":["../src/worker-rpc/parent-port.ts","../src/worker.ts"],"sourcesContent":["// Copyright (c) 2026 Climate Interactive / New Venture Fund\n\nimport type { NodeMessagePort } from './node-runtime'\nimport { isNodeEnvironment, nodeWorkerThreads } from './node-runtime'\nimport type { WorkerPort } from './worker-port'\n\n/**\n * The subset of the Web Worker global scope API that is used by this package.\n * @hidden\n */\ninterface WorkerGlobalScope {\n  postMessage(message: unknown, transferables?: Transferable[]): void\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  addEventListener(type: string, listener: (event: any) => void): void\n}\n\n/**\n * Adapt the `parentPort` from `node:worker_threads` to the `WorkerPort` interface.\n *\n * @param parentPort The port that is connected to the parent (runner) thread.\n * @returns The port for communicating with the runner.\n * @hidden For internal use only.\n */\nexport function portForNodeParentPort(parentPort: NodeMessagePort): WorkerPort {\n  return {\n    postMessage: (message, transferables) => parentPort.postMessage(message, transferables ?? []),\n\n    onMessage: handler => parentPort.on('message', handler)\n  }\n}\n\n/**\n * Adapt the global scope of a Web Worker to the `WorkerPort` interface.\n *\n * @param scope The global scope of the Web Worker.\n * @returns The port for communicating with the runner.\n * @hidden For internal use only.\n */\nexport function portForWorkerGlobalScope(scope: WorkerGlobalScope): WorkerPort {\n  return {\n    postMessage: (message, transferables) => scope.postMessage(message, transferables ?? []),\n\n    onMessage: handler => scope.addEventListener('message', event => handler(event.data))\n  }\n}\n\n/**\n * Return the port that connects this worker to the runner running in the main thread.\n *\n * @returns The port for communicating with the runner.\n * @throws An error if the current context is not a worker.\n * @hidden For internal use only.\n */\nexport function parentWorkerPort(): WorkerPort {\n  if (isNodeEnvironment()) {\n    const { parentPort } = nodeWorkerThreads()\n    if (parentPort === undefined) {\n      throw new Error('The `exposeModelWorker` function must be called from a worker thread')\n    }\n    return portForNodeParentPort(parentPort)\n  } else {\n    const scope = globalThis as unknown as WorkerGlobalScope\n    if ('document' in globalThis || typeof scope.postMessage !== 'function') {\n      throw new Error('The `exposeModelWorker` function must be called from a worker thread')\n    }\n    return portForWorkerGlobalScope(scope)\n  }\n}\n","// Copyright (c) 2020-2022 Climate Interactive / New Venture Fund\n\nimport type { GeneratedModel, RunnableModel } from '@sdeverywhere/runtime'\nimport { BufferedRunModelParams, createRunnableModel } from '@sdeverywhere/runtime'\n\nimport type { InitResult, ModelWorkerMethods } from './worker-rpc/model-worker-rpc'\nimport { serveModelWorker } from './worker-rpc/model-worker-rpc'\nimport { parentWorkerPort } from './worker-rpc/parent-port'\n\n/** @hidden */\nlet initGeneratedModel: () => Promise<GeneratedModel>\n\n/** @hidden */\nlet runnableModel: RunnableModel\n\n/**\n * Maintain a `BufferedRunModelParams` instance that wraps the transferable buffer\n * containing the I/O parameters.\n * @hidden\n */\nconst params = new BufferedRunModelParams()\n\n/** @hidden */\nconst modelWorker: ModelWorkerMethods = {\n  async initModel(): Promise<InitResult> {\n    if (runnableModel) {\n      throw new Error('RunnableModel was already initialized')\n    }\n\n    // Initialize the runnable model\n    const generatedModel = await initGeneratedModel()\n    runnableModel = createRunnableModel(generatedModel)\n\n    // Transfer the model metadata to the runner\n    return {\n      outputVarIds: runnableModel.outputVarIds,\n      modelListing: runnableModel.modelListing,\n      startTime: runnableModel.startTime,\n      endTime: runnableModel.endTime,\n      saveFreq: runnableModel.saveFreq\n    }\n  },\n\n  runModel(ioBuffer: ArrayBuffer): ArrayBuffer {\n    if (!runnableModel) {\n      throw new Error('RunnableModel must be initialized before running the model in worker')\n    }\n\n    // Update the `BufferedRunModelParams` to use the values in the buffer that was transferred\n    // from the runner to the worker\n    params.updateFromEncodedBuffer(ioBuffer)\n\n    // Run the model synchronously on the worker thread using those I/O parameters\n    runnableModel.runModel(params)\n\n    // Transfer the buffer back to the runner\n    return ioBuffer\n  }\n}\n\n/**\n * Expose an object in the current worker thread that communicates with the\n * `ModelRunner` instance running in the main thread.  The exposed worker\n * object will take care of running the model on the worker thread and\n * sending the outputs back to the main thread.\n *\n * @param init The function that initializes the generated model instance that\n * is used in the worker thread.\n */\nexport function exposeModelWorker(init: () => Promise<GeneratedModel>): void {\n  // Save the initializer, which will be used when the runner calls `initModel`\n  // on the worker\n  initGeneratedModel = init\n\n  // Handle the requests that arrive from the runner in the main thread\n  serveModelWorker(parentWorkerPort(), modelWorker)\n}\n"],"mappings":";;;;;;;;;;AAuBA,SAAgB,sBAAsB,YAAyC;CAC7E,OAAO;EACL,cAAc,SAAS,kBAAkB,WAAW,YAAY,SAAS,iBAAiB,CAAC,CAAC;EAE5F,YAAW,YAAW,WAAW,GAAG,WAAW,OAAO;CACxD;AACF;;;;;;;;AASA,SAAgB,yBAAyB,OAAsC;CAC7E,OAAO;EACL,cAAc,SAAS,kBAAkB,MAAM,YAAY,SAAS,iBAAiB,CAAC,CAAC;EAEvF,YAAW,YAAW,MAAM,iBAAiB,YAAW,UAAS,QAAQ,MAAM,IAAI,CAAC;CACtF;AACF;;;;;;;;AASA,SAAgB,mBAA+B;CAC7C,IAAI,kBAAkB,GAAG;EACvB,MAAM,EAAE,eAAe,kBAAkB;EACzC,IAAI,eAAe,KAAA,GACjB,MAAM,IAAI,MAAM,sEAAsE;EAExF,OAAO,sBAAsB,UAAU;CACzC,OAAO;EACL,MAAM,QAAQ;EACd,IAAI,cAAc,cAAc,OAAO,MAAM,gBAAgB,YAC3D,MAAM,IAAI,MAAM,sEAAsE;EAExF,OAAO,yBAAyB,KAAK;CACvC;AACF;;;;ACzDA,IAAI;;AAGJ,IAAI;;;;;;AAOJ,MAAM,SAAS,IAAI,uBAAuB;;AAG1C,MAAM,cAAkC;CACtC,MAAM,YAAiC;EACrC,IAAI,eACF,MAAM,IAAI,MAAM,uCAAuC;EAIzD,MAAM,iBAAiB,MAAM,mBAAmB;EAChD,gBAAgB,oBAAoB,cAAc;EAGlD,OAAO;GACL,cAAc,cAAc;GAC5B,cAAc,cAAc;GAC5B,WAAW,cAAc;GACzB,SAAS,cAAc;GACvB,UAAU,cAAc;EAC1B;CACF;CAEA,SAAS,UAAoC;EAC3C,IAAI,CAAC,eACH,MAAM,IAAI,MAAM,sEAAsE;EAKxF,OAAO,wBAAwB,QAAQ;EAGvC,cAAc,SAAS,MAAM;EAG7B,OAAO;CACT;AACF;;;;;;;;;;AAWA,SAAgB,kBAAkB,MAA2C;CAG3E,qBAAqB;CAGrB,iBAAiB,iBAAiB,GAAG,WAAW;AAClD"}

package/dist/worker.d.ts

@@ -1,5 +1,5 @@
-import { GeneratedModel } from '@sdeverywhere/runtime';
-
+import { GeneratedModel } from "@sdeverywhere/runtime";
+//#region src/worker.d.ts
 /**
  * Expose an object in the current worker thread that communicates with the
  * `ModelRunner` instance running in the main thread.  The exposed worker
@@ -9,6 +9,6 @@ import { GeneratedModel } from '@sdeverywhere/runtime';
  * @param init The function that initializes the generated model instance that
  * is used in the worker thread.
  */
-declare function exposeModelWorker(init: () => Promise<GeneratedModel>): void;
-
-export { exposeModelWorker };
+export declare function exposeModelWorker(init: () => Promise<GeneratedModel>): void;
+//#endregion
+//# sourceMappingURL=worker.d.ts.map

package/dist/worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.d.ts","names":[],"sources":["../src/worker.d.ts"],"mappings":";;;;;;;;;;;wBAUwB,kBAAkB,YAAY,QAAQ"}

package/dist/worker.js

@@ -1,39 +1,2 @@
-// src/worker.ts
-import { expose, Transfer } from "threads/worker";
-import { BufferedRunModelParams, createRunnableModel } from "@sdeverywhere/runtime";
-var initGeneratedModel;
-var runnableModel;
-var params = new BufferedRunModelParams();
-var modelWorker = {
-  async initModel() {
-    if (runnableModel) {
-      throw new Error("RunnableModel was already initialized");
-    }
-    const generatedModel = await initGeneratedModel();
-    runnableModel = createRunnableModel(generatedModel);
-    return {
-      outputVarIds: runnableModel.outputVarIds,
-      modelListing: runnableModel.modelListing,
-      startTime: runnableModel.startTime,
-      endTime: runnableModel.endTime,
-      saveFreq: runnableModel.saveFreq,
-      outputRowLength: runnableModel.numSavePoints
-    };
-  },
-  runModel(ioBuffer) {
-    if (!runnableModel) {
-      throw new Error("RunnableModel must be initialized before running the model in worker");
-    }
-    params.updateFromEncodedBuffer(ioBuffer);
-    runnableModel.runModel(params);
-    return Transfer(ioBuffer);
-  }
-};
-function exposeModelWorker(init) {
-  initGeneratedModel = init;
-  expose(modelWorker);
-}
-export {
-  exposeModelWorker
-};
-//# sourceMappingURL=worker.js.map
+import { t as exposeModelWorker } from "./worker-CVxcTQod.js";
+export { exposeModelWorker };

package/package.json

@@ -1,33 +1,34 @@
 {
   "name": "@sdeverywhere/runtime-async",
-  "version": "0.2.9",
+  "version": "0.2.11",
   "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"
+      "import": "./dist/index.js"
     },
     "./runner": {
       "types": "./dist/runner.d.ts",
-      "import": "./dist/runner.js",
-      "require": "./dist/runner.cjs"
+      "import": "./dist/runner.js"
     },
     "./worker": {
       "types": "./dist/worker.d.ts",
-      "import": "./dist/worker.js",
-      "require": "./dist/worker.cjs"
+      "import": "./dist/worker.js"
     }
   },
   "dependencies": {
-    "@sdeverywhere/runtime": "^0.2.9",
-    "threads": "1.7.0"
+    "@sdeverywhere/runtime": "^0.2.11"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.8"
+  },
+  "engines": {
+    "node": ">=22.3"
   },
   "author": "Climate Interactive",
   "license": "MIT",
@@ -50,7 +51,7 @@
     "test:watch": "vitest",
     "test:ci": "vitest run",
     "type-check": "tsc --noEmit -p tsconfig-test.json",
-    "build": "tsup",
+    "build": "tsdown",
     "docs": "../../scripts/gen-docs.js",
     "ci:build": "run-s clean lint prettier:check type-check build test:ci docs"
   }

package/dist/index.cjs

@@ -1,118 +0,0 @@
-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 index_exports = {};
-__export(index_exports, {
-  exposeModelWorker: () => exposeModelWorker,
-  spawnAsyncModelRunner: () => spawnAsyncModelRunner
-});
-module.exports = __toCommonJS(index_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"]));
-  } 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 modelListing = initResult.modelListing ? new import_runtime.ModelListing(initResult.modelListing) : void 0;
-  const params2 = new import_runtime.BufferedRunModelParams(modelListing);
-  let running = false;
-  let terminated = false;
-  return {
-    createOutputs: () => {
-      return new import_runtime.Outputs(initResult.outputVarIds, initResult.startTime, initResult.endTime, initResult.saveFreq);
-    },
-    runModel: async (inputs, outputs, options) => {
-      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;
-      }
-      params2.updateFromParams(inputs, outputs, options);
-      let ioBuffer;
-      try {
-        ioBuffer = await modelWorker2.runModel((0, import_threads.Transfer)(params2.getEncodedBuffer()));
-      } finally {
-        running = false;
-      }
-      params2.updateFromEncodedBuffer(ioBuffer);
-      params2.finalizeOutputs(outputs);
-      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_runtime2 = require("@sdeverywhere/runtime");
-var initGeneratedModel;
-var runnableModel;
-var params = new import_runtime2.BufferedRunModelParams();
-var modelWorker = {
-  async initModel() {
-    if (runnableModel) {
-      throw new Error("RunnableModel was already initialized");
-    }
-    const generatedModel = await initGeneratedModel();
-    runnableModel = (0, import_runtime2.createRunnableModel)(generatedModel);
-    return {
-      outputVarIds: runnableModel.outputVarIds,
-      modelListing: runnableModel.modelListing,
-      startTime: runnableModel.startTime,
-      endTime: runnableModel.endTime,
-      saveFreq: runnableModel.saveFreq,
-      outputRowLength: runnableModel.numSavePoints
-    };
-  },
-  runModel(ioBuffer) {
-    if (!runnableModel) {
-      throw new Error("RunnableModel must be initialized before running the model in worker");
-    }
-    params.updateFromEncodedBuffer(ioBuffer);
-    runnableModel.runModel(params);
-    return (0, import_worker.Transfer)(ioBuffer);
-  }
-};
-function exposeModelWorker(init) {
-  initGeneratedModel = 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

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

package/dist/index.d.cts

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

package/dist/index.js.map

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

package/dist/runner.cjs

@@ -1,78 +0,0 @@
-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");
-var import_runtime = require("@sdeverywhere/runtime");
-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 modelListing = initResult.modelListing ? new import_runtime.ModelListing(initResult.modelListing) : void 0;
-  const params = new import_runtime.BufferedRunModelParams(modelListing);
-  let running = false;
-  let terminated = false;
-  return {
-    createOutputs: () => {
-      return new import_runtime.Outputs(initResult.outputVarIds, initResult.startTime, initResult.endTime, initResult.saveFreq);
-    },
-    runModel: async (inputs, outputs, options) => {
-      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;
-      }
-      params.updateFromParams(inputs, outputs, options);
-      let ioBuffer;
-      try {
-        ioBuffer = await modelWorker.runModel((0, import_threads.Transfer)(params.getEncodedBuffer()));
-      } finally {
-        running = false;
-      }
-      params.updateFromEncodedBuffer(ioBuffer);
-      params.finalizeOutputs(outputs);
-      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

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

package/dist/runner.js.map

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

package/dist/worker.cjs

@@ -1,63 +0,0 @@
-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 initGeneratedModel;
-var runnableModel;
-var params = new import_runtime.BufferedRunModelParams();
-var modelWorker = {
-  async initModel() {
-    if (runnableModel) {
-      throw new Error("RunnableModel was already initialized");
-    }
-    const generatedModel = await initGeneratedModel();
-    runnableModel = (0, import_runtime.createRunnableModel)(generatedModel);
-    return {
-      outputVarIds: runnableModel.outputVarIds,
-      modelListing: runnableModel.modelListing,
-      startTime: runnableModel.startTime,
-      endTime: runnableModel.endTime,
-      saveFreq: runnableModel.saveFreq,
-      outputRowLength: runnableModel.numSavePoints
-    };
-  },
-  runModel(ioBuffer) {
-    if (!runnableModel) {
-      throw new Error("RunnableModel must be initialized before running the model in worker");
-    }
-    params.updateFromEncodedBuffer(ioBuffer);
-    runnableModel.runModel(params);
-    return (0, import_worker.Transfer)(ioBuffer);
-  }
-};
-function exposeModelWorker(init) {
-  initGeneratedModel = 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

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/worker.ts"],"sourcesContent":["// Copyright (c) 2020-2022 Climate Interactive / New Venture Fund\n\nimport type { TransferDescriptor } from 'threads'\nimport { expose, Transfer } from 'threads/worker'\n\nimport type { GeneratedModel, RunnableModel } from '@sdeverywhere/runtime'\nimport { BufferedRunModelParams, createRunnableModel } from '@sdeverywhere/runtime'\n\n/** @hidden */\nlet initGeneratedModel: () => Promise<GeneratedModel>\n\n/** @hidden */\nlet runnableModel: RunnableModel\n\n/**\n * Maintain a `BufferedRunModelParams` instance that wraps the transferable buffer\n * containing the I/O parameters.\n * @hidden\n */\nconst params = new BufferedRunModelParams()\n\ninterface InitResult {\n  outputVarIds: string[]\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  modelListing?: /*ModelListingSpecs*/ any\n  startTime: number\n  endTime: number\n  saveFreq: number\n  outputRowLength: number\n}\n\n/** @hidden */\nconst modelWorker = {\n  async initModel(): Promise<InitResult> {\n    if (runnableModel) {\n      throw new Error('RunnableModel was already initialized')\n    }\n\n    // Initialize the runnable model\n    const generatedModel = await initGeneratedModel()\n    runnableModel = createRunnableModel(generatedModel)\n\n    // Transfer the model metadata to the runner\n    return {\n      outputVarIds: runnableModel.outputVarIds,\n      modelListing: runnableModel.modelListing,\n      startTime: runnableModel.startTime,\n      endTime: runnableModel.endTime,\n      saveFreq: runnableModel.saveFreq,\n      outputRowLength: runnableModel.numSavePoints\n    }\n  },\n\n  runModel(ioBuffer: ArrayBuffer): TransferDescriptor<ArrayBuffer> {\n    if (!runnableModel) {\n      throw new Error('RunnableModel must be initialized before running the model in worker')\n    }\n\n    // Update the `BufferedRunModelParams` to use the values in the buffer that was transferred\n    // from the runner to the worker\n    params.updateFromEncodedBuffer(ioBuffer)\n\n    // Run the model synchronously on the worker thread using those I/O parameters\n    runnableModel.runModel(params)\n\n    // Transfer the buffer back to the runner\n    return Transfer(ioBuffer)\n  }\n}\n\n/**\n * Expose an object in the current worker thread that communicates with the\n * `ModelRunner` instance running in the main thread.  The exposed worker\n * object will take care of running the model on the worker thread and\n * sending the outputs back to the main thread.\n *\n * @param init The function that initializes the generated model instance that\n * is used in the worker thread.\n */\nexport function exposeModelWorker(init: () => Promise<GeneratedModel>): void {\n  // Save the initializer, which will be used when the runner calls `initModel`\n  // on the worker\n  initGeneratedModel = init\n\n  // Expose the worker implementation to `threads.js`\n  expose(modelWorker)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,oBAAiC;AAGjC,qBAA4D;AAG5D,IAAI;AAGJ,IAAI;AAOJ,IAAM,SAAS,IAAI,sCAAuB;AAa1C,IAAM,cAAc;AAAA,EAClB,MAAM,YAAiC;AACrC,QAAI,eAAe;AACjB,YAAM,IAAI,MAAM,uCAAuC;AAAA,IACzD;AAGA,UAAM,iBAAiB,MAAM,mBAAmB;AAChD,wBAAgB,oCAAoB,cAAc;AAGlD,WAAO;AAAA,MACL,cAAc,cAAc;AAAA,MAC5B,cAAc,cAAc;AAAA,MAC5B,WAAW,cAAc;AAAA,MACzB,SAAS,cAAc;AAAA,MACvB,UAAU,cAAc;AAAA,MACxB,iBAAiB,cAAc;AAAA,IACjC;AAAA,EACF;AAAA,EAEA,SAAS,UAAwD;AAC/D,QAAI,CAAC,eAAe;AAClB,YAAM,IAAI,MAAM,sEAAsE;AAAA,IACxF;AAIA,WAAO,wBAAwB,QAAQ;AAGvC,kBAAc,SAAS,MAAM;AAG7B,eAAO,wBAAS,QAAQ;AAAA,EAC1B;AACF;AAWO,SAAS,kBAAkB,MAA2C;AAG3E,uBAAqB;AAGrB,4BAAO,WAAW;AACpB;","names":[]}

package/dist/worker.d.cts

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

package/dist/worker.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/worker.ts"],"sourcesContent":["// Copyright (c) 2020-2022 Climate Interactive / New Venture Fund\n\nimport type { TransferDescriptor } from 'threads'\nimport { expose, Transfer } from 'threads/worker'\n\nimport type { GeneratedModel, RunnableModel } from '@sdeverywhere/runtime'\nimport { BufferedRunModelParams, createRunnableModel } from '@sdeverywhere/runtime'\n\n/** @hidden */\nlet initGeneratedModel: () => Promise<GeneratedModel>\n\n/** @hidden */\nlet runnableModel: RunnableModel\n\n/**\n * Maintain a `BufferedRunModelParams` instance that wraps the transferable buffer\n * containing the I/O parameters.\n * @hidden\n */\nconst params = new BufferedRunModelParams()\n\ninterface InitResult {\n  outputVarIds: string[]\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  modelListing?: /*ModelListingSpecs*/ any\n  startTime: number\n  endTime: number\n  saveFreq: number\n  outputRowLength: number\n}\n\n/** @hidden */\nconst modelWorker = {\n  async initModel(): Promise<InitResult> {\n    if (runnableModel) {\n      throw new Error('RunnableModel was already initialized')\n    }\n\n    // Initialize the runnable model\n    const generatedModel = await initGeneratedModel()\n    runnableModel = createRunnableModel(generatedModel)\n\n    // Transfer the model metadata to the runner\n    return {\n      outputVarIds: runnableModel.outputVarIds,\n      modelListing: runnableModel.modelListing,\n      startTime: runnableModel.startTime,\n      endTime: runnableModel.endTime,\n      saveFreq: runnableModel.saveFreq,\n      outputRowLength: runnableModel.numSavePoints\n    }\n  },\n\n  runModel(ioBuffer: ArrayBuffer): TransferDescriptor<ArrayBuffer> {\n    if (!runnableModel) {\n      throw new Error('RunnableModel must be initialized before running the model in worker')\n    }\n\n    // Update the `BufferedRunModelParams` to use the values in the buffer that was transferred\n    // from the runner to the worker\n    params.updateFromEncodedBuffer(ioBuffer)\n\n    // Run the model synchronously on the worker thread using those I/O parameters\n    runnableModel.runModel(params)\n\n    // Transfer the buffer back to the runner\n    return Transfer(ioBuffer)\n  }\n}\n\n/**\n * Expose an object in the current worker thread that communicates with the\n * `ModelRunner` instance running in the main thread.  The exposed worker\n * object will take care of running the model on the worker thread and\n * sending the outputs back to the main thread.\n *\n * @param init The function that initializes the generated model instance that\n * is used in the worker thread.\n */\nexport function exposeModelWorker(init: () => Promise<GeneratedModel>): void {\n  // Save the initializer, which will be used when the runner calls `initModel`\n  // on the worker\n  initGeneratedModel = init\n\n  // Expose the worker implementation to `threads.js`\n  expose(modelWorker)\n}\n"],"mappings":";AAGA,SAAS,QAAQ,gBAAgB;AAGjC,SAAS,wBAAwB,2BAA2B;AAG5D,IAAI;AAGJ,IAAI;AAOJ,IAAM,SAAS,IAAI,uBAAuB;AAa1C,IAAM,cAAc;AAAA,EAClB,MAAM,YAAiC;AACrC,QAAI,eAAe;AACjB,YAAM,IAAI,MAAM,uCAAuC;AAAA,IACzD;AAGA,UAAM,iBAAiB,MAAM,mBAAmB;AAChD,oBAAgB,oBAAoB,cAAc;AAGlD,WAAO;AAAA,MACL,cAAc,cAAc;AAAA,MAC5B,cAAc,cAAc;AAAA,MAC5B,WAAW,cAAc;AAAA,MACzB,SAAS,cAAc;AAAA,MACvB,UAAU,cAAc;AAAA,MACxB,iBAAiB,cAAc;AAAA,IACjC;AAAA,EACF;AAAA,EAEA,SAAS,UAAwD;AAC/D,QAAI,CAAC,eAAe;AAClB,YAAM,IAAI,MAAM,sEAAsE;AAAA,IACxF;AAIA,WAAO,wBAAwB,QAAQ;AAGvC,kBAAc,SAAS,MAAM;AAG7B,WAAO,SAAS,QAAQ;AAAA,EAC1B;AACF;AAWO,SAAS,kBAAkB,MAA2C;AAG3E,uBAAqB;AAGrB,SAAO,WAAW;AACpB;","names":[]}