@netlify/build 29.0.0-rc → 29.0.0

package/lib/plugins/child/status.js

@@ -0,0 +1,63 @@
+import isPlainObj from 'is-plain-obj';
+import mapObj from 'map-obj';
+import { addErrorInfo } from '../../error/info.js';
+// Report status information to the UI
+export const show = function (runState, showArgs) {
+    validateShowArgs(showArgs);
+    const { title, summary, text, extraData } = removeEmptyStrings(showArgs);
+    runState.status = { state: 'success', title, summary, text, extraData };
+};
+// Validate arguments of `utils.status.show()`
+const validateShowArgs = function (showArgs) {
+    try {
+        validateShowArgsObject(showArgs);
+        const { title, summary, text, extraData, ...otherArgs } = showArgs;
+        validateShowArgsKeys(otherArgs);
+        Object.entries({ title, summary, text }).forEach(validateStringArg);
+        validateShowArgsSummary(summary);
+        validateShowArgsExtraData(extraData);
+    }
+    catch (error) {
+        error.message = `utils.status.show() ${error.message}`;
+        addErrorInfo(error, { type: 'pluginValidation' });
+        throw error;
+    }
+};
+const validateShowArgsObject = function (showArgs) {
+    if (showArgs === undefined) {
+        throw new Error('requires an argument');
+    }
+    if (!isPlainObj(showArgs)) {
+        throw new Error('argument must be a plain object');
+    }
+};
+const validateShowArgsKeys = function (otherArgs) {
+    const otherKeys = Object.keys(otherArgs).map((arg) => `"${arg}"`);
+    if (otherKeys.length !== 0) {
+        throw new Error(`must only contain "title", "summary" or "text" properties, not ${otherKeys.join(', ')}`);
+    }
+};
+const validateStringArg = function ([key, value]) {
+    if (value !== undefined && typeof value !== 'string') {
+        throw new Error(`"${key}" property must be a string`);
+    }
+};
+const validateShowArgsSummary = function (summary) {
+    if (summary === undefined || summary.trim() === '') {
+        throw new Error('requires specifying a "summary" property');
+    }
+};
+const validateShowArgsExtraData = function (extraData) {
+    if (extraData !== undefined && Array.isArray(extraData) === false) {
+        throw new TypeError('provided extra data must be an array');
+    }
+};
+const removeEmptyStrings = function (showArgs) {
+    return mapObj(showArgs, removeEmptyString);
+};
+const removeEmptyString = function (key, value) {
+    if (typeof value === 'string' && value.trim() === '') {
+        return [key];
+    }
+    return [key, value];
+};

package/lib/plugins/child/typescript.js

@@ -0,0 +1,28 @@
+import { extname } from 'path';
+import { register } from 'ts-node';
+import { addErrorInfo } from '../../error/info.js';
+// Allow local plugins to be written with TypeScript.
+// Local plugins cannot be transpiled by the build command since they can be run
+// before it. Therefore, we type-check and transpile them automatically using
+// `ts-node`.
+export const registerTypeScript = function (pluginPath) {
+    if (!isTypeScriptPlugin(pluginPath)) {
+        return;
+    }
+    return register();
+};
+// On TypeScript errors, adds information about the `ts-node` configuration,
+// which includes the resolved `tsconfig.json`.
+export const addTsErrorInfo = function (error, tsNodeService) {
+    if (tsNodeService === undefined) {
+        return;
+    }
+    const { config: { raw: { compilerOptions }, }, options: realTsNodeOptions, } = tsNodeService;
+    // filter out functions as they cannot be serialized
+    const tsNodeOptions = Object.fromEntries(Object.entries(realTsNodeOptions).filter(([, val]) => typeof val !== 'function'));
+    addErrorInfo(error, { tsConfig: { compilerOptions, tsNodeOptions } });
+};
+const isTypeScriptPlugin = function (pluginPath) {
+    return TYPESCRIPT_EXTENSIONS.has(extname(pluginPath));
+};
+const TYPESCRIPT_EXTENSIONS = new Set(['.ts', '.tsx', '.mts', '.cts']);

