scripts/devtools_build.mjs - devtools/devtools-frontend - Git at Google

 // Copyright 2025 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 import childProcess from 'node:child_process';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import {performance} from 'node:perf_hooks';

 import {
   autoninjaPyPath,
   gnPyPath,
   isInChromiumDirectory,
   rootPath,
   vpython3ExecutablePath,
 } from './devtools_paths.js';

 /**
  * Errors returned from `spawn()` will have additional `stderr` and `stdout`
  * properties, similar to what we'd get from `child_process.execFile()`.
  */
 class SpawnError extends Error {
   /**
    * Constructor for errors generated from `spawn()`.
    *
    * @param {string} message The actual error message.
    * @param {string} stderr The child process' error output.
    * @param {string} stdout The child process' regular output.
    */
   constructor(message, stderr, stdout) {
     super(message);
     this.stderr = stderr;
     this.stdout = stdout;
   }
 }

 /**
  * Promisified wrapper around `child_process.spawn()`.
  *
  * In addition to forwarding the `options` to `child_process.spawn()`, it'll also
  * set the `shell` option to `true`, to ensure that on Windows we can correctly
  * invoke `.bat` files (necessary for the Python3 wrapper script).
  *
  * @param {string} command The command to run.
  * @param {Array<string>} args List of string arguments to pass to the `command`.
  * @param {Object} options Passed directly to `child_process.spawn()`.
  * @returns {Promise<{stdout: string, stderr: string}>}
  */
 function spawn(command, args, options = {}) {
   return new Promise((resolve, reject) => {
     const child = childProcess.spawn(command, args, {
       ...options,
       shell: true,
     });

     let stdout = '';
     let stderr = '';

     child.stdout.on('data', data => {
       stdout += data.toString();
     });

     child.stderr.on('data', data => {
       stderr += data.toString();
     });

     child.on('exit', (code, signal) => {
       if (signal) {
         reject(
             new SpawnError(
                 `Process terminated due to signal ${signal}`,
                 stderr,
                 stdout,
                 ),
         );
       } else if (code) {
         reject(
             new SpawnError(`Process exited with code ${code}`, stderr, stdout),
         );
       } else {
         resolve({stdout, stderr});
       }
     });

     child.on('error', reject);
   });
 }

 /**
  * Representation of the feature set that is configured for Chrome. This
  * keeps track of enabled and disabled features and generates the correct
  * combination of `--enable-features` / `--disable-features` command line
  * flags.
  *
  * There are unit tests for this in `./devtools_build.test.mjs`.
  */
 export class FeatureSet {
   #disabled = new Set();
   #enabled = new Map();

   /**
    * Disables the given `feature`.
    *
    * @param feature the name of the feature to disable.
    */
   disable(feature) {
     this.#disabled.add(feature);
     this.#enabled.delete(feature);
   }

   /**
    * Enables the given `feature`, and optionally adds the `parameters` to it.
    * For example:
    * ```js
    * featureSet.enable('DevToolsFreestyler', {patching: true});
    * ```
    * The parameters are additive.
    *
    * @param feature the name of the feature to enable.
    * @param parameters the additional parameters to pass to it, in
    *                            the form of key/value pairs.
    */
   enable(feature, parameters = {}) {
     this.#disabled.delete(feature);
     if (!this.#enabled.has(feature)) {
       this.#enabled.set(feature, Object.create(null));
     }
     for (const [key, value] of Object.entries(parameters)) {
       this.#enabled.get(feature)[key] = value;
     }
   }

   /**
    * Merge the other `featureSet` into this.
    *
    * @param featureSet the other `FeatureSet` to apply.
    */
   merge(featureSet) {
     for (const feature of featureSet.#disabled) {
       this.disable(feature);
     }
     for (const [feature, parameters] of featureSet.#enabled) {
       this.enable(feature, parameters);
     }
   }

   /**
    * Yields the command line parameters to pass to the invocation of
    * a Chrome binary for achieving the state of the feature set.
    */
   * [Symbol.iterator]() {
     const disabledFeatures = [...this.#disabled];
     if (disabledFeatures.length) {
       yield `--disable-features=${disabledFeatures.sort().join(',')}`;
     }
     const enabledFeatures = [...this.#enabled].map(([feature, parameters]) => {
       parameters = Object.entries(parameters);
       if (parameters.length) {
         parameters = parameters.map(([key, value]) => `${key}/${value}`);
         feature = `${feature}:${parameters.sort().join('/')}`;
       }
       return feature;
     });
     if (enabledFeatures.length) {
       yield `--enable-features=${enabledFeatures.sort().join(',')}`;
     }
   }

   static parse(text) {
     if (!text) {
       return [];
     }
     const features = [];
     for (const str of text.split(',')) {
       const parts = str.split(':');
       if (parts.length < 1 || parts.length > 2) {
         throw new Error(`Invalid feature declaration '${str}'`);
       }
       const feature = parts[0];
       const parameters = Object.create(null);
       if (parts.length > 1) {
         const args = parts[1].split('/');
         if (args.length % 2 !== 0) {
           throw new Error(
               `Invalid parameters '${parts[1]}' for feature ${feature}`,
           );
         }
         for (let i = 0; i < args.length; i += 2) {
           const key = args[i + 0];
           const value = args[i + 1];
           parameters[key] = value;
         }
       }
       features.push({feature, parameters});
     }
     return features;
   }
 }

 /**
  * Constructs a human readable error message for the given build `error`.
  *
  * @param error the `Error` from the failed `autoninja` invocation.
  * @param outDir the absolute path to the `target` out directory.
  * @param target the target relative to `//out`.
  * @returns the human readable error message.
  */
 function buildErrorMessageForNinja(error, outDir, target) {
   const {message, stderr, stdout} = error;
   if (stderr) {
     // Anything that went to stderr has precedence.
     return `Failed to build \`${target}' in \`${outDir}'
 ${stdout}
 ${stderr}
 `;
   }
   if (stdout) {
     // Check for `tsc` or `esbuild` errors in the stdout.
     const tscErrors = [
       ...stdout.matchAll(/^[^\s].*\(\d+,\d+\): error TS\d+:\s+.*$/gm),
     ].map(([tscError]) => tscError);
     if (!tscErrors.length) {
       // We didn't find any `tsc` errors, but maybe there are `esbuild` errors.
       // Transform these into the `tsc` format (with a made up error code), so
       // we can report all TypeScript errors consistently in `tsc` format (which
       // is well-known and understood by tools).
       const esbuildErrors = stdout.matchAll(
           /^✘ \[ERROR\] ([^\n]+)\n\n\s+\.\.\/\.\.\/(.+):(\d+):(\d+):/gm,
       );
       for (const [, message, filename, line, column] of esbuildErrors) {
         tscErrors.push(
             `${filename}(${line},${column}): error TS0000: ${message}`,
         );
       }
     }
     if (tscErrors.length) {
       return `TypeScript compilation failed for \`${target}'

 ${tscErrors.join('\n')}
 `;
     }

     // At the very least we strip `ninja: Something, something` lines from the
     // standard output, since that's not particularly helpful.
     const output = stdout.replaceAll(/^ninja: [^\n]+\n+/gm, '').trim();
     return `Failed to build \`${target}' in \`${outDir}'

 ${output}
 `;
   }
   return `Failed to build \`${target}' in \`${outDir}' (${message})`;
 }

 /** @enum */
 export const BuildStep = {
   GN: 'gn',
   AUTONINJA: 'autoninja',
 };

 export class BuildError extends Error {
   /**
    * Constructs a new `BuildError` with the given parameters.
    *
    * @param step the build step that failed.
    * @param {object} options additional options for the `BuildError`.
    * @param options.cause the actual cause for the build error.
    * @param options.outDir the absolute path to the `target` out directory.
    * @param options.target the target relative to `//out`.
    */
   constructor(step, options) {
     const {cause, outDir, target} = options;
     const message = step === BuildStep.GN ? `\`gn' failed to initialize out directory ${outDir}` :
                                             buildErrorMessageForNinja(cause, outDir, target);
     super(message, {cause});
     this.step = step;
     this.name = 'BuildError';
     this.target = target;
     this.outDir = outDir;
   }
 }

 /**
  * @typedef BuildResult
  * @type {object}
  * @property {number} time - wall clock time (in seconds) for the build.
  */

 /**
  * @param target the target relative to `//out`.
  * @returns the GN args for the `target`.
  */
 export async function prepareBuild(target) {
   const outDir = path.join(rootPath(), 'out', target);

   // Prepare the build directory first.
   const outDirStat = await fs.stat(outDir).catch(() => null);
   if (!outDirStat?.isDirectory()) {
     // Use GN to (optionally create and) initialize the |outDir|.
     try {
       const gnExe = vpython3ExecutablePath();
       const gnArgs = [gnPyPath(), '-q', 'gen', outDir];
       await spawn(gnExe, gnArgs);
     } catch (cause) {
       throw new BuildError(BuildStep.GN, {cause, outDir, target});
     }
   }

   return await gnArgsForTarget(target);
 }

 /** @type Map<string, Promise<Map<string, string>>> */
 const gnArgsCache = new Map();

 /**
  * @param {string} target
  */
 export function gnArgsForTarget(target) {
   let gnArgs = gnArgsCache.get(target);
   if (!gnArgs) {
     gnArgs = (async () => {
       const outDir = path.join(rootPath(), 'out', target);
       try {
         const cwd = rootPath();
         const gnExe = vpython3ExecutablePath();
         const gnArgs = [
           gnPyPath(),
           '-q',
           'args',
           outDir,
           '--json',
           '--list',
           '--short',
         ];
         const {stdout} = await spawn(gnExe, gnArgs, {cwd});
         return new Map(
             JSON.parse(stdout).map(
                 arg =>
                     [arg.name,
                      arg.current?.value ?? arg.default?.value,
         ]),
         );
       } catch {
         return new Map();
       }
     })();
     gnArgsCache.set(target, gnArgs);
   }
   return gnArgs;
 }

 /** @type Map<string, Map<string, Promise<Array<string>>>> */
 const gnRefsCache = new Map();

 function gnRefsForTarget(target, filename) {
   let gnRefsPerTarget = gnRefsCache.get(target);
   if (!gnRefsPerTarget) {
     gnRefsPerTarget = new Map();
     gnRefsCache.set(target, gnRefsPerTarget);
   }
   let gnRef = gnRefsPerTarget.get(filename);
   if (!gnRef) {
     gnRef = (async () => {
       const cwd = rootPath();
       const outDir = path.join(rootPath(), 'out', target);
       const gnExe = vpython3ExecutablePath();
       const gnArgs = [gnPyPath(), 'refs', outDir, '--as=output', filename];
       const {stdout} = await spawn(gnExe, gnArgs, {cwd});
       return stdout.trim().split('\n');
     })();
     gnRefsPerTarget.set(filename, gnRef);
   }
   return gnRef;
 }

 /**
  *
  * @param {string} target
  * @param {string[]=} filenames
  * @returns {Promise<string[]>}
  */
 async function computeBuildTargetsForFiles(target, filenames) {
   const SUPPORTED_EXTENSIONS = ['.css', '.ts'];
   if (filenames && filenames.length &&
       filenames.every(
           filename => SUPPORTED_EXTENSIONS.includes(path.extname(filename)),
           )) {
     if (isInChromiumDirectory().isInChromium) {
       filenames = filenames.map(
           filename => path.join('third_party', 'devtools-frontend', 'src', filename),
       );
     }
     const gnArgs = await gnArgsForTarget(target);
     if (gnArgs.get('devtools_bundle') === 'false') {
       try {
         const gnRefs = (await Promise.all(
                             filenames.map(filename => gnRefsForTarget(target, filename)),
                             ))
                            .flat();
         if (gnRefs.length) {
           // If there are any changes to TypeScript files, we need to also rebuild the
           // `en-US.json`, as otherwise the changes to `UIStrings` aren't picked up.
           if (filenames.some(filename => path.extname(filename) === '.ts')) {
             gnRefs.push('collect_strings');
           }
           return gnRefs;
         }
       } catch (error) {
         console.error(error);
       }
     }
   }

   return ['devtools_all_files'];
 }

 /**
  * @param {string} target
  * @param {{ filenames?: string[], signal?: AbortSignal}} options
  * @returns a `BuildResult` with statistics for the build.
  */
 export async function build(target, options = {}) {
   const startTime = performance.now();
   const outDir = path.join(rootPath(), 'out', target);

   // Build just the devtools-frontend resources in |outDir|. This is important
   // since we might be running in a full Chromium checkout and certainly don't
   // want to build all of Chromium first.
   const buildTargets = await computeBuildTargetsForFiles(
       target,
       options.filenames,
   );
   try {
     const autoninjaExe = vpython3ExecutablePath();
     const autoninjaArgs = [autoninjaPyPath(), '-C', outDir, ...buildTargets];
     await spawn(autoninjaExe, autoninjaArgs, {
       shell: true,
       signal: options.signal,
     });
   } catch (cause) {
     if (cause.name === 'AbortError') {
       throw cause;
     }
     throw new BuildError(BuildStep.AUTONINJA, {cause, outDir, target});
   }

   // Report the build result.
   const time = (performance.now() - startTime) / 1000;
   return {time};
 }
	// Copyright 2025 The Chromium Authors
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	import childProcess from 'node:child_process';
	import fs from 'node:fs/promises';
	import path from 'node:path';
	import {performance} from 'node:perf_hooks';

	import {
	autoninjaPyPath,
	gnPyPath,
	isInChromiumDirectory,
	rootPath,
	vpython3ExecutablePath,
	} from './devtools_paths.js';

	/**
	* Errors returned from `spawn()` will have additional `stderr` and `stdout`
	* properties, similar to what we'd get from `child_process.execFile()`.
	*/
	class SpawnError extends Error {
	/**
	* Constructor for errors generated from `spawn()`.
	*
	* @param {string} message The actual error message.
	* @param {string} stderr The child process' error output.
	* @param {string} stdout The child process' regular output.
	*/
	constructor(message, stderr, stdout) {
	super(message);
	this.stderr = stderr;
	this.stdout = stdout;
	}
	}

	/**
	* Promisified wrapper around `child_process.spawn()`.
	*
	* In addition to forwarding the `options` to `child_process.spawn()`, it'll also
	* set the `shell` option to `true`, to ensure that on Windows we can correctly
	* invoke `.bat` files (necessary for the Python3 wrapper script).
	*
	* @param {string} command The command to run.
	* @param {Array<string>} args List of string arguments to pass to the `command`.
	* @param {Object} options Passed directly to `child_process.spawn()`.
	* @returns {Promise<{stdout: string, stderr: string}>}
	*/
	function spawn(command, args, options = {}) {
	return new Promise((resolve, reject) => {
	const child = childProcess.spawn(command, args, {
	...options,
	shell: true,
	});

	let stdout = '';
	let stderr = '';

	child.stdout.on('data', data => {
	stdout += data.toString();
	});

	child.stderr.on('data', data => {
	stderr += data.toString();
	});

	child.on('exit', (code, signal) => {
	if (signal) {
	reject(
	new SpawnError(
	`Process terminated due to signal ${signal}`,
	stderr,
	stdout,
	),
	);
	} else if (code) {
	reject(
	new SpawnError(`Process exited with code ${code}`, stderr, stdout),
	);
	} else {
	resolve({stdout, stderr});
	}
	});

	child.on('error', reject);
	});
	}

	/**
	* Representation of the feature set that is configured for Chrome. This
	* keeps track of enabled and disabled features and generates the correct
	* combination of `--enable-features` / `--disable-features` command line
	* flags.
	*
	* There are unit tests for this in `./devtools_build.test.mjs`.
	*/
	export class FeatureSet {
	#disabled = new Set();
	#enabled = new Map();

	/**
	* Disables the given `feature`.
	*
	* @param feature the name of the feature to disable.
	*/
	disable(feature) {
	this.#disabled.add(feature);
	this.#enabled.delete(feature);
	}

	/**
	* Enables the given `feature`, and optionally adds the `parameters` to it.
	* For example:
	* ```js
	* featureSet.enable('DevToolsFreestyler', {patching: true});
	* ```
	* The parameters are additive.
	*
	* @param feature the name of the feature to enable.
	* @param parameters the additional parameters to pass to it, in
	* the form of key/value pairs.
	*/
	enable(feature, parameters = {}) {
	this.#disabled.delete(feature);
	if (!this.#enabled.has(feature)) {
	this.#enabled.set(feature, Object.create(null));
	}
	for (const [key, value] of Object.entries(parameters)) {
	this.#enabled.get(feature)[key] = value;
	}
	}

	/**
	* Merge the other `featureSet` into this.
	*
	* @param featureSet the other `FeatureSet` to apply.
	*/
	merge(featureSet) {
	for (const feature of featureSet.#disabled) {
	this.disable(feature);
	}
	for (const [feature, parameters] of featureSet.#enabled) {
	this.enable(feature, parameters);
	}
	}

	/**
	* Yields the command line parameters to pass to the invocation of
	* a Chrome binary for achieving the state of the feature set.
	*/
	* [Symbol.iterator]() {
	const disabledFeatures = [...this.#disabled];
	if (disabledFeatures.length) {
	yield `--disable-features=${disabledFeatures.sort().join(',')}`;
	}
	const enabledFeatures = [...this.#enabled].map(([feature, parameters]) => {
	parameters = Object.entries(parameters);
	if (parameters.length) {
	parameters = parameters.map(([key, value]) => `${key}/${value}`);
	feature = `${feature}:${parameters.sort().join('/')}`;
	}
	return feature;
	});
	if (enabledFeatures.length) {
	yield `--enable-features=${enabledFeatures.sort().join(',')}`;
	}
	}

	static parse(text) {
	if (!text) {
	return [];
	}
	const features = [];
	for (const str of text.split(',')) {
	const parts = str.split(':');
	if (parts.length < 1 \|\| parts.length > 2) {
	throw new Error(`Invalid feature declaration '${str}'`);
	}
	const feature = parts[0];
	const parameters = Object.create(null);
	if (parts.length > 1) {
	const args = parts[1].split('/');
	if (args.length % 2 !== 0) {
	throw new Error(
	`Invalid parameters '${parts[1]}' for feature ${feature}`,
	);
	}
	for (let i = 0; i < args.length; i += 2) {
	const key = args[i + 0];
	const value = args[i + 1];
	parameters[key] = value;
	}
	}
	features.push({feature, parameters});
	}
	return features;
	}
	}

	/**
	* Constructs a human readable error message for the given build `error`.
	*
	* @param error the `Error` from the failed `autoninja` invocation.
	* @param outDir the absolute path to the `target` out directory.
	* @param target the target relative to `//out`.
	* @returns the human readable error message.
	*/
	function buildErrorMessageForNinja(error, outDir, target) {
	const {message, stderr, stdout} = error;
	if (stderr) {
	// Anything that went to stderr has precedence.
	return `Failed to build \`${target}' in \`${outDir}'
	${stdout}
	${stderr}
	`;
	}
	if (stdout) {
	// Check for `tsc` or `esbuild` errors in the stdout.
	const tscErrors = [
	...stdout.matchAll(/^[^\s].\(\d+,\d+\): error TS\d+:\s+.$/gm),
	].map(([tscError]) => tscError);
	if (!tscErrors.length) {
	// We didn't find any `tsc` errors, but maybe there are `esbuild` errors.
	// Transform these into the `tsc` format (with a made up error code), so
	// we can report all TypeScript errors consistently in `tsc` format (which
	// is well-known and understood by tools).
	const esbuildErrors = stdout.matchAll(
	/^✘ \[ERROR\] ([^\n]+)\n\n\s+\.\.\/\.\.\/(.+):(\d+):(\d+):/gm,
	);
	for (const [, message, filename, line, column] of esbuildErrors) {
	tscErrors.push(
	`${filename}(${line},${column}): error TS0000: ${message}`,
	);
	}
	}
	if (tscErrors.length) {
	return `TypeScript compilation failed for \`${target}'

	${tscErrors.join('\n')}
	`;
	}

	// At the very least we strip `ninja: Something, something` lines from the
	// standard output, since that's not particularly helpful.
	const output = stdout.replaceAll(/^ninja: [^\n]+\n+/gm, '').trim();
	return `Failed to build \`${target}' in \`${outDir}'

	${output}
	`;
	}
	return `Failed to build \`${target}' in \`${outDir}' (${message})`;
	}

	/** @enum */
	export const BuildStep = {
	GN: 'gn',
	AUTONINJA: 'autoninja',
	};

	export class BuildError extends Error {
	/**
	* Constructs a new `BuildError` with the given parameters.
	*
	* @param step the build step that failed.
	* @param {object} options additional options for the `BuildError`.
	* @param options.cause the actual cause for the build error.
	* @param options.outDir the absolute path to the `target` out directory.
	* @param options.target the target relative to `//out`.
	*/
	constructor(step, options) {
	const {cause, outDir, target} = options;
	const message = step === BuildStep.GN ? `\`gn' failed to initialize out directory ${outDir}` :
	buildErrorMessageForNinja(cause, outDir, target);
	super(message, {cause});
	this.step = step;
	this.name = 'BuildError';
	this.target = target;
	this.outDir = outDir;
	}
	}

	/**
	* @typedef BuildResult
	* @type {object}
	* @property {number} time - wall clock time (in seconds) for the build.
	*/

	/**
	* @param target the target relative to `//out`.
	* @returns the GN args for the `target`.
	*/
	export async function prepareBuild(target) {
	const outDir = path.join(rootPath(), 'out', target);

	// Prepare the build directory first.
	const outDirStat = await fs.stat(outDir).catch(() => null);
	if (!outDirStat?.isDirectory()) {
	// Use GN to (optionally create and) initialize the \|outDir\|.
	try {
	const gnExe = vpython3ExecutablePath();
	const gnArgs = [gnPyPath(), '-q', 'gen', outDir];
	await spawn(gnExe, gnArgs);
	} catch (cause) {
	throw new BuildError(BuildStep.GN, {cause, outDir, target});
	}
	}

	return await gnArgsForTarget(target);
	}

	/** @type Map<string, Promise<Map<string, string>>> */
	const gnArgsCache = new Map();

	/**
	* @param {string} target
	*/
	export function gnArgsForTarget(target) {
	let gnArgs = gnArgsCache.get(target);
	if (!gnArgs) {
	gnArgs = (async () => {
	const outDir = path.join(rootPath(), 'out', target);
	try {
	const cwd = rootPath();
	const gnExe = vpython3ExecutablePath();
	const gnArgs = [
	gnPyPath(),
	'-q',
	'args',
	outDir,
	'--json',
	'--list',
	'--short',
	];
	const {stdout} = await spawn(gnExe, gnArgs, {cwd});
	return new Map(
	JSON.parse(stdout).map(
	arg =>
	[arg.name,
	arg.current?.value ?? arg.default?.value,
	]),
	);
	} catch {
	return new Map();
	}
	})();
	gnArgsCache.set(target, gnArgs);
	}
	return gnArgs;
	}

	/** @type Map<string, Map<string, Promise<Array<string>>>> */
	const gnRefsCache = new Map();

	function gnRefsForTarget(target, filename) {
	let gnRefsPerTarget = gnRefsCache.get(target);
	if (!gnRefsPerTarget) {
	gnRefsPerTarget = new Map();
	gnRefsCache.set(target, gnRefsPerTarget);
	}
	let gnRef = gnRefsPerTarget.get(filename);
	if (!gnRef) {
	gnRef = (async () => {
	const cwd = rootPath();
	const outDir = path.join(rootPath(), 'out', target);
	const gnExe = vpython3ExecutablePath();
	const gnArgs = [gnPyPath(), 'refs', outDir, '--as=output', filename];
	const {stdout} = await spawn(gnExe, gnArgs, {cwd});
	return stdout.trim().split('\n');
	})();
	gnRefsPerTarget.set(filename, gnRef);
	}
	return gnRef;
	}

	/**
	*
	* @param {string} target
	* @param {string[]=} filenames
	* @returns {Promise<string[]>}
	*/
	async function computeBuildTargetsForFiles(target, filenames) {
	const SUPPORTED_EXTENSIONS = ['.css', '.ts'];
	if (filenames && filenames.length &&
	filenames.every(
	filename => SUPPORTED_EXTENSIONS.includes(path.extname(filename)),
	)) {
	if (isInChromiumDirectory().isInChromium) {
	filenames = filenames.map(
	filename => path.join('third_party', 'devtools-frontend', 'src', filename),
	);
	}
	const gnArgs = await gnArgsForTarget(target);
	if (gnArgs.get('devtools_bundle') === 'false') {
	try {
	const gnRefs = (await Promise.all(
	filenames.map(filename => gnRefsForTarget(target, filename)),
	))
	.flat();
	if (gnRefs.length) {
	// If there are any changes to TypeScript files, we need to also rebuild the
	// `en-US.json`, as otherwise the changes to `UIStrings` aren't picked up.
	if (filenames.some(filename => path.extname(filename) === '.ts')) {
	gnRefs.push('collect_strings');
	}
	return gnRefs;
	}
	} catch (error) {
	console.error(error);
	}
	}
	}

	return ['devtools_all_files'];
	}

	/**
	* @param {string} target
	* @param {{ filenames?: string[], signal?: AbortSignal}} options
	* @returns a `BuildResult` with statistics for the build.
	*/
	export async function build(target, options = {}) {
	const startTime = performance.now();
	const outDir = path.join(rootPath(), 'out', target);

	// Build just the devtools-frontend resources in \|outDir\|. This is important
	// since we might be running in a full Chromium checkout and certainly don't
	// want to build all of Chromium first.
	const buildTargets = await computeBuildTargetsForFiles(
	target,
	options.filenames,
	);
	try {
	const autoninjaExe = vpython3ExecutablePath();
	const autoninjaArgs = [autoninjaPyPath(), '-C', outDir, ...buildTargets];
	await spawn(autoninjaExe, autoninjaArgs, {
	shell: true,
	signal: options.signal,
	});
	} catch (cause) {
	if (cause.name === 'AbortError') {
	throw cause;
	}
	throw new BuildError(BuildStep.AUTONINJA, {cause, outDir, target});
	}

	// Report the build result.
	const time = (performance.now() - startTime) / 1000;
	return {time};
	}