@intlayer/engine 9.0.0-canary.12

package/dist/esm/utils/runParallel/index.mjs

@@ -0,0 +1,100 @@
+import { spawnPosix } from "./spawnPosix.mjs";
+import { spawnWin32 } from "./spawnWin32.mjs";
+import { delimiter, join } from "node:path";
+
+//#region src/utils/runParallel/index.ts
+/**
+* Start a cross-platform parallel process using npm-run-all approach.
+* Accepts either a single string (e.g., 'next start') or an array of tokens (e.g., ['next', 'start']).
+*/
+const runParallel = (proc) => {
+	if (!proc || Array.isArray(proc) && proc.length === 0) throw new Error("Invalid command");
+	const commandText = Array.isArray(proc) ? proc.join(" ") : proc;
+	const isArray = Array.isArray(proc);
+	const command = isArray ? proc[0] : commandText;
+	const args = isArray ? proc.slice(1) : [];
+	const cwdBin = join(process.cwd(), "node_modules", ".bin");
+	const PATH_KEY = Object.keys(process.env).find((key) => key.toLowerCase() === "path") ?? "PATH";
+	const extendedPath = [cwdBin, process.env[PATH_KEY] ?? ""].filter(Boolean).join(delimiter);
+	const childEnv = {
+		...process.env,
+		[PATH_KEY]: extendedPath
+	};
+	const isWin = process.platform === "win32";
+	const spawnFunc = isWin ? spawnWin32 : spawnPosix;
+	const spawnOptions = {
+		cwd: process.cwd(),
+		stdio: "inherit",
+		env: childEnv,
+		shell: isWin
+	};
+	const child = isArray ? args.length === 0 && /\s/.test(command) ? isWin ? spawnFunc(process.env.ComSpec ?? "cmd.exe", [
+		"/d",
+		"/s",
+		"/c",
+		command
+	], spawnOptions) : spawnFunc(process.env.SHELL ?? "/bin/sh", ["-c", command], spawnOptions) : spawnFunc(command, args, spawnOptions) : isWin ? spawnFunc(process.env.ComSpec ?? "cmd.exe", [
+		"/d",
+		"/s",
+		"/c",
+		commandText
+	], spawnOptions) : spawnFunc(process.env.SHELL ?? "/bin/sh", ["-c", commandText], spawnOptions);
+	const result = new Promise((resolve, reject) => {
+		child.on("error", (err) => {
+			try {
+				console.error(`[runParallel] Failed to start: ${err?.message ?? String(err)}`);
+			} catch {}
+			reject(err);
+		});
+		child.on("exit", (code, signal) => {
+			if (code === 0 || new Set([
+				129,
+				130,
+				131,
+				143
+			]).has(code ?? -1) || signal && [
+				"SIGINT",
+				"SIGTERM",
+				"SIGQUIT",
+				"SIGHUP"
+			].includes(signal)) resolve();
+			else reject(Object.assign(/* @__PURE__ */ new Error("Parallel process failed"), {
+				code,
+				signal
+			}));
+		});
+	});
+	const kill = () => {
+		try {
+			child.kill("SIGTERM");
+		} catch {}
+	};
+	const handleExit = () => kill();
+	const handleSigInt = () => {
+		kill();
+		process.off("SIGINT", handleSigInt);
+		process.kill(process.pid, "SIGINT");
+	};
+	const handleSigTerm = () => {
+		kill();
+		process.off("SIGTERM", handleSigTerm);
+		process.kill(process.pid, "SIGTERM");
+	};
+	process.on("exit", handleExit);
+	process.on("SIGINT", handleSigInt);
+	process.on("SIGTERM", handleSigTerm);
+	child.on("exit", () => {
+		process.off("exit", handleExit);
+		process.off("SIGINT", handleSigInt);
+		process.off("SIGTERM", handleSigTerm);
+	});
+	return {
+		kill,
+		result,
+		commandText
+	};
+};
+
+//#endregion
+export { runParallel };
+//# sourceMappingURL=index.mjs.map