package/lib/plugins/child/utils.js

@@ -0,0 +1,42 @@
+import { bindOpts as cacheBindOpts } from '@netlify/cache-utils';
+import { add as functionsAdd, list as functionsList, listAll as functionsListAll } from '@netlify/functions-utils';
+import { getGitUtils } from '@netlify/git-utils';
+import { run, runCommand } from '@netlify/run-utils';
+import { failBuild, failPlugin, cancelBuild, failPluginWithWarning } from '../error.js';
+import { isSoftFailEvent } from '../events.js';
+import { addLazyProp } from './lazy.js';
+import { show } from './status.js';
+// Retrieve the `utils` argument.
+export const getUtils = function ({ event, constants: { FUNCTIONS_SRC, INTERNAL_FUNCTIONS_SRC, CACHE_DIR }, runState, }) {
+    run.command = runCommand;
+    const build = getBuildUtils(event);
+    const cache = getCacheUtils(CACHE_DIR);
+    const functions = getFunctionsUtils(FUNCTIONS_SRC, INTERNAL_FUNCTIONS_SRC);
+    const status = getStatusUtils(runState);
+    const utils = { build, cache, run, functions, status };
+    addLazyProp(utils, 'git', () => getGitUtils());
+    return utils;
+};
+const getBuildUtils = function (event) {
+    if (isSoftFailEvent(event)) {
+        return {
+            failPlugin,
+            failBuild: failPluginWithWarning.bind(null, 'failBuild', event),
+            cancelBuild: failPluginWithWarning.bind(null, 'cancelBuild', event),
+        };
+    }
+    return { failBuild, failPlugin, cancelBuild };
+};
+const getCacheUtils = function (CACHE_DIR) {
+    return cacheBindOpts({ cacheDir: CACHE_DIR });
+};
+const getFunctionsUtils = function (FUNCTIONS_SRC, INTERNAL_FUNCTIONS_SRC) {
+    const functionsDirectories = [INTERNAL_FUNCTIONS_SRC, FUNCTIONS_SRC].filter(Boolean);
+    const add = (src) => functionsAdd(src, INTERNAL_FUNCTIONS_SRC, { fail: failBuild });
+    const list = functionsList.bind(null, functionsDirectories, { fail: failBuild });
+    const listAll = functionsListAll.bind(null, functionsDirectories, { fail: failBuild });
+    return { add, list, listAll };
+};
+const getStatusUtils = function (runState) {
+    return { show: show.bind(undefined, runState) };
+};

package/lib/plugins/child/validate.js

@@ -0,0 +1,31 @@
+import { addErrorInfo } from '../../error/info.js';
+import { serializeArray } from '../../log/serialize.js';
+import { DEV_EVENTS, EVENTS } from '../events.js';
+// Validate the shape of a plugin return value
+export const validatePlugin = function (logic) {
+    try {
+        // This validation must work with the return value of `import()` which has
+        // a `Module` prototype, not `Object`
+        if (typeof logic !== 'object' || logic === null) {
+            throw new Error('Plugin must be an object or a function');
+        }
+        Object.entries(logic).forEach(([propName, value]) => {
+            validateEventHandler(value, propName);
+        });
+    }
+    catch (error) {
+        addErrorInfo(error, { type: 'pluginValidation' });
+        throw error;
+    }
+};
+// All other properties are event handlers
+const validateEventHandler = function (value, propName) {
+    if (!EVENTS.includes(propName) && !DEV_EVENTS.includes(propName)) {
+        throw new Error(`Invalid event '${propName}'.
+Please use a valid event name. One of:
+${serializeArray(EVENTS)}`);
+    }
+    if (typeof value !== 'function') {
+        throw new TypeError(`Invalid event handler '${propName}': must be a function`);
+    }
+};

package/lib/plugins/compatibility.js

