q9

node_modules/tinypool/dist/entry/process.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

node_modules/tinypool/dist/entry/process.js

@@ -0,0 +1,92 @@
+import {
+  stderr,
+  stdout
+} from "../chunk-ACQHDOFQ.js";
+import {
+  getHandler,
+  throwInNextTick
+} from "../chunk-E2J7JLFN.js";
+import "../chunk-6LX4VMOV.js";
+
+// src/entry/process.ts
+process.__tinypool_state__ = {
+  isChildProcess: true,
+  isTinypoolWorker: true,
+  workerData: null,
+  workerId: Number(process.env.TINYPOOL_WORKER_ID)
+};
+var memoryUsage = process.memoryUsage.bind(process);
+var send = process.send.bind(process);
+process.on("message", (message) => {
+  if (!message || !message.__tinypool_worker_message__)
+    return;
+  if (message.source === "pool") {
+    const { filename, name } = message;
+    (async function() {
+      if (filename !== null) {
+        await getHandler(filename, name);
+      }
+      send(
+        {
+          ready: true,
+          source: "pool",
+          __tinypool_worker_message__: true
+        },
+        () => {
+        }
+      );
+    })().catch(throwInNextTick);
+    return;
+  }
+  if (message.source === "port") {
+    onMessage(message).catch(throwInNextTick);
+    return;
+  }
+  throw new Error(`Unexpected TinypoolWorkerMessage ${JSON.stringify(message)}`);
+});
+async function onMessage(message) {
+  const { taskId, task, filename, name } = message;
+  let response;
+  try {
+    const handler = await getHandler(filename, name);
+    if (handler === null) {
+      throw new Error(`No handler function exported from ${filename}`);
+    }
+    const result = await handler(task);
+    response = {
+      source: "port",
+      __tinypool_worker_message__: true,
+      taskId,
+      result,
+      error: null,
+      usedMemory: memoryUsage().heapUsed
+    };
+    if (stdout()?.writableLength > 0) {
+      await new Promise((resolve) => process.stdout.write("", resolve));
+    }
+    if (stderr()?.writableLength > 0) {
+      await new Promise((resolve) => process.stderr.write("", resolve));
+    }
+  } catch (error) {
+    response = {
+      source: "port",
+      __tinypool_worker_message__: true,
+      taskId,
+      result: null,
+      error: serializeError(error),
+      usedMemory: memoryUsage().heapUsed
+    };
+  }
+  send(response);
+}
+function serializeError(error) {
+  if (error instanceof Error) {
+    return {
+      ...error,
+      name: error.name,
+      stack: error.stack,
+      message: error.message
+    };
+  }
+  return String(error);
+}

node_modules/tinypool/dist/entry/utils.d.ts

@@ -0,0 +1,5 @@
+type Handler = Function;
+declare function getHandler(filename: string, name: string): Promise<Handler | null>;
+declare function throwInNextTick(error: Error): void;
+
+export { getHandler, throwInNextTick };

node_modules/tinypool/dist/entry/utils.js

@@ -0,0 +1,9 @@
+import {
+  getHandler,
+  throwInNextTick
+} from "../chunk-E2J7JLFN.js";
+import "../chunk-6LX4VMOV.js";
+export {
+  getHandler,
+  throwInNextTick
+};

node_modules/tinypool/dist/entry/worker.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

node_modules/tinypool/dist/entry/worker.js

@@ -0,0 +1,103 @@
+import {
+  isMovable,
+  kRequestCountField,
+  kResponseCountField,
+  kTransferable,
+  kValue
+} from "../chunk-UBWFVGJX.js";
+import {
+  stderr,
+  stdout
+} from "../chunk-ACQHDOFQ.js";
+import {
+  getHandler,
+  throwInNextTick
+} from "../chunk-E2J7JLFN.js";
+import "../chunk-6LX4VMOV.js";
+
+// src/entry/worker.ts
+import {
+  parentPort,
+  receiveMessageOnPort,
+  workerData as tinypoolData
+} from "worker_threads";
+var [tinypoolPrivateData, workerData] = tinypoolData;
+process.__tinypool_state__ = {
+  isWorkerThread: true,
+  isTinypoolWorker: true,
+  workerData,
+  workerId: tinypoolPrivateData.workerId
+};
+var memoryUsage = process.memoryUsage.bind(process);
+var useAtomics = process.env.PISCINA_DISABLE_ATOMICS !== "1";
+parentPort.on("message", (message) => {
+  useAtomics = process.env.PISCINA_DISABLE_ATOMICS === "1" ? false : message.useAtomics;
+  const { port, sharedBuffer, filename, name } = message;
+  (async function() {
+    if (filename !== null) {
+      await getHandler(filename, name);
+    }
+    const readyMessage = { ready: true };
+    parentPort.postMessage(readyMessage);
+    port.on("message", onMessage.bind(null, port, sharedBuffer));
+    atomicsWaitLoop(port, sharedBuffer);
+  })().catch(throwInNextTick);
+});
+var currentTasks = 0;
+var lastSeenRequestCount = 0;
+function atomicsWaitLoop(port, sharedBuffer) {
+  if (!useAtomics)
+    return;
+  while (currentTasks === 0) {
+    Atomics.wait(sharedBuffer, kRequestCountField, lastSeenRequestCount);
+    lastSeenRequestCount = Atomics.load(sharedBuffer, kRequestCountField);
+    let entry;
+    while ((entry = receiveMessageOnPort(port)) !== void 0) {
+      onMessage(port, sharedBuffer, entry.message);
+    }
+  }
+}
+function onMessage(port, sharedBuffer, message) {
+  currentTasks++;
+  const { taskId, task, filename, name } = message;
+  (async function() {
+    let response;
+    let transferList = [];
+    try {
+      const handler = await getHandler(filename, name);
+      if (handler === null) {
+        throw new Error(`No handler function exported from ${filename}`);
+      }
+      let result = await handler(task);
+      if (isMovable(result)) {
+        transferList = transferList.concat(result[kTransferable]);
+        result = result[kValue];
+      }
+      response = {
+        taskId,
+        result,
+        error: null,
+        usedMemory: memoryUsage().heapUsed
+      };
+      if (stdout()?.writableLength > 0) {
+        await new Promise((resolve) => process.stdout.write("", resolve));
+      }
+      if (stderr()?.writableLength > 0) {
+        await new Promise((resolve) => process.stderr.write("", resolve));
+      }
+    } catch (error) {
+      response = {
+        taskId,
+        result: null,
+        // It may be worth taking a look at the error cloning algorithm we
+        // use in Node.js core here, it's quite a bit more flexible
+        error,
+        usedMemory: memoryUsage().heapUsed
+      };
+    }
+    currentTasks--;
+    port.postMessage(response, transferList);
+    Atomics.add(sharedBuffer, kResponseCountField, 1);
+    atomicsWaitLoop(port, sharedBuffer);
+  })().catch(throwInNextTick);
+}