package/dist/esm/utils/runParallel/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../../../src/utils/runParallel/index.ts"],"sourcesContent":["import { delimiter, join } from 'node:path';\nimport { spawnPosix } from './spawnPosix';\nimport { spawnWin32 } from './spawnWin32';\n\nexport type ParallelHandle = {\n  kill: () => void;\n  result: Promise<any>;\n  commandText: string;\n};\n\n/**\n * Start a cross-platform parallel process using npm-run-all approach.\n * Accepts either a single string (e.g., 'next start') or an array of tokens (e.g., ['next', 'start']).\n */\nexport const runParallel = (proc?: string | string[]): ParallelHandle => {\n  if (!proc || (Array.isArray(proc) && proc.length === 0))\n    throw new Error('Invalid command');\n\n  const commandText = Array.isArray(proc) ? proc.join(' ') : proc;\n\n  const isArray = Array.isArray(proc);\n  const command = isArray ? (proc as string[])[0] : commandText;\n  const args = isArray ? (proc as string[]).slice(1) : [];\n\n  // Ensure local binaries (node_modules/.bin) are resolvable\n  const cwdBin = join(process.cwd(), 'node_modules', '.bin');\n  const PATH_KEY =\n    Object.keys(process.env).find((key) => key.toLowerCase() === 'path') ??\n    'PATH';\n\n  const extendedPath = [cwdBin, process.env[PATH_KEY] ?? '']\n    .filter(Boolean)\n    .join(delimiter);\n\n  const childEnv = {\n    ...process.env,\n    [PATH_KEY]: extendedPath,\n  } as NodeJS.ProcessEnv;\n\n  const isWin = process.platform === 'win32';\n  const spawnFunc = isWin ? spawnWin32 : spawnPosix;\n\n  // Spawn options\n  const spawnOptions = {\n    cwd: process.cwd(),\n    stdio: 'inherit' as const,\n    env: childEnv,\n    shell: isWin,\n  };\n\n  // Spawn the child process\n  const child = isArray\n    ? // If provided as a single string element that includes spaces, treat it like a shell command\n      args.length === 0 && /\\s/.test(command)\n      ? isWin\n        ? spawnFunc(\n            process.env.ComSpec ?? 'cmd.exe',\n            ['/d', '/s', '/c', command],\n            spawnOptions\n          )\n        : spawnFunc(\n            process.env.SHELL ?? '/bin/sh',\n            ['-c', command],\n            spawnOptions\n          )\n      : spawnFunc(command, args, spawnOptions)\n    : isWin\n      ? spawnFunc(\n          process.env.ComSpec ?? 'cmd.exe',\n          ['/d', '/s', '/c', commandText],\n          spawnOptions\n        )\n      : spawnFunc(\n          process.env.SHELL ?? '/bin/sh',\n          ['-c', commandText],\n          spawnOptions\n        );\n\n  const result = new Promise<void>((resolve, reject) => {\n    child.on('error', (err) => {\n      try {\n        console.error(\n          `[runParallel] Failed to start: ${err?.message ?? String(err)}`\n        );\n      } catch {}\n      reject(err);\n    });\n\n    child.on('exit', (code, signal) => {\n      // Treat common termination signals as graceful exits, not failures\n      const gracefulSignals = ['SIGINT', 'SIGTERM', 'SIGQUIT', 'SIGHUP'];\n      // Also treat shell-convention exit codes (128 + signal number) as graceful:\n      // 129 = SIGHUP, 130 = SIGINT, 131 = SIGQUIT, 143 = SIGTERM\n      const gracefulSignalCodes = new Set([129, 130, 131, 143]);\n      if (\n        code === 0 ||\n        gracefulSignalCodes.has(code ?? -1) ||\n        (signal && gracefulSignals.includes(signal))\n      ) {\n        resolve();\n      } else {\n        reject(\n          Object.assign(new Error('Parallel process failed'), { code, signal })\n        );\n      }\n    });\n  });\n\n  const kill = () => {\n    try {\n      child.kill('SIGTERM');\n    } catch {\n      // Best effort\n    }\n  };\n\n  const handleExit = () => kill();\n\n  const handleSigInt = () => {\n    kill();\n    process.off('SIGINT', handleSigInt);\n    process.kill(process.pid, 'SIGINT'); // Propagate to allow natural shutdown\n  };\n\n  const handleSigTerm = () => {\n    kill();\n    process.off('SIGTERM', handleSigTerm);\n    process.kill(process.pid, 'SIGTERM'); // Propagate to allow natural shutdown\n  };\n\n  process.on('exit', handleExit);\n  process.on('SIGINT', handleSigInt);\n  process.on('SIGTERM', handleSigTerm);\n\n  child.on('exit', () => {\n    process.off('exit', handleExit);\n    process.off('SIGINT', handleSigInt);\n    process.off('SIGTERM', handleSigTerm);\n  });\n\n  return { kill, result, commandText };\n};\n"],"mappings":";;;;;;;;;AAcA,MAAa,eAAe,SAA6C;AACvE,KAAI,CAAC,QAAS,MAAM,QAAQ,KAAK,IAAI,KAAK,WAAW,EACnD,OAAM,IAAI,MAAM,kBAAkB;CAEpC,MAAM,cAAc,MAAM,QAAQ,KAAK,GAAG,KAAK,KAAK,IAAI,GAAG;CAE3D,MAAM,UAAU,MAAM,QAAQ,KAAK;CACnC,MAAM,UAAU,UAAW,KAAkB,KAAK;CAClD,MAAM,OAAO,UAAW,KAAkB,MAAM,EAAE,GAAG,EAAE;CAGvD,MAAM,SAAS,KAAK,QAAQ,KAAK,EAAE,gBAAgB,OAAO;CAC1D,MAAM,WACJ,OAAO,KAAK,QAAQ,IAAI,CAAC,MAAM,QAAQ,IAAI,aAAa,KAAK,OAAO,IACpE;CAEF,MAAM,eAAe,CAAC,QAAQ,QAAQ,IAAI,aAAa,GAAG,CACvD,OAAO,QAAQ,CACf,KAAK,UAAU;CAElB,MAAM,WAAW;EACf,GAAG,QAAQ;GACV,WAAW;EACb;CAED,MAAM,QAAQ,QAAQ,aAAa;CACnC,MAAM,YAAY,QAAQ,aAAa;CAGvC,MAAM,eAAe;EACnB,KAAK,QAAQ,KAAK;EAClB,OAAO;EACP,KAAK;EACL,OAAO;EACR;CAGD,MAAM,QAAQ,UAEV,KAAK,WAAW,KAAK,KAAK,KAAK,QAAQ,GACrC,QACE,UACE,QAAQ,IAAI,WAAW,WACvB;EAAC;EAAM;EAAM;EAAM;EAAQ,EAC3B,aACD,GACD,UACE,QAAQ,IAAI,SAAS,WACrB,CAAC,MAAM,QAAQ,EACf,aACD,GACH,UAAU,SAAS,MAAM,aAAa,GACxC,QACE,UACE,QAAQ,IAAI,WAAW,WACvB;EAAC;EAAM;EAAM;EAAM;EAAY,EAC/B,aACD,GACD,UACE,QAAQ,IAAI,SAAS,WACrB,CAAC,MAAM,YAAY,EACnB,aACD;CAEP,MAAM,SAAS,IAAI,SAAe,SAAS,WAAW;AACpD,QAAM,GAAG,UAAU,QAAQ;AACzB,OAAI;AACF,YAAQ,MACN,kCAAkC,KAAK,WAAW,OAAO,IAAI,GAC9D;WACK;AACR,UAAO,IAAI;IACX;AAEF,QAAM,GAAG,SAAS,MAAM,WAAW;AAMjC,OACE,SAAS,KACT,IAH8B,IAAI;IAAC;IAAK;IAAK;IAAK;IAAI,CAGnC,CAAC,IAAI,QAAQ,GAAG,IAClC,UAAU;IAPY;IAAU;IAAW;IAAW;IAO7B,CAAC,SAAS,OAAO,CAE3C,UAAS;OAET,QACE,OAAO,uBAAO,IAAI,MAAM,0BAA0B,EAAE;IAAE;IAAM;IAAQ,CAAC,CACtE;IAEH;GACF;CAEF,MAAM,aAAa;AACjB,MAAI;AACF,SAAM,KAAK,UAAU;UACf;;CAKV,MAAM,mBAAmB,MAAM;CAE/B,MAAM,qBAAqB;AACzB,QAAM;AACN,UAAQ,IAAI,UAAU,aAAa;AACnC,UAAQ,KAAK,QAAQ,KAAK,SAAS;;CAGrC,MAAM,sBAAsB;AAC1B,QAAM;AACN,UAAQ,IAAI,WAAW,cAAc;AACrC,UAAQ,KAAK,QAAQ,KAAK,UAAU;;AAGtC,SAAQ,GAAG,QAAQ,WAAW;AAC9B,SAAQ,GAAG,UAAU,aAAa;AAClC,SAAQ,GAAG,WAAW,cAAc;AAEpC,OAAM,GAAG,cAAc;AACrB,UAAQ,IAAI,QAAQ,WAAW;AAC/B,UAAQ,IAAI,UAAU,aAAa;AACnC,UAAQ,IAAI,WAAW,cAAc;GACrC;AAEF,QAAO;EAAE;EAAM;EAAQ;EAAa"}

package/dist/esm/utils/runParallel/pidTree.mjs

@@ -0,0 +1,143 @@
+import { ps } from "./ps.mjs";
+import { wmic } from "./wmic.mjs";
+import * as os$1 from "node:os";
+
+//#region src/utils/runParallel/pidTree.ts
+const platformToMethod = {
+	darwin: "ps",
+	sunos: "ps",
+	freebsd: "ps",
+	netbsd: "ps",
+	win: "wmic",
+	linux: "ps",
+	aix: "ps"
+};
+const methodToFn = {
+	ps,
+	wmic
+};
+let platform = os$1.platform();
+if (platform.startsWith("win")) platform = "win";
+const method = platformToMethod[platform];
+/**
+* Gets the list of all the pids of the system.
+*/
+const getAll = (callback) => {
+	if (method === void 0) {
+		callback(/* @__PURE__ */ new Error(os$1.platform() + " is not supported yet, please open an issue (https://github.com/simonepri/pidtree)"), void 0);
+		return;
+	}
+	const listFn = methodToFn[method];
+	listFn(callback);
+};
+/**
+* Get the list of children and grandchildren pids of the given PID.
+* @param PID A PID. If -1 will return all the pids.
+* @param options Optional options object.
+* @param callback Called when the list is ready.
+*/
+const pidtree = (PID, options, callback) => {
+	let normalizedOptions;
+	let normalizedCallback;
+	if (typeof options === "function") {
+		normalizedCallback = options;
+		normalizedOptions = {};
+	} else {
+		normalizedCallback = callback;
+		normalizedOptions = typeof options === "object" ? options : {};
+	}
+	const parsedPID = parseInt(String(PID), 10);
+	if (Number.isNaN(parsedPID) || parsedPID < -1) {
+		normalizedCallback(/* @__PURE__ */ new TypeError("The pid provided is invalid"), void 0);
+		return;
+	}
+	getAll((err, processList) => {
+		if (err) {
+			normalizedCallback(err, void 0);
+			return;
+		}
+		if (!processList) {
+			normalizedCallback(/* @__PURE__ */ new Error("Failed to get process list"), void 0);
+			return;
+		}
+		if (parsedPID === -1) {
+			const result = processList.map(([ppid, pid]) => normalizedOptions.advanced ? {
+				ppid,
+				pid
+			} : pid);
+			normalizedCallback(null, result);
+			return;
+		}
+		let root;
+		for (let l = 0; l < processList.length; l++) {
+			if (processList[l][1] === parsedPID) {
+				root = normalizedOptions.advanced ? {
+					ppid: processList[l][0],
+					pid: parsedPID
+				} : parsedPID;
+				break;
+			}
+			if (processList[l][0] === parsedPID) root = normalizedOptions.advanced ? { pid: parsedPID } : parsedPID;
+		}
+		if (root === void 0) {
+			normalizedCallback(/* @__PURE__ */ new Error("No matching pid found"), void 0);
+			return;
+		}
+		const tree = {};
+		const listCopy = [...processList];
+		while (listCopy.length > 0) {
+			const element = listCopy.pop();
+			if (tree[element[0]]) tree[element[0]].push(element[1]);
+			else tree[element[0]] = [element[1]];
+		}
+		let idx = 0;
+		const pids = [root];
+		while (idx < pids.length) {
+			const curpid = normalizedOptions.advanced ? pids[idx++].pid : pids[idx++];
+			if (!tree[curpid]) continue;
+			const length = tree[curpid].length;
+			for (let j = 0; j < length; j++) pids.push(normalizedOptions.advanced ? {
+				ppid: curpid,
+				pid: tree[curpid][j]
+			} : tree[curpid][j]);
+			delete tree[curpid];
+		}
+		if (!normalizedOptions.root) pids.shift();
+		normalizedCallback(null, pids);
+	});
+};
+const pify = (fn, arg1, arg2) => {
+	return new Promise((resolve, reject) => {
+		fn(arg1, arg2, (err, data) => {
+			if (err) return reject(err);
+			if (data === void 0) return reject(/* @__PURE__ */ new Error("No data returned"));
+			resolve(data);
+		});
+	});
+};
+/* istanbul ignore if */
+if (!String.prototype.startsWith) String.prototype.startsWith = function(suffix) {
+	return this.substring(0, suffix.length) === suffix;
+};
+/**
+* Get the list of children pids of the given pid.
+* @param pid A PID. If -1 will return all the pids.
+* @param options Optional options object.
+* @param callback Called when the list is ready. If not provided a promise is returned instead.
+* @returns Only when the callback is not provided.
+*/
+const list = (pid, options, callback) => {
+	if (typeof options === "function") {
+		pidtree(pid, void 0, options);
+		return;
+	}
+	if (typeof callback === "function") {
+		pidtree(pid, options, callback);
+		return;
+	}
+	return pify(pidtree, pid, options);
+};
+
+//#endregion
+export { list };
+//# sourceMappingURL=pidTree.mjs.map

package/dist/esm/utils/runParallel/pidTree.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"pidTree.mjs","names":["os"],"sources":["../../../../src/utils/runParallel/pidTree.ts"],"sourcesContent":["import * as os from 'node:os';\nimport { ps } from './ps';\nimport { wmic } from './wmic';\n\ntype Platform =\n  | 'darwin'\n  | 'sunos'\n  | 'freebsd'\n  | 'netbsd'\n  | 'win'\n  | 'linux'\n  | 'aix';\ntype Method = 'ps' | 'wmic';\n\ntype ProcessList = [number, number][]; // [PPID, PID][]\n\ninterface ListOptions {\n  root?: boolean;\n  advanced?: boolean;\n}\n\ntype ProcessInfo = { pid: number; ppid?: number };\ntype ResultType<T extends ListOptions | undefined> = T extends {\n  advanced: true;\n}\n  ? ProcessInfo[]\n  : number[];\n\ntype ProcessListCallback = (err: Error | null, list?: ProcessList) => void;\ntype ListCallback<T extends ListOptions | undefined> = (\n  err: Error | null,\n  list?: ResultType<T>\n) => void;\n\ntype ProcessListFn = (callback: ProcessListCallback) => void;\n\nconst platformToMethod: Record<Platform, Method> = {\n  darwin: 'ps',\n  sunos: 'ps',\n  freebsd: 'ps',\n  netbsd: 'ps',\n  win: 'wmic',\n  linux: 'ps',\n  aix: 'ps',\n};\n\nconst methodToFn: Record<Method, ProcessListFn> = {\n  ps,\n  wmic,\n};\n\nlet platform: string = os.platform();\nif (platform.startsWith('win')) {\n  platform = 'win';\n}\n\nconst method: Method | undefined = platformToMethod[platform as Platform];\n\n/**\n * Gets the list of all the pids of the system.\n */\nconst getAll = (callback: ProcessListCallback): void => {\n  if (method === undefined) {\n    callback(\n      new Error(\n        os.platform() +\n          ' is not supported yet, please open an issue (https://github.com/simonepri/pidtree)'\n      ),\n      undefined\n    );\n    return;\n  }\n\n  const listFn = methodToFn[method];\n  listFn(callback);\n};\n\n/**\n * Get the list of children and grandchildren pids of the given PID.\n * @param PID A PID. If -1 will return all the pids.\n * @param options Optional options object.\n * @param callback Called when the list is ready.\n */\nconst pidtree = <T extends ListOptions | undefined>(\n  PID: number | string,\n  options: T | ListCallback<T> | undefined,\n  callback?: ListCallback<T>\n): void => {\n  let normalizedOptions: ListOptions;\n  let normalizedCallback: ListCallback<T>;\n\n  if (typeof options === 'function') {\n    normalizedCallback = options;\n    normalizedOptions = {};\n  } else {\n    normalizedCallback = callback!;\n    normalizedOptions = typeof options === 'object' ? options : {};\n  }\n\n  const parsedPID = parseInt(String(PID), 10);\n  if (Number.isNaN(parsedPID) || parsedPID < -1) {\n    normalizedCallback(\n      new TypeError('The pid provided is invalid') as Error,\n      undefined\n    );\n    return;\n  }\n\n  getAll((err, processList) => {\n    if (err) {\n      normalizedCallback(err, undefined);\n      return;\n    }\n\n    if (!processList) {\n      normalizedCallback(new Error('Failed to get process list'), undefined);\n      return;\n    }\n\n    // If the user wants the whole list just return it\n    if (parsedPID === -1) {\n      const result = processList.map(([ppid, pid]) =>\n        normalizedOptions.advanced ? { ppid, pid } : pid\n      ) as ResultType<T>;\n\n      normalizedCallback(null, result);\n      return;\n    }\n\n    let root: ProcessInfo | number | undefined;\n    for (let l = 0; l < processList.length; l++) {\n      if (processList[l][1] === parsedPID) {\n        root = normalizedOptions.advanced\n          ? { ppid: processList[l][0], pid: parsedPID }\n          : parsedPID;\n        break;\n      }\n\n      if (processList[l][0] === parsedPID) {\n        root = normalizedOptions.advanced ? { pid: parsedPID } : parsedPID; // Special pids like 0 on *nix\n      }\n    }\n\n    if (root === undefined) {\n      normalizedCallback(new Error('No matching pid found'), undefined);\n      return;\n    }\n\n    // Build the adjacency Hash Map (pid -> [children of pid])\n    const tree: Record<number, number[]> = {};\n    const listCopy = [...processList];\n    while (listCopy.length > 0) {\n      const element = listCopy.pop()!;\n      if (tree[element[0]]) {\n        tree[element[0]].push(element[1]);\n      } else {\n        tree[element[0]] = [element[1]];\n      }\n    }\n\n    // Starting by the PID provided by the user, traverse the tree using the\n    // adjacency Hash Map until the whole subtree is visited.\n    // Each pid encountered while visiting is added to the pids array.\n    let idx = 0;\n    const pids: (ProcessInfo | number)[] = [root];\n    while (idx < pids.length) {\n      const curpid = normalizedOptions.advanced\n        ? (pids[idx++] as ProcessInfo).pid\n        : (pids[idx++] as number);\n      if (!tree[curpid]) continue;\n      const length = tree[curpid].length;\n      for (let j = 0; j < length; j++) {\n        pids.push(\n          normalizedOptions.advanced\n            ? { ppid: curpid, pid: tree[curpid][j] }\n            : tree[curpid][j]\n        );\n      }\n\n      delete tree[curpid];\n    }\n\n    if (!normalizedOptions.root) {\n      pids.shift(); // Remove root\n    }\n\n    normalizedCallback(null, pids as ResultType<T>);\n  });\n};\n\nconst pify = <T extends ListOptions | undefined>(\n  fn: typeof pidtree,\n  arg1: number | string,\n  arg2: T | undefined\n): Promise<ResultType<T>> => {\n  return new Promise((resolve, reject) => {\n    fn(arg1, arg2, (err, data) => {\n      if (err) return reject(err);\n      if (data === undefined) {\n        return reject(new Error('No data returned'));\n      }\n      resolve(data);\n    });\n  });\n};\n\n// Node versions prior to 4.0.0 do not define have `startsWith`.\n/* istanbul ignore if */\nif (!String.prototype.startsWith) {\n  String.prototype.startsWith = function (suffix: string): boolean {\n    return this.substring(0, suffix.length) === suffix;\n  };\n}\n\n/**\n * Get the list of children pids of the given pid.\n * @param pid A PID. If -1 will return all the pids.\n * @param options Optional options object.\n * @param callback Called when the list is ready. If not provided a promise is returned instead.\n * @returns Only when the callback is not provided.\n */\nexport const list = <T extends ListOptions | undefined>(\n  pid: number | string,\n  options?: T | ListCallback<T>,\n  callback?: ListCallback<T>\n): Promise<ResultType<T>> | undefined => {\n  if (typeof options === 'function') {\n    pidtree(pid, undefined, options);\n    return;\n  }\n\n  if (typeof callback === 'function') {\n    pidtree(pid, options, callback);\n    return;\n  }\n\n  return pify(pidtree, pid, options);\n};\n"],"mappings":";;;;;AAoCA,MAAM,mBAA6C;CACjD,QAAQ;CACR,OAAO;CACP,SAAS;CACT,QAAQ;CACR,KAAK;CACL,OAAO;CACP,KAAK;CACN;AAED,MAAM,aAA4C;CAChD;CACA;CACD;AAED,IAAI,WAAmBA,KAAG,UAAU;AACpC,IAAI,SAAS,WAAW,MAAM,CAC5B,YAAW;AAGb,MAAM,SAA6B,iBAAiB;;;;AAKpD,MAAM,UAAU,aAAwC;AACtD,KAAI,WAAW,QAAW;AACxB,2BACE,IAAI,MACFA,KAAG,UAAU,GACX,qFACH,EACD,OACD;AACD;;CAGF,MAAM,SAAS,WAAW;AAC1B,QAAO,SAAS;;;;;;;;AASlB,MAAM,WACJ,KACA,SACA,aACS;CACT,IAAI;CACJ,IAAI;AAEJ,KAAI,OAAO,YAAY,YAAY;AACjC,uBAAqB;AACrB,sBAAoB,EAAE;QACjB;AACL,uBAAqB;AACrB,sBAAoB,OAAO,YAAY,WAAW,UAAU,EAAE;;CAGhE,MAAM,YAAY,SAAS,OAAO,IAAI,EAAE,GAAG;AAC3C,KAAI,OAAO,MAAM,UAAU,IAAI,YAAY,IAAI;AAC7C,qCACE,IAAI,UAAU,8BAA8B,EAC5C,OACD;AACD;;AAGF,SAAQ,KAAK,gBAAgB;AAC3B,MAAI,KAAK;AACP,sBAAmB,KAAK,OAAU;AAClC;;AAGF,MAAI,CAAC,aAAa;AAChB,sCAAmB,IAAI,MAAM,6BAA6B,EAAE,OAAU;AACtE;;AAIF,MAAI,cAAc,IAAI;GACpB,MAAM,SAAS,YAAY,KAAK,CAAC,MAAM,SACrC,kBAAkB,WAAW;IAAE;IAAM;IAAK,GAAG,IAC9C;AAED,sBAAmB,MAAM,OAAO;AAChC;;EAGF,IAAI;AACJ,OAAK,IAAI,IAAI,GAAG,IAAI,YAAY,QAAQ,KAAK;AAC3C,OAAI,YAAY,GAAG,OAAO,WAAW;AACnC,WAAO,kBAAkB,WACrB;KAAE,MAAM,YAAY,GAAG;KAAI,KAAK;KAAW,GAC3C;AACJ;;AAGF,OAAI,YAAY,GAAG,OAAO,UACxB,QAAO,kBAAkB,WAAW,EAAE,KAAK,WAAW,GAAG;;AAI7D,MAAI,SAAS,QAAW;AACtB,sCAAmB,IAAI,MAAM,wBAAwB,EAAE,OAAU;AACjE;;EAIF,MAAM,OAAiC,EAAE;EACzC,MAAM,WAAW,CAAC,GAAG,YAAY;AACjC,SAAO,SAAS,SAAS,GAAG;GAC1B,MAAM,UAAU,SAAS,KAAK;AAC9B,OAAI,KAAK,QAAQ,IACf,MAAK,QAAQ,IAAI,KAAK,QAAQ,GAAG;OAEjC,MAAK,QAAQ,MAAM,CAAC,QAAQ,GAAG;;EAOnC,IAAI,MAAM;EACV,MAAM,OAAiC,CAAC,KAAK;AAC7C,SAAO,MAAM,KAAK,QAAQ;GACxB,MAAM,SAAS,kBAAkB,WAC5B,KAAK,OAAuB,MAC5B,KAAK;AACV,OAAI,CAAC,KAAK,QAAS;GACnB,MAAM,SAAS,KAAK,QAAQ;AAC5B,QAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,IAC1B,MAAK,KACH,kBAAkB,WACd;IAAE,MAAM;IAAQ,KAAK,KAAK,QAAQ;IAAI,GACtC,KAAK,QAAQ,GAClB;AAGH,UAAO,KAAK;;AAGd,MAAI,CAAC,kBAAkB,KACrB,MAAK,OAAO;AAGd,qBAAmB,MAAM,KAAsB;GAC/C;;AAGJ,MAAM,QACJ,IACA,MACA,SAC2B;AAC3B,QAAO,IAAI,SAAS,SAAS,WAAW;AACtC,KAAG,MAAM,OAAO,KAAK,SAAS;AAC5B,OAAI,IAAK,QAAO,OAAO,IAAI;AAC3B,OAAI,SAAS,OACX,QAAO,uBAAO,IAAI,MAAM,mBAAmB,CAAC;AAE9C,WAAQ,KAAK;IACb;GACF;;;AAKJ,IAAI,CAAC,OAAO,UAAU,WACpB,QAAO,UAAU,aAAa,SAAU,QAAyB;AAC/D,QAAO,KAAK,UAAU,GAAG,OAAO,OAAO,KAAK;;;;;;;;;AAWhD,MAAa,QACX,KACA,SACA,aACuC;AACvC,KAAI,OAAO,YAAY,YAAY;AACjC,UAAQ,KAAK,QAAW,QAAQ;AAChC;;AAGF,KAAI,OAAO,aAAa,YAAY;AAClC,UAAQ,KAAK,SAAS,SAAS;AAC/B;;AAGF,QAAO,KAAK,SAAS,KAAK,QAAQ"}

