first_commit

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

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

GTA_P_V2/node_modules/tinypool/dist/entry/process.js

@@ -0,0 +1,72 @@
+import { stderr, stdout } from "../utils-De75vAgL.js";
+import { getHandler, throwInNextTick } from "../utils-B--2TaWv.js";
+
+//#region src/entry/process.ts
+process.__tinypool_state__ = {
+	isChildProcess: true,
+	isTinypoolWorker: true,
+	workerData: null,
+	workerId: Number(process.env.TINYPOOL_WORKER_ID)
+};
+const memoryUsage = process.memoryUsage.bind(process);
+const 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 "${name}" 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);
+}
+
+//#endregion

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

@@ -0,0 +1,7 @@
+//#region src/entry/utils.d.ts
+type Handler = Function;
+declare function getHandler(filename: string, name: string): Promise<Handler | null>;
+declare function throwInNextTick(error: Error): void;
+
+//#endregion
+export { getHandler, throwInNextTick };

GTA_P_V2/node_modules/tinypool/dist/entry/utils.js

@@ -0,0 +1,3 @@
+import { getHandler, throwInNextTick } from "../utils-B--2TaWv.js";
+
+export { getHandler, throwInNextTick };

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

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

GTA_P_V2/node_modules/tinypool/dist/entry/worker.js

@@ -0,0 +1,76 @@
+import { isMovable, kRequestCountField, kResponseCountField, kTransferable, kValue } from "../common-Qw-RoVFD.js";
+import { stderr, stdout } from "../utils-De75vAgL.js";
+import { getHandler, throwInNextTick } from "../utils-B--2TaWv.js";
+import { parentPort, receiveMessageOnPort, workerData } from "node:worker_threads";
+
+//#region src/entry/worker.ts
+const [tinypoolPrivateData, workerData$1] = workerData;
+process.__tinypool_state__ = {
+	isWorkerThread: true,
+	isTinypoolWorker: true,
+	workerData: workerData$1,
+	workerId: tinypoolPrivateData.workerId
+};
+const memoryUsage = process.memoryUsage.bind(process);
+let 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.start();
+		port.on("message", onMessage.bind(null, port, sharedBuffer));
+		atomicsWaitLoop(port, sharedBuffer);
+	})().catch(throwInNextTick);
+});
+let currentTasks = 0;
+let 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 "${name}" 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,
+				error,
+				usedMemory: memoryUsage().heapUsed
+			};
+		}
+		currentTasks--;
+		port.postMessage(response, transferList);
+		Atomics.add(sharedBuffer, kResponseCountField, 1);
+		atomicsWaitLoop(port, sharedBuffer);
+	})().catch(throwInNextTick);
+}
+
+//#endregion