@@ -0,0 +1,104 @@
+import pEvery from 'p-every';
+import pLocate from 'p-locate';
+import semver from 'semver';
+import { importJsonFile } from '../utils/json.js';
+import { resolvePath } from '../utils/resolve.js';
+// Retrieve the `expectedVersion` of a plugin:
+//  - This is the version which should be run
+//  - This takes version pinning into account
+//  - If this does not match the currently cached version, it is installed first
+// This is also used to retrieve the `compatibleVersion` of a plugin
+//  - This is the most recent version compatible with this site
+//  - This is the same logic except it does not use version pinning
+//  - This is only used to print a warning message when the `compatibleVersion`
+//    is older than the currently used version.
+export const getExpectedVersion = async function ({ versions, nodeVersion, packageJson, buildDir, pinnedVersion }) {
+    const { version, conditions } = await getCompatibleEntry({
+        versions,
+        nodeVersion,
+        packageJson,
+        buildDir,
+        pinnedVersion,
+    });
+    const compatWarning = getCompatWarning(conditions);
+    return { version, compatWarning };
+};
+// This function finds the right `compatibility` entry to use with the plugin.
+//  - `compatibitlity` entries are meant for backward compatibility
+//    Plugins should define each major version in `compatibility`.
+//  - The entries are sorted from most to least recent version.
+//  - After their first successful run, plugins are pinned by their major
+//    version which is passed as `pinnedVersion` to the next builds.
+// When the plugin does not have a `pinnedVersion`, we use the most recent
+// `compatibility` entry with a successful condition.
+// When the plugin has a `pinnedVersion`, we do not use the `compatibility`
+// conditions. Instead, we just use the most recent entry with a `version`
+// matching `pinnedVersion`.
+// When no `compatibility` entry matches, we use:
+//  - If there is a `pinnedVersion`, use it unless `latestVersion` matches it
+//  - Otherwise, use `latestVersion`
+const getCompatibleEntry = async function ({ versions, nodeVersion, packageJson, buildDir, pinnedVersion }) {
+    if (pinnedVersion !== undefined) {
+        const matchingVersion = versions.find(({ version }) => semver.satisfies(version, pinnedVersion, { includePrerelease: true }));
+        return matchingVersion || { version: pinnedVersion };
+    }
+    const versionsWithConditions = versions.filter(hasConditions);
+    const compatibleEntry = await pLocate(versionsWithConditions, ({ conditions }) => matchesCompatField({ conditions, nodeVersion, packageJson, buildDir }));
+    return compatibleEntry || { version: versions[0].version };
+};
+// Ignore entries without conditions. Those are used to specify breaking
+// changes, i.e. meant to be used for version pinning instead.
+const hasConditions = function ({ conditions }) {
+    return conditions.length !== 0;
+};
+const matchesCompatField = async function ({ conditions, nodeVersion, packageJson, buildDir }) {
+    return await pEvery(conditions, ({ type, condition }) => CONDITIONS[type].test(condition, { nodeVersion, packageJson, buildDir }));
+};
+// Retrieve warning message shown when using an older version with `compatibility`
+const getCompatWarning = function (conditions = []) {
+    return conditions.map(getConditionWarning).join(', ');
+};
+const getConditionWarning = function ({ type, condition }) {
+    return CONDITIONS[type].warning(condition);
+};
+// Plugins can use `compatibility.{version}.nodeVersion: 'allowedNodeVersion'`
+// to deliver different plugin versions based on the Node.js version
+const nodeVersionTest = function (allowedNodeVersion, { nodeVersion }) {
+    return semver.satisfies(nodeVersion, allowedNodeVersion);
+};
+const nodeVersionWarning = function (allowedNodeVersion) {
+    return `Node.js ${allowedNodeVersion}`;
+};
+const siteDependenciesTest = async function (allowedSiteDependencies, { packageJson: { devDependencies, dependencies }, buildDir }) {
+    const siteDependencies = { ...devDependencies, ...dependencies };
+    return await pEvery(Object.entries(allowedSiteDependencies), ([dependencyName, allowedVersion]) => siteDependencyTest({ dependencyName, allowedVersion, siteDependencies, buildDir }));
+};
+const siteDependencyTest = async function ({ dependencyName, allowedVersion, siteDependencies, buildDir }) {
+    const siteDependency = siteDependencies[dependencyName];
+    if (typeof siteDependency !== 'string') {
+        return false;
+    }
+    // if this is a valid version we can apply the rule directly
+    if (semver.clean(siteDependency) !== null) {
+        return semver.satisfies(siteDependency, allowedVersion);
+    }
+    try {
+        // if this is a range we need to get the exact version
+        const packageJsonPath = await resolvePath(`${dependencyName}/package.json`, buildDir);
+        const { version } = await importJsonFile(packageJsonPath);
+        return semver.satisfies(version, allowedVersion);
+    }
+    catch {
+        return false;
+    }
+};
+const siteDependenciesWarning = function (allowedSiteDependencies) {
+    return Object.entries(allowedSiteDependencies).map(siteDependencyWarning).join(',');
+};
+const siteDependencyWarning = function ([dependencyName, allowedVersion]) {
+    return `${dependencyName}@${allowedVersion}`;
+};
+export const CONDITIONS = {
+    nodeVersion: { test: nodeVersionTest, warning: nodeVersionWarning },
+    siteDependencies: { test: siteDependenciesTest, warning: siteDependenciesWarning },
+};