package/dist/esm/utils/runParallel/ps.mjs

@@ -0,0 +1,47 @@
+import { run } from "./bin.mjs";
+import * as os$1 from "node:os";
+
+//#region src/utils/runParallel/ps.ts
+/**
+* Gets the list of all the pids of the system through the ps command.
+* @param callback Callback function with error and process list.
+*/
+const ps = (callback) => {
+	run("ps", [
+		"-A",
+		"-o",
+		"ppid,pid"
+	], (err, stdout, code) => {
+		if (err) {
+			callback(err);
+			return;
+		}
+		if (code !== 0) {
+			callback(/* @__PURE__ */ new Error(`pidtree ps command exited with code ${code}`));
+			return;
+		}
+		if (!stdout) {
+			callback(/* @__PURE__ */ new Error("No stdout received from ps command"));
+			return;
+		}
+		try {
+			const lines = stdout.split(os$1.EOL);
+			const list = [];
+			for (let i = 1; i < lines.length; i++) {
+				const trimmed = lines[i].trim();
+				if (!trimmed) continue;
+				const parts = trimmed.split(/\s+/);
+				const ppid = parseInt(parts[0], 10);
+				const pid = parseInt(parts[1], 10);
+				if (!Number.isNaN(ppid) && !Number.isNaN(pid)) list.push([ppid, pid]);
+			}
+			callback(null, list);
+		} catch (error) {
+			callback(error instanceof Error ? error : new Error(String(error)));
+		}
+	});
+};
+
+//#endregion
+export { ps };
+//# sourceMappingURL=ps.mjs.map

package/dist/esm/utils/runParallel/ps.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ps.mjs","names":["os"],"sources":["../../../../src/utils/runParallel/ps.ts"],"sourcesContent":["import * as os from 'node:os';\nimport { run } from './bin';\n\ntype ProcessList = [number, number][]; // [PPID, PID][]\ntype ProcessListCallback = (err: Error | null, list?: ProcessList) => void;\n\n/**\n * Gets the list of all the pids of the system through the ps command.\n * @param callback Callback function with error and process list.\n */\nexport const ps = (callback: ProcessListCallback): void => {\n  const args = ['-A', '-o', 'ppid,pid'];\n\n  run('ps', args, (err, stdout, code) => {\n    if (err) {\n      callback(err);\n      return;\n    }\n    if (code !== 0) {\n      callback(new Error(`pidtree ps command exited with code ${code}`));\n      return;\n    }\n\n    // Example of stdout\n    //\n    // PPID   PID\n    //    1   430\n    //  430   432\n    //    1   727\n    //    1  7166\n\n    if (!stdout) {\n      callback(new Error('No stdout received from ps command'));\n      return;\n    }\n\n    try {\n      const lines = stdout.split(os.EOL);\n\n      const list: ProcessList = [];\n      for (let i = 1; i < lines.length; i++) {\n        const trimmed = lines[i].trim();\n        if (!trimmed) continue;\n        const parts = trimmed.split(/\\s+/);\n        const ppid = parseInt(parts[0], 10); // PPID\n        const pid = parseInt(parts[1], 10); // PID\n        if (!Number.isNaN(ppid) && !Number.isNaN(pid)) {\n          list.push([ppid, pid]);\n        }\n      }\n\n      callback(null, list);\n    } catch (error) {\n      callback(error instanceof Error ? error : new Error(String(error)));\n    }\n  });\n};\n"],"mappings":";;;;;;;;AAUA,MAAa,MAAM,aAAwC;AAGzD,KAAI,MAAM;EAFI;EAAM;EAAM;EAEZ,GAAG,KAAK,QAAQ,SAAS;AACrC,MAAI,KAAK;AACP,YAAS,IAAI;AACb;;AAEF,MAAI,SAAS,GAAG;AACd,4BAAS,IAAI,MAAM,uCAAuC,OAAO,CAAC;AAClE;;AAWF,MAAI,CAAC,QAAQ;AACX,4BAAS,IAAI,MAAM,qCAAqC,CAAC;AACzD;;AAGF,MAAI;GACF,MAAM,QAAQ,OAAO,MAAMA,KAAG,IAAI;GAElC,MAAM,OAAoB,EAAE;AAC5B,QAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;IACrC,MAAM,UAAU,MAAM,GAAG,MAAM;AAC/B,QAAI,CAAC,QAAS;IACd,MAAM,QAAQ,QAAQ,MAAM,MAAM;IAClC,MAAM,OAAO,SAAS,MAAM,IAAI,GAAG;IACnC,MAAM,MAAM,SAAS,MAAM,IAAI,GAAG;AAClC,QAAI,CAAC,OAAO,MAAM,KAAK,IAAI,CAAC,OAAO,MAAM,IAAI,CAC3C,MAAK,KAAK,CAAC,MAAM,IAAI,CAAC;;AAI1B,YAAS,MAAM,KAAK;WACb,OAAO;AACd,YAAS,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,MAAM,CAAC,CAAC;;GAErE"}