package/{src → lib}/plugins/error.js

@@ -1,50 +1,46 @@
-import { addErrorInfo } from '../error/info.js'
-import { logFailPluginWarning } from '../log/messages/plugins.js'
-
+import { addErrorInfo } from '../error/info.js';
+import { logFailPluginWarning } from '../log/messages/plugins.js';
 // Stop build.
 // As opposed to throwing an error directly or to uncaught exceptions, this is
 // displayed as a user error, not an implementation error.
 export const failBuild = function (message, opts) {
-  throw normalizeError('failBuild', failBuild, message, opts)
-}
-
+    throw normalizeError('failBuild', failBuild, message, opts);
+};
 // Stop plugin. Same as `failBuild` but only stops plugin not whole build
 export const failPlugin = function (message, opts) {
-  throw normalizeError('failPlugin', failPlugin, message, opts)
-}
-
+    throw normalizeError('failPlugin', failPlugin, message, opts);
+};
 // Cancel build. Same as `failBuild` except it marks the build as "canceled".
 export const cancelBuild = function (message, opts) {
-  throw normalizeError('cancelBuild', cancelBuild, message, opts)
-}
-
+    throw normalizeError('cancelBuild', cancelBuild, message, opts);
+};
 // `onSuccess`, `onEnd` and `onError` cannot cancel the build since they are run
 // or might be run after deployment. When calling `failBuild()` or
 // `cancelBuild()`, `failPlugin()` is run instead and a warning is printed.
 export const failPluginWithWarning = function (methodName, event, message, opts) {
-  logFailPluginWarning(methodName, event)
-  failPlugin(message, opts)
-}
-
+    logFailPluginWarning(methodName, event);
+    failPlugin(message, opts);
+};
 // An `error` option can be passed to keep the original error message and
 // stack trace. An additional `message` string is always required.
-const normalizeError = function (type, func, message, { error } = {}) {
-  const errorA = getError(error, message, func)
-  addErrorInfo(errorA, { type })
-  return errorA
-}
-
+const normalizeError = function (type, func, message, { error, errorMetadata } = {}) {
+    const errorA = getError(error, message, func);
+    addErrorInfo(errorA, { type, errorMetadata });
+    return errorA;
+};
 const getError = function (error, message, func) {
-  if (error instanceof Error) {
-    // This might fail if `name` is a getter or is non-writable.
-    try {
-      error.message = `${message}\n${error.message}`
-    } catch {}
-    return error
-  }
-
-  const errorA = new Error(message)
-  // Do not include function itself in the stack trace
-  Error.captureStackTrace(errorA, func)
-  return errorA
-}
+    if (error instanceof Error) {
+        // This might fail if `name` is a getter or is non-writable.
+        try {
+            error.message = `${message}\n${error.message}`;
+        }
+        catch {
+            // continue regardless error
+        }
+        return error;
+    }
+    const errorA = new Error(message);
+    // Do not include function itself in the stack trace
+    Error.captureStackTrace(errorA, func);
+    return errorA;
+};