package/dist/esm/utils/runParallel/runTask.mjs

@@ -0,0 +1,153 @@
+import { Writable } from "node:stream";
+
+//#region src/utils/runParallel/runTask.ts
+/**
+* Remove the given value from the array.
+*/
+const remove = (array, x) => {
+	const index = array.indexOf(x);
+	if (index !== -1) array.splice(index, 1);
+};
+const signals = {
+	SIGABRT: 6,
+	SIGALRM: 14,
+	SIGBUS: 10,
+	SIGCHLD: 20,
+	SIGCONT: 19,
+	SIGFPE: 8,
+	SIGHUP: 1,
+	SIGILL: 4,
+	SIGINT: 2,
+	SIGKILL: 9,
+	SIGPIPE: 13,
+	SIGQUIT: 3,
+	SIGSEGV: 11,
+	SIGSTOP: 17,
+	SIGTERM: 15,
+	SIGTRAP: 5,
+	SIGTSTP: 18,
+	SIGTTIN: 21,
+	SIGTTOU: 22,
+	SIGUSR1: 30,
+	SIGUSR2: 31
+};
+/**
+* Converts a signal name to a number.
+*/
+const convert = (signal) => {
+	return signals[signal] || 0;
+};
+/**
+* Simple in-memory writable stream
+*/
+var MemoryStream = class extends Writable {
+	chunks = [];
+	_write(chunk, _encoding, callback) {
+		this.chunks.push(chunk);
+		callback();
+	}
+	toString() {
+		return Buffer.concat(this.chunks).toString("utf8");
+	}
+};
+/**
+* Run npm-scripts of given names in parallel.
+*
+* If a npm-script exited with a non-zero code, this aborts other all npm-scripts.
+*
+* Note: This is a simplified version for our use case.
+* The full implementation would require the actual runTask function from npm-run-all.
+*/
+const runTasks = (tasks, options) => {
+	return new Promise((resolve, reject) => {
+		if (tasks.length === 0) {
+			resolve([]);
+			return;
+		}
+		const results = tasks.map((task) => ({
+			name: task,
+			code: void 0
+		}));
+		const queue = tasks.map((task, index) => ({
+			name: task,
+			index
+		}));
+		const promises = [];
+		let error = null;
+		let aborted = false;
+		/**
+		* Done.
+		*/
+		const done = () => {
+			if (error == null) resolve(results);
+			else reject(error);
+		};
+		/**
+		* Aborts all tasks.
+		*/
+		const abort = () => {
+			if (aborted) return;
+			aborted = true;
+			if (promises.length === 0) done();
+			else {
+				for (const p of promises) p.abort?.();
+				Promise.all(promises).then(done, reject);
+			}
+		};
+		/**
+		* Runs a next task.
+		*/
+		const next = () => {
+			if (aborted) return;
+			if (queue.length === 0) {
+				if (promises.length === 0) done();
+				return;
+			}
+			const originalOutputStream = options.stdout;
+			const optionsClone = { ...options };
+			const writer = new MemoryStream();
+			if (options.aggregateOutput) optionsClone.stdout = writer;
+			const task = queue.shift();
+			const promise = Promise.resolve({
+				name: task.name,
+				code: 0,
+				signal: null
+			});
+			promises.push(promise);
+			promise.then((result) => {
+				remove(promises, promise);
+				if (aborted) return;
+				if (options.aggregateOutput) originalOutputStream.write(writer.toString());
+				if (result.code === null && result.signal !== null && result.signal !== void 0) result.code = 128 + convert(result.signal);
+				results[task.index].code = result.code;
+				if (result.code) {
+					error = /* @__PURE__ */ new Error(`Task ${result.name} failed with code ${result.code}`);
+					if (!options.continueOnError) {
+						abort();
+						return;
+					}
+				}
+				if (options.race && !result.code) {
+					abort();
+					return;
+				}
+				next();
+			}, (thisError) => {
+				remove(promises, promise);
+				if (!options.continueOnError || options.race) {
+					error = thisError;
+					abort();
+					return;
+				}
+				next();
+			});
+		};
+		const max = options.maxParallel;
+		const end = typeof max === "number" && max > 0 ? Math.min(tasks.length, max) : tasks.length;
+		for (let i = 0; i < end; ++i) next();
+	});
+};
+
+//#endregion
+export { runTasks };
+//# sourceMappingURL=runTask.mjs.map

package/dist/esm/utils/runParallel/runTask.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"runTask.mjs","names":[],"sources":["../../../../src/utils/runParallel/runTask.ts"],"sourcesContent":["//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\nimport { Writable } from 'node:stream';\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Remove the given value from the array.\n */\nconst remove = <T>(array: T[], x: T): void => {\n  const index = array.indexOf(x);\n  if (index !== -1) {\n    array.splice(index, 1);\n  }\n};\n\nconst signals: Record<string, number> = {\n  // Signal name mappings to their respective standard numeric codes.\n  // See: https://man7.org/linux/man-pages/man7/signal.7.html\n\n  SIGABRT: 6, // Abort signal from abort(3)\n  SIGALRM: 14, // Timer signal from alarm(2)\n  SIGBUS: 10, // Bus error (bad memory access)\n  SIGCHLD: 20, // Child stopped or terminated\n  SIGCONT: 19, // Continue if stopped\n  SIGFPE: 8, // Floating point exception\n  SIGHUP: 1, // Hangup detected on controlling terminal or death of controlling process\n  SIGILL: 4, // Illegal Instruction\n  SIGINT: 2, // Interrupt from keyboard (Ctrl+C)\n  SIGKILL: 9, // Kill signal (cannot be caught or ignored)\n  SIGPIPE: 13, // Broken pipe: write to pipe with no readers\n  SIGQUIT: 3, // Quit from keyboard (Ctrl+\\)\n  SIGSEGV: 11, // Invalid memory reference (segmentation fault)\n  SIGSTOP: 17, // Stop process (cannot be caught or ignored)\n  SIGTERM: 15, // Termination signal\n  SIGTRAP: 5, // Trace/breakpoint trap\n  SIGTSTP: 18, // Stop typed at tty (Ctrl+Z)\n  SIGTTIN: 21, // tty input for background process\n  SIGTTOU: 22, // tty output for background process\n  SIGUSR1: 30, // User-defined signal 1\n  SIGUSR2: 31, // User-defined signal 2\n};\n\n/**\n * Converts a signal name to a number.\n */\nconst convert = (signal: string): number => {\n  return signals[signal] || 0;\n};\n\n/**\n * Simple in-memory writable stream\n */\nclass MemoryStream extends Writable {\n  private chunks: Buffer[] = [];\n\n  _write(\n    chunk: Buffer,\n    _encoding: string,\n    callback: (error?: Error | null) => void\n  ): void {\n    this.chunks.push(chunk);\n    callback();\n  }\n\n  toString(): string {\n    return Buffer.concat(this.chunks).toString('utf8');\n  }\n}\n\n//------------------------------------------------------------------------------\n// Types\n//------------------------------------------------------------------------------\n\ninterface TaskResult {\n  name: string;\n  code: number | null;\n  signal?: string | null;\n}\n\ninterface TaskQueueItem {\n  name: string;\n  index: number;\n}\n\ninterface RunTaskOptions {\n  stdout: NodeJS.WritableStream;\n  stderr?: NodeJS.WritableStream;\n  aggregateOutput?: boolean;\n  continueOnError?: boolean;\n  race?: boolean;\n  maxParallel?: number;\n}\n\ninterface TaskPromise extends Promise<TaskResult> {\n  abort?: () => void;\n}\n\n//------------------------------------------------------------------------------\n// Public Interface\n//------------------------------------------------------------------------------\n\n/**\n * Run npm-scripts of given names in parallel.\n *\n * If a npm-script exited with a non-zero code, this aborts other all npm-scripts.\n *\n * Note: This is a simplified version for our use case.\n * The full implementation would require the actual runTask function from npm-run-all.\n */\nexport const runTasks = (\n  tasks: string[],\n  options: RunTaskOptions\n): Promise<TaskResult[]> => {\n  return new Promise((resolve, reject) => {\n    if (tasks.length === 0) {\n      resolve([]);\n      return;\n    }\n\n    const results: TaskResult[] = tasks.map((task) => ({\n      name: task,\n      code: undefined as any,\n    }));\n    const queue: TaskQueueItem[] = tasks.map((task, index) => ({\n      name: task,\n      index,\n    }));\n    const promises: TaskPromise[] = [];\n    let error: Error | null = null;\n    let aborted = false;\n\n    /**\n     * Done.\n     */\n    const done = (): void => {\n      if (error == null) {\n        resolve(results);\n      } else {\n        reject(error);\n      }\n    };\n\n    /**\n     * Aborts all tasks.\n     */\n    const abort = (): void => {\n      if (aborted) {\n        return;\n      }\n      aborted = true;\n\n      if (promises.length === 0) {\n        done();\n      } else {\n        for (const p of promises) {\n          p.abort?.();\n        }\n        Promise.all(promises).then(done, reject);\n      }\n    };\n\n    /**\n     * Runs a next task.\n     */\n    const next = (): void => {\n      if (aborted) {\n        return;\n      }\n      if (queue.length === 0) {\n        if (promises.length === 0) {\n          done();\n        }\n        return;\n      }\n\n      const originalOutputStream = options.stdout;\n      const optionsClone = { ...options };\n      const writer = new MemoryStream();\n\n      if (options.aggregateOutput) {\n        optionsClone.stdout = writer as any;\n      }\n\n      const task = queue.shift()!;\n\n      // Note: This requires the actual runTask implementation from npm-run-all\n      // For now, this is a placeholder that would need to be implemented\n      const promise = Promise.resolve({\n        name: task.name,\n        code: 0,\n        signal: null,\n      }) as TaskPromise;\n\n      promises.push(promise);\n      promise.then(\n        (result) => {\n          remove(promises, promise);\n          if (aborted) {\n            return;\n          }\n\n          if (options.aggregateOutput) {\n            originalOutputStream.write(writer.toString());\n          }\n\n          // Check if the task failed as a result of a signal, and\n          // amend the exit code as a result.\n          if (\n            result.code === null &&\n            result.signal !== null &&\n            result.signal !== undefined\n          ) {\n            // An exit caused by a signal must return a status code\n            // of 128 plus the value of the signal code.\n            // Ref: https://nodejs.org/api/process.html#process_exit_codes\n            result.code = 128 + convert(result.signal);\n          }\n\n          // Save the result.\n          results[task.index].code = result.code;\n\n          // Aborts all tasks if it's an error.\n          if (result.code) {\n            error = new Error(\n              `Task ${result.name} failed with code ${result.code}`\n            );\n            if (!options.continueOnError) {\n              abort();\n              return;\n            }\n          }\n\n          // Aborts all tasks if options.race is true.\n          if (options.race && !result.code) {\n            abort();\n            return;\n          }\n\n          // Call the next task.\n          next();\n        },\n        (thisError: Error) => {\n          remove(promises, promise);\n          if (!options.continueOnError || options.race) {\n            error = thisError;\n            abort();\n            return;\n          }\n          next();\n        }\n      );\n    };\n\n    const max = options.maxParallel;\n    const end =\n      typeof max === 'number' && max > 0\n        ? Math.min(tasks.length, max)\n        : tasks.length;\n    for (let i = 0; i < end; ++i) {\n      next();\n    }\n  });\n};\n"],"mappings":"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"}