package/{src → lib}/plugins/events.js

@@ -1,17 +1,12 @@
-export { DEV_EVENTS, EVENTS } from '@netlify/config'
-
+export { DEV_EVENTS, EVENTS } from '@netlify/config';
 const isAmongEvents = function (events, event) {
-  return events.includes(event)
-}
-
+    return events.includes(event);
+};
 // Check if failure of the event should not make the build fail
-export const isSoftFailEvent = isAmongEvents.bind(null, ['onSuccess', 'onError', 'onEnd'])
-
+export const isSoftFailEvent = isAmongEvents.bind(null, ['onSuccess', 'onError', 'onEnd']);
 // Check if the event is triggered even when the build fails
-export const runsAlsoOnBuildFailure = isAmongEvents.bind(null, ['onError', 'onEnd'])
-
+export const runsAlsoOnBuildFailure = isAmongEvents.bind(null, ['onError', 'onEnd']);
 // Check if the event is only triggered when the build fails
-export const runsOnlyOnBuildFailure = isAmongEvents.bind(null, ['onError'])
-
+export const runsOnlyOnBuildFailure = isAmongEvents.bind(null, ['onError']);
 // Check if the event is happening after deploy
-export const runsAfterDeploy = isAmongEvents.bind(null, ['onSuccess', 'onEnd'])
+export const runsAfterDeploy = isAmongEvents.bind(null, ['onSuccess', 'onEnd']);

package/lib/plugins/expected_version.js

@@ -0,0 +1,81 @@
+import semver from 'semver';
+import { addErrorInfo } from '../error/info.js';
+import { importJsonFile } from '../utils/json.js';
+import { resolvePath } from '../utils/resolve.js';
+import { getExpectedVersion } from './compatibility.js';
+import { getPluginsList } from './list.js';
+// When using plugins in our official list, those are installed in .netlify/plugins/
+// We ensure that the last version that's been approved is always the one being used.
+// We also ensure that the plugin is our official list.
+export const addExpectedVersions = async function ({ pluginsOptions, autoPluginsDir, packageJson, debug, logs, buildDir, testOpts, featureFlags, }) {
+    if (!pluginsOptions.some(needsExpectedVersion)) {
+        return pluginsOptions;
+    }
+    const pluginsList = await getPluginsList({ debug, logs, testOpts });
+    return await Promise.all(pluginsOptions.map((pluginOptions) => addExpectedVersion({ pluginsList, autoPluginsDir, packageJson, pluginOptions, buildDir, featureFlags })));
+};
+// Any `pluginOptions` with `expectedVersion` set will be automatically installed
+const addExpectedVersion = async function ({ pluginsList, autoPluginsDir, packageJson, pluginOptions, pluginOptions: { packageName, pluginPath, loadedFrom, nodeVersion, pinnedVersion }, buildDir, featureFlags, }) {
+    if (!needsExpectedVersion(pluginOptions)) {
+        return pluginOptions;
+    }
+    if (pluginsList[packageName] === undefined) {
+        validateUnlistedPlugin(packageName, loadedFrom);
+        return pluginOptions;
+    }
+    const unfilteredVersions = pluginsList[packageName];
+    const versions = filterVersions(unfilteredVersions, featureFlags);
+    const [{ version: latestVersion, migrationGuide }] = versions;
+    const [{ version: expectedVersion }, { version: compatibleVersion, compatWarning }] = await Promise.all([
+        getExpectedVersion({ versions, nodeVersion, packageJson, buildDir, pinnedVersion }),
+        getExpectedVersion({ versions, nodeVersion, packageJson, buildDir }),
+    ]);
+    const isMissing = await isMissingVersion({ autoPluginsDir, packageName, pluginPath, loadedFrom, expectedVersion });
+    return {
+        ...pluginOptions,
+        latestVersion,
+        expectedVersion,
+        compatibleVersion,
+        migrationGuide,
+        compatWarning,
+        isMissing,
+    };
+};
+// Feature flagged versions are removed unless the feature flag is present.
+//  - This is done before conditions are applied since, unlike conditions,
+//    users cannot always choose to enable a feature flag.
+const filterVersions = function (unfilteredVersions, featureFlags) {
+    return unfilteredVersions.filter(({ featureFlag }) => featureFlag === undefined || featureFlags[featureFlag]);
+};
+// Checks whether plugin should be installed due to the wrong version being used
+// (either outdated, or mismatching compatibility requirements)
+const isMissingVersion = async function ({ autoPluginsDir, packageName, pluginPath, loadedFrom, expectedVersion }) {
+    return (
+    // We always respect the versions specified in `package.json`, as opposed
+    // to auto-installed plugins
+    loadedFrom !== 'package.json' &&
+        // Plugin was not previously installed
+        (pluginPath === undefined ||
+            // Plugin was previously installed but a different version should be used
+            !semver.satisfies(await getAutoPluginVersion(packageName, autoPluginsDir), expectedVersion)));
+};
+const getAutoPluginVersion = async function (packageName, autoPluginsDir) {
+    const packageJsonPath = await resolvePath(`${packageName}/package.json`, autoPluginsDir);
+    const { version } = await importJsonFile(packageJsonPath);
+    return version;
+};
+const needsExpectedVersion = function ({ loadedFrom }) {
+    return loadedFrom === 'auto_install' || loadedFrom === 'package.json';
+};
+// Plugins that are not in our official list can only be specified in
+// `netlify.toml` providing they are also installed in the site's package.json.
+// Otherwise, the build should fail.
+const validateUnlistedPlugin = function (packageName, loadedFrom) {
+    if (loadedFrom === 'package.json') {
+        return;
+    }
+    const error = new Error(`Plugins must be installed either in the Netlify App or in "package.json".
+Please run "npm install -D ${packageName}" or "yarn add -D ${packageName}".`);
+    addErrorInfo(error, { type: 'resolveConfig' });
+    throw error;
+};