package/dist/esm/utils/runParallel/spawnPosix.mjs

@@ -0,0 +1,47 @@
+import { spawn } from "node:child_process";
+
+//#region src/utils/runParallel/spawnPosix.ts
+/**
+* Kills the new process and its sub processes synchronously using
+* process group kill (negative PID). This ensures all descendants
+* are terminated before the parent calls process.exit().
+*/
+const createKillHandler = (child) => {
+	return (signal) => {
+		if (!child.pid) return false;
+		const killSignal = signal ?? "SIGTERM";
+		try {
+			process.kill(-child.pid, killSignal);
+			return true;
+		} catch {}
+		try {
+			process.kill(child.pid, killSignal);
+		} catch {}
+		return true;
+	};
+};
+/**
+* Launches a new process with the given command.
+* This is almost same as `child_process.spawn`.
+*
+* This returns a `ChildProcess` instance.
+* `kill` method of the instance kills the new process and its sub processes.
+*
+* @param command - The command to run.
+* @param args - List of string arguments.
+* @param options - Options.
+* @returns A ChildProcess instance of new process.
+* @private
+*/
+const spawnPosix = (command, args, options) => {
+	const child = spawn(command, args, {
+		...options,
+		detached: true
+	});
+	child.kill = createKillHandler(child);
+	return child;
+};
+
+//#endregion
+export { spawnPosix };
+//# sourceMappingURL=spawnPosix.mjs.map

package/dist/esm/utils/runParallel/spawnPosix.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"spawnPosix.mjs","names":["nodeSpawn"],"sources":["../../../../src/utils/runParallel/spawnPosix.ts"],"sourcesContent":["//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\nimport type { SpawnOptions } from 'node:child_process';\nimport { type ChildProcess, spawn as nodeSpawn } from 'node:child_process';\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Kills the new process and its sub processes synchronously using\n * process group kill (negative PID). This ensures all descendants\n * are terminated before the parent calls process.exit().\n */\nconst createKillHandler = (\n  child: ChildProcess\n): ((signal?: NodeJS.Signals | number) => boolean) => {\n  return (signal?: NodeJS.Signals | number): boolean => {\n    if (!child.pid) return false;\n\n    const killSignal = signal ?? 'SIGTERM';\n\n    // Use synchronous process group kill (negative PID) as primary strategy.\n    // This kills the entire process group (shell + all descendants) immediately.\n    try {\n      process.kill(-child.pid, killSignal);\n      return true;\n    } catch {\n      // Process group kill failed (e.g., process not a group leader).\n    }\n\n    // Fallback: kill the child process directly.\n    try {\n      process.kill(child.pid, killSignal);\n    } catch {\n      // ignore — process may have already exited.\n    }\n\n    return true;\n  };\n};\n\n//------------------------------------------------------------------------------\n// Public Interface\n//------------------------------------------------------------------------------\n\n/**\n * Launches a new process with the given command.\n * This is almost same as `child_process.spawn`.\n *\n * This returns a `ChildProcess` instance.\n * `kill` method of the instance kills the new process and its sub processes.\n *\n * @param command - The command to run.\n * @param args - List of string arguments.\n * @param options - Options.\n * @returns A ChildProcess instance of new process.\n * @private\n */\nexport const spawnPosix = (\n  command: string,\n  args: string[],\n  options: SpawnOptions\n): ChildProcess => {\n  // Spawn detached so the child becomes its own process group leader.\n  // This allows killing the entire tree via process.kill(-pid, signal).\n  const child = nodeSpawn(command, args, { ...options, detached: true });\n  child.kill = createKillHandler(child);\n\n  return child;\n};\n"],"mappings":";;;;;;;;AAgBA,MAAM,qBACJ,UACoD;AACpD,SAAQ,WAA8C;AACpD,MAAI,CAAC,MAAM,IAAK,QAAO;EAEvB,MAAM,aAAa,UAAU;AAI7B,MAAI;AACF,WAAQ,KAAK,CAAC,MAAM,KAAK,WAAW;AACpC,UAAO;UACD;AAKR,MAAI;AACF,WAAQ,KAAK,MAAM,KAAK,WAAW;UAC7B;AAIR,SAAO;;;;;;;;;;;;;;;;AAqBX,MAAa,cACX,SACA,MACA,YACiB;CAGjB,MAAM,QAAQA,MAAU,SAAS,MAAM;EAAE,GAAG;EAAS,UAAU;EAAM,CAAC;AACtE,OAAM,OAAO,kBAAkB,MAAM;AAErC,QAAO"}

package/dist/esm/utils/runParallel/spawnWin32.mjs

@@ -0,0 +1,42 @@
+import { spawn, spawnSync } from "node:child_process";
+
+//#region src/utils/runParallel/spawnWin32.ts
+/**
+* Kills the new process and its sub processes forcibly.
+*/
+const createKillHandler = (child) => {
+	return () => {
+		if (!child.pid) return false;
+		try {
+			spawnSync("taskkill", [
+				"/F",
+				"/T",
+				"/PID",
+				String(child.pid)
+			], { stdio: "ignore" });
+		} catch {}
+		return true;
+	};
+};
+/**
+* Launches a new process with the given command.
+* This is almost same as `child_process.spawn`.
+*
+* This returns a `ChildProcess` instance.
+* `kill` method of the instance kills the new process and its sub processes forcibly.
+*
+* @param command - The command to run.
+* @param args - List of string arguments.
+* @param options - Options.
+* @returns A ChildProcess instance of new process.
+* @private
+*/
+const spawnWin32 = (command, args, options) => {
+	const child = spawn(command, args, options);
+	child.kill = createKillHandler(child);
+	return child;
+};
+
+//#endregion
+export { spawnWin32 };
+//# sourceMappingURL=spawnWin32.mjs.map

package/dist/esm/utils/runParallel/spawnWin32.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"spawnWin32.mjs","names":["nodeSpawn"],"sources":["../../../../src/utils/runParallel/spawnWin32.ts"],"sourcesContent":["//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\nimport type { SpawnOptions } from 'node:child_process';\nimport {\n  type ChildProcess,\n  spawn as nodeSpawn,\n  spawnSync,\n} from 'node:child_process';\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Kills the new process and its sub processes forcibly.\n */\nconst createKillHandler = (child: ChildProcess) => {\n  return (): boolean => {\n    if (!child.pid) return false;\n\n    try {\n      // This MUST be synchronous. Otherwise, it dies with the parent process.\n      spawnSync('taskkill', ['/F', '/T', '/PID', String(child.pid)], {\n        stdio: 'ignore',\n      });\n    } catch {\n      // ignore\n    }\n\n    return true;\n  };\n};\n\n//------------------------------------------------------------------------------\n// Public Interface\n//------------------------------------------------------------------------------\n\n/**\n * Launches a new process with the given command.\n * This is almost same as `child_process.spawn`.\n *\n * This returns a `ChildProcess` instance.\n * `kill` method of the instance kills the new process and its sub processes forcibly.\n *\n * @param command - The command to run.\n * @param args - List of string arguments.\n * @param options - Options.\n * @returns A ChildProcess instance of new process.\n * @private\n */\nexport const spawnWin32 = (\n  command: string,\n  args: string[],\n  options: SpawnOptions\n): ChildProcess => {\n  const child = nodeSpawn(command, args, options);\n  child.kill = createKillHandler(child);\n\n  return child;\n};\n"],"mappings":";;;;;;AAkBA,MAAM,qBAAqB,UAAwB;AACjD,cAAsB;AACpB,MAAI,CAAC,MAAM,IAAK,QAAO;AAEvB,MAAI;AAEF,aAAU,YAAY;IAAC;IAAM;IAAM;IAAQ,OAAO,MAAM,IAAI;IAAC,EAAE,EAC7D,OAAO,UACR,CAAC;UACI;AAIR,SAAO;;;;;;;;;;;;;;;;AAqBX,MAAa,cACX,SACA,MACA,YACiB;CACjB,MAAM,QAAQA,MAAU,SAAS,MAAM,QAAQ;AAC/C,OAAM,OAAO,kBAAkB,MAAM;AAErC,QAAO"}

package/dist/esm/utils/runParallel/wmic.mjs

@@ -0,0 +1,50 @@
+import { run } from "./bin.mjs";
+import * as os$1 from "node:os";
+
+//#region src/utils/runParallel/wmic.ts
+/**
+* Gets the list of all the pids of the system through the wmic command.
+* @param callback Callback function with error and process list.
+*/
+const wmic = (callback) => {
+	run("wmic", [
+		"PROCESS",
+		"get",
+		"ParentProcessId,ProcessId"
+	], {
+		windowsHide: true,
+		windowsVerbatimArguments: true
+	}, (err, stdout, code) => {
+		if (err) {
+			callback(err);
+			return;
+		}
+		if (code !== 0) {
+			callback(/* @__PURE__ */ new Error(`pidtree wmic command exited with code ${code}`));
+			return;
+		}
+		if (!stdout) {
+			callback(/* @__PURE__ */ new Error("No stdout received from wmic command"));
+			return;
+		}
+		try {
+			const lines = stdout.split(os$1.EOL);
+			const list = [];
+			for (let i = 1; i < lines.length; i++) {
+				const trimmed = lines[i].trim();
+				if (!trimmed) continue;
+				const parts = trimmed.split(/\s+/);
+				const ppid = parseInt(parts[0], 10);
+				const pid = parseInt(parts[1], 10);
+				if (!Number.isNaN(ppid) && !Number.isNaN(pid)) list.push([ppid, pid]);
+			}
+			callback(null, list);
+		} catch (error) {
+			callback(error instanceof Error ? error : new Error(String(error)));
+		}
+	});
+};
+
+//#endregion
+export { wmic };
+//# sourceMappingURL=wmic.mjs.map