package/lib/plugins/internal.js

@@ -0,0 +1,10 @@
+const NETLIFY_MAINTAINED_PLUGINS = new Set([
+    'netlify_plugin_gatsby_cache',
+    'netlify_plugin_sitemap',
+    'netlify_plugin_debug_cache',
+    'netlify_plugin_is_website_vulnerable',
+    'netlify_plugin_lighthouse',
+    'netlify_plugin_nextjs',
+    'netlify_plugin_gatsby',
+]);
+export const isNetlifyMaintainedPlugin = (pluginPackage) => NETLIFY_MAINTAINED_PLUGINS.has(pluginPackage);

package/lib/plugins/ipc.js

@@ -0,0 +1,120 @@
+import process from 'process';
+import { promisify } from 'util';
+import { pEvent } from 'p-event';
+import { v4 as uuidv4 } from 'uuid';
+import { jsonToError, errorToJson } from '../error/build.js';
+import { addErrorInfo } from '../error/info.js';
+import { logSendingEventToChild, logSentEventToChild, logReceivedEventFromChild, logSendingEventToParent, } from '../log/messages/ipc.js';
+// Send event from child to parent process then wait for response
+// We need to fire them in parallel because `process.send()` can be slow
+// to await, i.e. child might send response before parent start listening for it
+export const callChild = async function ({ childProcess, eventName, payload, logs, verbose }) {
+    const callId = uuidv4();
+    const [response] = await Promise.all([
+        getEventFromChild(childProcess, callId),
+        sendEventToChild({ childProcess, callId, eventName, payload, logs, verbose }),
+    ]);
+    logReceivedEventFromChild(logs, verbose);
+    return response;
+};
+// Receive event from child to parent process
+// Wait for either:
+//  - `message` event with a specific `callId`
+//  - `message` event with an `error` `callId` indicating an exception in the
+//    child process
+//  - child process `exit`
+// In the later two cases, we propagate the error.
+// We need to make `p-event` listeners are properly cleaned up too.
+export const getEventFromChild = async function (childProcess, callId) {
+    if (childProcessHasExited(childProcess)) {
+        throw getChildExitError('Could not receive event from child process because it already exited.');
+    }
+    const messagePromise = pEvent(childProcess, 'message', { filter: ([actualCallId]) => actualCallId === callId });
+    const errorPromise = pEvent(childProcess, 'message', { filter: ([actualCallId]) => actualCallId === 'error' });
+    const exitPromise = pEvent(childProcess, 'exit', { multiArgs: true });
+    try {
+        return await Promise.race([getMessage(messagePromise), getError(errorPromise), getExit(exitPromise)]);
+    }
+    finally {
+        messagePromise.cancel();
+        errorPromise.cancel();
+        exitPromise.cancel();
+    }
+};
+const childProcessHasExited = function (childProcess) {
+    return !childProcess.connected || childProcess.signalCode !== null || childProcess.exitCode !== null;
+};
+const getMessage = async function (messagePromise) {
+    const [, response] = await messagePromise;
+    return response;
+};
+const getError = async function (errorPromise) {
+    const [, error] = await errorPromise;
+    throw jsonToError(error);
+};
+const getExit = async function (exitPromise) {
+    const [exitCode, signal] = await exitPromise;
+    throw getChildExitError(`Plugin exited with exit code ${exitCode} and signal ${signal}.`);
+};
+// Plugins should not terminate processes explicitly:
+//  - It prevents specifying error messages to the end users
+//  - It makes it impossible to distinguish between bugs (such as infinite loops) and user errors
+//  - It complicates child process orchestration. For example if an async operation
+//    of a previous event handler is still running, it would be aborted if another
+//    is terminating the process.
+const getChildExitError = function (message) {
+    const error = new Error(`${message}\n${EXIT_WARNING}`);
+    addErrorInfo(error, { type: 'ipc' });
+    return error;
+};
+const EXIT_WARNING = `The plugin might have exited due to a bug terminating the process, such as an infinite loop.
+The plugin might also have explicitly terminated the process, for example with process.exit().
+Plugin methods should instead:
+  - on success: return
+  - on failure: call utils.build.failPlugin() or utils.build.failBuild()`;
+// Send event from parent to child process
+const sendEventToChild = async function ({ childProcess, callId, eventName, payload, logs, verbose }) {
+    logSendingEventToChild(logs, verbose);
+    const payloadA = serializePayload(payload);
+    await promisify(childProcess.send.bind(childProcess))([callId, eventName, payloadA]);
+    logSentEventToChild(logs, verbose);
+};
+// Respond to events from parent to child process.
+// This runs forever until `childProcess.kill()` is called.
+// We need to use `new Promise()` and callbacks because this runs forever.
+export const getEventsFromParent = function (callback) {
+    return new Promise((resolve, reject) => {
+        process.on('message', async (message) => {
+            try {
+                const [callId, eventName, payload] = message;
+                const payloadA = parsePayload(payload);
+                return await callback(callId, eventName, payloadA);
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    });
+};
+// Send event from child to parent process
+export const sendEventToParent = async function (callId, payload, verbose, error) {
+    logSendingEventToParent(verbose, error);
+    await promisify(process.send.bind(process))([callId, payload]);
+};
+// Error static properties are not serializable through `child_process`
+// (which uses `v8.serialize()` under the hood) so we need to convert from/to
+// plain objects.
+const serializePayload = function ({ error = {}, error: { name } = {}, ...payload }) {
+    if (name === undefined) {
+        return payload;
+    }
+    const errorA = errorToJson(error);
+    return { ...payload, error: errorA };
+};
+const parsePayload = function ({ error = {}, error: { name } = {}, ...payload }) {
+    if (name === undefined) {
+        return payload;
+    }
+    const errorA = jsonToError(error);
+    return { ...payload, error: errorA };
+};