@netlify/build 29.0.1-rc → 29.0.2

package/lib/install/missing.js

@@ -0,0 +1,54 @@
+import { promises as fs } from 'fs';
+import { normalize } from 'path';
+import { pathExists } from 'path-exists';
+import { isFile } from 'path-type';
+import { logInstallMissingPlugins } from '../log/messages/install.js';
+import { addExactDependencies } from './main.js';
+// Automatically install plugins if not already installed.
+// Since this is done under the hood, we always use `npm` with specific `npm`
+// options. We do not allow configure the package manager nor its options.
+// Users requiring `yarn` or custom npm/yarn flags should install the plugin in
+// their `package.json`.
+export const installMissingPlugins = async function ({ missingPlugins, autoPluginsDir, mode, logs }) {
+    const packages = missingPlugins.map(getPackage);
+    logInstallMissingPlugins(logs, packages);
+    await createAutoPluginsDir(logs, autoPluginsDir);
+    await addExactDependencies({ packageRoot: autoPluginsDir, isLocal: mode !== 'buildbot', packages });
+};
+// We pin the version without using semver ranges ^ nor ~
+const getPackage = function ({ packageName, expectedVersion }) {
+    return `${packageName}@${expectedVersion}`;
+};
+const createAutoPluginsDir = async function (logs, autoPluginsDir) {
+    await ensureDir(logs, autoPluginsDir);
+    await createPackageJson(autoPluginsDir);
+};
+// Create the directory if it does not exist
+const ensureDir = async function (logs, autoPluginsDir) {
+    if (await pathExists(autoPluginsDir)) {
+        return;
+    }
+    // If `.netlify` exists but is not a directory, we remove it first
+    const autoPluginsParent = normalize(`${autoPluginsDir}/..`);
+    if (await isFile(autoPluginsParent)) {
+        await fs.unlink(autoPluginsParent);
+    }
+    await fs.mkdir(autoPluginsDir, { recursive: true });
+};
+// Create a dummy `package.json` so we can run `npm install` and get a lock file
+const createPackageJson = async function (autoPluginsDir) {
+    const packageJsonPath = `${autoPluginsDir}/package.json`;
+    if (await pathExists(packageJsonPath)) {
+        return;
+    }
+    const packageJsonContent = JSON.stringify(AUTO_PLUGINS_PACKAGE_JSON, null, 2);
+    await fs.writeFile(packageJsonPath, packageJsonContent);
+};
+const AUTO_PLUGINS_PACKAGE_JSON = {
+    name: 'netlify-local-plugins',
+    description: 'This directory contains Build plugins that have been automatically installed by Netlify.',
+    version: '1.0.0',
+    private: true,
+    author: 'Netlify',
+    license: 'MIT',
+};

package/lib/log/colors.js

@@ -0,0 +1,28 @@
+import { inspect } from 'util';
+import supportsColor from 'supports-color';
+const hasColors = () => supportsColor.stdout !== false;
+/**
+ * Plugin child processes use `stdio: 'pipe'` so they are always
+ * non-interactive even if the parent is an interactive TTY. This means they
+ * would normally lose colors. If the parent has colors, we pass an environment
+ * variable to the child process to force colors.
+ */
+export const getParentColorEnv = function () {
+    if (!hasColors()) {
+        return {};
+    }
+    return { FORCE_COLOR: '1' };
+};
+/**
+ * Child processes and the buildbot relies on `FORCE_COLOR=1` to set colors.
+ * However `utils.inspect()` (used by `console.log()`) uses
+ * `process.stdout.hasColors` which is always `undefined` when the TTY is
+ * non-interactive. So we need to set `util.inspect.defaultOptions.colors`
+ * manually both in plugin processes.
+ */
+export const setInspectColors = function () {
+    if (!hasColors()) {
+        return;
+    }
+    inspect.defaultOptions.colors = true;
+};

package/lib/log/description.js

@@ -0,0 +1,21 @@
+export const getBuildCommandDescription = function (buildCommandOrigin) {
+    return BUILD_COMMAND_DESCRIPTIONS[buildCommandOrigin];
+};
+const BUILD_COMMAND_DESCRIPTIONS = {
+    ui: 'Build command from Netlify app',
+    config: 'build.command from netlify.toml',
+    inline: 'build.command from a plugin',
+};
+/** Retrieve human-friendly plugin origin */
+export const getPluginOrigin = function (loadedFrom, origin) {
+    const originName = PLUGIN_ORIGINS[origin];
+    if (loadedFrom === 'package.json') {
+        return `from ${originName} and package.json`;
+    }
+    return `from ${originName}`;
+};
+const PLUGIN_ORIGINS = {
+    core: 'core',
+    ui: 'Netlify app',
+    config: 'netlify.toml',
+};

package/lib/log/header.js

@@ -0,0 +1,14 @@
+import stringWidth from 'string-width';
+const HEADER_MIN_WIDTH = 60;
+const PADDING_WIDTH = 2;
+/** Print a rectangular header */
+export const getHeader = function (message) {
+    const messageWidth = stringWidth(message);
+    const headerWidth = Math.max(HEADER_MIN_WIDTH, messageWidth);
+    const line = '─'.repeat(headerWidth + PADDING_WIDTH * 2);
+    const paddingLeft = ' '.repeat(PADDING_WIDTH);
+    const paddingRight = ' '.repeat(PADDING_WIDTH + headerWidth - messageWidth);
+    return `${line}
+${paddingLeft}${message}${paddingRight}
+${line}`;
+};

package/lib/log/header_func.js

@@ -0,0 +1,13 @@
+import { parseErrorInfo } from '../error/parse/parse.js';
+import { logHeader, logErrorHeader } from './logger.js';
+/** Retrieve successful or error header depending on whether `error` exists */
+export const getLogHeaderFunc = function (error) {
+    if (error === undefined) {
+        return logHeader;
+    }
+    const { severity } = parseErrorInfo(error);
+    if (severity === 'none') {
+        return logHeader;
+    }
+    return logErrorHeader;
+};

package/lib/log/logger.js

@@ -0,0 +1,140 @@
+import { createWriteStream } from 'fs';
+import figures from 'figures';
+import indentString from 'indent-string';
+import { getHeader } from './header.js';
+import { serializeArray, serializeObject } from './serialize.js';
+import { THEME } from './theme.js';
+const INDENT_SIZE = 2;
+/**
+ * We need to add a zero width space character in empty lines. Otherwise the
+ * buildbot removes those due to a bug: https://github.com/netlify/buildbot/issues/595
+ */
+const EMPTY_LINES_REGEXP = /^\s*$/gm;
+const EMPTY_LINE = '\u{200B}';
+/**
+ * When the `buffer` option is true, we return logs instead of printing them
+ * on the console. The logs are accumulated in a `logs` array variable.
+ */
+export const getBufferLogs = (config) => {
+    const { buffer = false } = config;
+    if (!buffer) {
+        return;
+    }
+    return { stdout: [], stderr: [] };
+};
+// Core logging utility, used by the other methods.
+// This should be used instead of `console.log()` as it allows us to instrument
+// how any build logs is being printed.
+export const log = function (logs, string, config = {}) {
+    const { indent = false, color } = config;
+    const stringA = indent ? indentString(string, INDENT_SIZE) : string;
+    const stringB = String(stringA).replace(EMPTY_LINES_REGEXP, EMPTY_LINE);
+    const stringC = color === undefined ? stringB : color(stringB);
+    if (logs !== undefined) {
+        // `logs` is a stateful variable
+        logs.stdout.push(stringC);
+        return;
+    }
+    console.log(stringC);
+};
+const serializeIndentedArray = function (array) {
+    return serializeArray(array.map(serializeIndentedItem));
+};
+const serializeIndentedItem = function (item) {
+    return indentString(item, INDENT_SIZE + 1).trimStart();
+};
+export const logError = function (logs, string, opts = {}) {
+    log(logs, string, { color: THEME.errorLine, ...opts });
+};
+export const logWarning = function (logs, string, opts = {}) {
+    log(logs, string, { color: THEME.warningLine, ...opts });
+};
+// Print a message that is under a header/subheader, i.e. indented
+export const logMessage = function (logs, string, opts = {}) {
+    log(logs, string, { indent: true, ...opts });
+};
+// Print an object
+export const logObject = function (logs, object, opts) {
+    logMessage(logs, serializeObject(object), opts);
+};
+// Print an array
+export const logArray = function (logs, array, opts = {}) {
+    logMessage(logs, serializeIndentedArray(array), { color: THEME.none, ...opts });
+};
+// Print an array of errors
+export const logErrorArray = function (logs, array, opts = {}) {
+    logMessage(logs, serializeIndentedArray(array), { color: THEME.errorLine, ...opts });
+};
+// Print an array of warnings
+export const logWarningArray = function (logs, array, opts = {}) {
+    logMessage(logs, serializeIndentedArray(array), { color: THEME.warningLine, ...opts });
+};
+// Print a main section header
+export const logHeader = function (logs, string, opts = {}) {
+    log(logs, `\n${getHeader(string)}`, { color: THEME.header, ...opts });
+};
+// Print a main section header, when an error happened
+export const logErrorHeader = function (logs, string, opts = {}) {
+    logHeader(logs, string, { color: THEME.errorHeader, ...opts });
+};
+// Print a sub-section header
+export const logSubHeader = function (logs, string, opts = {}) {
+    log(logs, `\n${figures.pointer} ${string}`, { color: THEME.subHeader, ...opts });
+};
+// Print a sub-section header, when an error happened
+export const logErrorSubHeader = function (logs, string, opts = {}) {
+    logSubHeader(logs, string, { color: THEME.errorSubHeader, ...opts });
+};
+// Print a sub-section header, when a warning happened
+export const logWarningSubHeader = function (logs, string, opts = {}) {
+    logSubHeader(logs, string, { color: THEME.warningSubHeader, ...opts });
+};
+// Combines an array of elements into a single string, separated by a space,
+// and with basic serialization of non-string types
+const reduceLogLines = function (lines) {
+    return lines
+        .map((input) => {
+        if (input instanceof Error) {
+            return `${input.message} ${input.stack}`;
+        }
+        if (typeof input === 'object') {
+            try {
+                return JSON.stringify(input);
+            }
+            catch {
+                // Value could not be serialized to JSON, so we return the string
+                // representation.
+                return String(input);
+            }
+        }
+        return String(input);
+    })
+        .join(' ');
+};
+/**
+ * Builds a function for logging data to the system logger (i.e. hidden from
+ * the user-facing build logs)
+ */
+export const getSystemLogger = function (logs, debug, 
+/** A system log file descriptor, if non is provided it will be a noop logger */
+systemLogFile) {
+    // If the `debug` flag is used, we return a function that pipes system logs
+    // to the regular logger, as the intention is for them to end up in stdout.
+    if (debug) {
+        return (...args) => log(logs, reduceLogLines(args));
+    }
+    // If there's not a file descriptor configured for system logs and `debug`
+    // is not set, we return a no-op function that will swallow the errors.
+    if (!systemLogFile) {
+        return () => {
+            // no-op
+        };
+    }
+    // Return a function that writes to the file descriptor configured for system
+    // logs.
+    const fileDescriptor = createWriteStream('', { fd: systemLogFile });
+    fileDescriptor.on('error', () => {
+        logError(logs, 'Could not write to system log file');
+    });
+    return (...args) => fileDescriptor.write(`${reduceLogLines(args)}\n`);
+};

package/lib/log/messages/compatibility.js

@@ -0,0 +1,146 @@
+import semver from 'semver';
+import { addErrorInfo } from '../../error/info.js';
+import { isRuntime } from '../../utils/runtime.js';
+import { isPreviousMajor } from '../../utils/semver.js';
+import { getPluginOrigin } from '../description.js';
+import { logArray, logSubHeader, logWarningArray, logWarningSubHeader } from '../logger.js';
+import { THEME } from '../theme.js';
+export const logRuntime = (logs, pluginOptions) => {
+    const runtimes = pluginOptions.filter(isRuntime);
+    // Once we have more runtimes, this hardcoded check should be removed
+    if (runtimes.length !== 0) {
+        const [nextRuntime] = runtimes;
+        logSubHeader(logs, `Using Next.js Runtime - v${nextRuntime.pluginPackageJson.version}`);
+    }
+};
+export const logLoadingPlugins = function (logs, pluginsOptions, debug) {
+    const loadingPlugins = pluginsOptions
+        .filter(isNotCorePlugin)
+        // We don't want to show runtimes as plugins
+        .filter((plugin) => !isRuntime(plugin))
+        .map((pluginOptions) => getPluginDescription(pluginOptions, debug));
+    if (loadingPlugins.length === 0) {
+        return;
+    }
+    logSubHeader(logs, 'Loading plugins');
+    logArray(logs, loadingPlugins);
+};
+// We only logs plugins explicitly enabled by users
+const isNotCorePlugin = function ({ origin }) {
+    return origin !== 'core';
+};
+const getPluginDescription = function ({ packageName, pluginPackageJson: { version }, loadedFrom, origin, pinnedVersion, latestVersion, expectedVersion, compatibleVersion, }, debug) {
+    const versionedPackage = getVersionedPackage(packageName, version);
+    const pluginOrigin = getPluginOrigin(loadedFrom, origin);
+    const description = `${THEME.highlightWords(packageName)}${versionedPackage} ${pluginOrigin}`;
+    if (!debug) {
+        return description;
+    }
+    const versions = Object.entries({
+        pinned: pinnedVersion,
+        latest: latestVersion,
+        expected: expectedVersion,
+        compatible: compatibleVersion,
+    })
+        .filter(hasVersion)
+        .map(getVersionField);
+    if (versions.length === 0) {
+        return description;
+    }
+    return `${description} (${versions.join(', ')})`;
+};
+const hasVersion = function ([, version]) {
+    return version !== undefined;
+};
+const getVersionField = function ([versionFieldName, version]) {
+    return `${versionFieldName} ${version}`;
+};
+// Print a warning message when old versions plugins are used.
+// This can only happen when they are installed to `package.json`.
+// Also throws an error if the Next runtime is >= 4.0.0 || < 4.26.0
+export const logOutdatedPlugins = function (logs, pluginsOptions, featureFlags) {
+    const outdatedPlugins = pluginsOptions.filter(hasOutdatedVersion).map(getOutdatedPlugin);
+    if (outdatedPlugins.length === 0) {
+        return;
+    }
+    // TODO: remove feature flag once fully rolled out
+    if (featureFlags.plugins_break_builds_with_unsupported_plugin_versions)
+        throwIfUnsupportedPluginVersion(pluginsOptions.filter(hasOutdatedVersion));
+    logWarningSubHeader(logs, 'Outdated plugins');
+    logWarningArray(logs, outdatedPlugins);
+};
+const hasOutdatedVersion = function ({ pluginPackageJson: { version }, latestVersion }) {
+    return version !== undefined && latestVersion !== undefined && semver.lt(version, latestVersion);
+};
+const getOutdatedPlugin = function ({ packageName, pluginPackageJson: { version }, latestVersion, migrationGuide, loadedFrom, origin, }) {
+    const versionedPackage = getVersionedPackage(packageName, version);
+    const outdatedDescription = getOutdatedDescription({ latestVersion, migrationGuide, loadedFrom, origin });
+    return `${THEME.warningHighlightWords(packageName)}${versionedPackage}: ${outdatedDescription}`;
+};
+const getOutdatedDescription = function ({ latestVersion, migrationGuide, loadedFrom, origin }) {
+    const upgradeInstruction = getUpgradeInstruction(loadedFrom, origin);
+    if (migrationGuide === undefined) {
+        return `latest version is ${latestVersion}\n${upgradeInstruction}`;
+    }
+    return `latest version is ${latestVersion}\nMigration guide: ${migrationGuide}\n${upgradeInstruction}`;
+};
+const getUpgradeInstruction = function (loadedFrom, origin) {
+    if (loadedFrom === 'package.json') {
+        return 'To upgrade this plugin, please update its version in "package.json"';
+    }
+    if (origin === 'ui') {
+        return 'To upgrade this plugin, please uninstall and re-install it from the Netlify plugins directory (https://app.netlify.com/plugins)';
+    }
+    return 'To upgrade this plugin, please remove it from "netlify.toml" and install it from the Netlify plugins directory instead (https://app.netlify.com/plugins)';
+};
+// Print a warning message when plugins are using a version that is too recent
+// and does not meet some `compatibility` expectations.
+// This can only happen when they are installed to `package.json`.
+export const logIncompatiblePlugins = function (logs, pluginsOptions) {
+    const incompatiblePlugins = pluginsOptions.filter(hasIncompatibleVersion).map(getIncompatiblePlugin);
+    if (incompatiblePlugins.length === 0) {
+        return;
+    }
+    logWarningSubHeader(logs, 'Incompatible plugins');
+    logWarningArray(logs, incompatiblePlugins);
+};
+// Throws an error if the Next runtime is >= 4.0.0 || < 4.26.0, otherwise returns.
+const throwIfUnsupportedPluginVersion = function (outdatedPlugins) {
+    let packageName;
+    let version;
+    let latestVersion;
+    const nextOutdatedV4Plugin = outdatedPlugins.find((plugin) => {
+        packageName = plugin.pluginPackageJson.name;
+        version = plugin.pluginPackageJson.version;
+        latestVersion = plugin.latestVersion;
+        // https://github.com/npm/node-semver#hyphen-ranges-xyz---abc
+        // semver hyphen range is inclusive 4.0.0 - 4.25.0 is same as >= 4.0.0 || < 4.26.0;
+        return (packageName === '@netlify/plugin-nextjs' &&
+            semver.satisfies(version, '4.0.0 - 4.25.0', { includePrerelease: true }));
+    });
+    if (!nextOutdatedV4Plugin) {
+        return;
+    }
+    const error = new Error(`This site cannot be built because it is using an outdated version of the Next.js Runtime: ${packageName}@${version}. Versions greater than 4.26.0 are recommended. To upgrade this plugin, please update its version in "package.json" to the latest version: ${latestVersion}. If you cannot use a more recent version, please contact support at https://www.netlify.com/support for guidance.`);
+    addErrorInfo(error, { type: 'pluginUnsupportedVersion' });
+    throw error;
+};
+const hasIncompatibleVersion = function ({ pluginPackageJson: { version }, compatibleVersion, compatWarning }) {
+    return (compatWarning !== '' &&
+        version !== undefined &&
+        compatibleVersion !== undefined &&
+        // Using only the major version prevents printing this warning message when
+        // a site is using the right `compatibility` version, but is using the most
+        // recent version due to the time gap between `npm publish` and the
+        // `plugins.json` update
+        isPreviousMajor(compatibleVersion, version));
+};
+const getIncompatiblePlugin = function ({ packageName, pluginPackageJson: { version }, compatibleVersion, compatWarning, }) {
+    const versionedPackage = getVersionedPackage(packageName, version);
+    return `${THEME.warningHighlightWords(packageName)}${versionedPackage}: version ${compatibleVersion} is the most recent version compatible with ${compatWarning}`;
+};
+// Make sure we handle `package.json` with `version` being either `undefined`
+// or an empty string
+const getVersionedPackage = function (packageName, version = '') {
+    return version === '' ? '' : `@${version}`;
+};

package/lib/log/messages/config.js

@@ -0,0 +1,91 @@
+import { cleanupConfig } from '@netlify/config';
+import { DEFAULT_FEATURE_FLAGS } from '../../core/feature_flags.js';
+import { omit } from '../../utils/omit.js';
+import { logMessage, logObject, logSubHeader } from '../logger.js';
+import { THEME } from '../theme.js';
+export const logFlags = function (logs, flags, { debug }) {
+    const flagsA = cleanFeatureFlags(flags);
+    const hiddenFlags = debug ? HIDDEN_DEBUG_FLAGS : HIDDEN_FLAGS;
+    const flagsB = omit(flagsA, hiddenFlags);
+    logSubHeader(logs, 'Flags');
+    logObject(logs, flagsB);
+};
+// We only show feature flags related to `@netlify/build`.
+// Also, we only print enabled feature flags.
+const cleanFeatureFlags = function ({ featureFlags = {}, ...flags }) {
+    const cleanedFeatureFlags = Object.entries(featureFlags)
+        .filter(shouldPrintFeatureFlag)
+        .map(([featureFlagName]) => featureFlagName);
+    return cleanedFeatureFlags.length === 0 ? flags : { ...flags, featureFlags: cleanedFeatureFlags };
+};
+const shouldPrintFeatureFlag = function ([featureFlagName, enabled]) {
+    return enabled && featureFlagName in DEFAULT_FEATURE_FLAGS;
+};
+// Hidden because the value is security-sensitive
+const SECURE_FLAGS = ['token', 'bugsnagKey', 'env', 'cachedConfig', 'defaultConfig'];
+// Hidden because those are used in tests
+const TEST_FLAGS = ['buffer', 'telemetry'];
+// Hidden because those are only used internally
+const INTERNAL_FLAGS = [
+    'nodePath',
+    'functionsDistDir',
+    'edgeFunctionsDistDir',
+    'defaultConfig',
+    'cachedConfigPath',
+    'sendStatus',
+    'saveConfig',
+    'statsd',
+    'framework',
+    'featureFlags',
+    'buildbotServerSocket',
+    'testOpts',
+    'siteId',
+    'context',
+    'branch',
+    'cwd',
+    'repositoryRoot',
+    'mode',
+    'apiHost',
+    'cacheDir',
+    'systemLogFile',
+    'timeline',
+];
+const HIDDEN_FLAGS = [...SECURE_FLAGS, ...TEST_FLAGS, ...INTERNAL_FLAGS];
+const HIDDEN_DEBUG_FLAGS = [...SECURE_FLAGS, ...TEST_FLAGS];
+export const logBuildDir = function (logs, buildDir) {
+    logSubHeader(logs, 'Current directory');
+    logMessage(logs, buildDir);
+};
+export const logConfigPath = function (logs, configPath = NO_CONFIG_MESSAGE) {
+    logSubHeader(logs, 'Config file');
+    logMessage(logs, configPath);
+};
+const NO_CONFIG_MESSAGE = 'No config file was defined: using default values.';
+export const logConfig = function ({ logs, netlifyConfig, debug }) {
+    if (!debug) {
+        return;
+    }
+    logSubHeader(logs, 'Resolved config');
+    logObject(logs, cleanupConfig(netlifyConfig));
+};
+export const logConfigOnUpdate = function ({ logs, netlifyConfig, debug }) {
+    if (!debug) {
+        return;
+    }
+    logSubHeader(logs, 'Updated config');
+    logObject(logs, cleanupConfig(netlifyConfig));
+};
+export const logConfigOnError = function ({ logs, netlifyConfig, severity }) {
+    if (netlifyConfig === undefined || severity === 'none') {
+        return;
+    }
+    logMessage(logs, THEME.errorSubHeader('Resolved config'));
+    logObject(logs, cleanupConfig(netlifyConfig));
+};
+export const logContext = function (logs, context) {
+    if (context === undefined) {
+        return;
+    }
+    logSubHeader(logs, 'Context');
+    logMessage(logs, context);
+};

package/lib/log/messages/core.js

@@ -0,0 +1,51 @@
+import ansiEscapes from 'ansi-escapes';
+import prettyMs from 'pretty-ms';
+import { getFullErrorInfo } from '../../error/parse/parse.js';
+import { serializeLogError } from '../../error/parse/serialize_log.js';
+import { roundTimerToMillisecs } from '../../time/measure.js';
+import { ROOT_PACKAGE_JSON } from '../../utils/json.js';
+import { getLogHeaderFunc } from '../header_func.js';
+import { log, logMessage, logWarning, logHeader, logSubHeader, logWarningArray } from '../logger.js';
+import { logOldCliVersionError } from '../old_version.js';
+import { THEME } from '../theme.js';
+import { logConfigOnError } from './config.js';
+export const logBuildStart = function (logs) {
+    logHeader(logs, 'Netlify Build');
+    logSubHeader(logs, 'Version');
+    logMessage(logs, `${ROOT_PACKAGE_JSON.name} ${ROOT_PACKAGE_JSON.version}`);
+};
+export const logBuildError = function ({ error, netlifyConfig, mode, logs, debug, testOpts }) {
+    const fullErrorInfo = getFullErrorInfo({ error, colors: true, debug });
+    const { severity } = fullErrorInfo;
+    const { title, body } = serializeLogError({ fullErrorInfo });
+    const logHeaderFunc = getLogHeaderFunc(error);
+    logHeaderFunc(logs, title);
+    logMessage(logs, `\n${body}\n`);
+    logConfigOnError({ logs, netlifyConfig, severity });
+    logOldCliVersionError({ mode, testOpts });
+};
+export const logBuildSuccess = function (logs) {
+    logHeader(logs, 'Netlify Build Complete');
+    logMessage(logs, '');
+};
+export const logTimer = function (logs, durationNs, timerName, systemLog) {
+    const durationMs = roundTimerToMillisecs(durationNs);
+    const duration = prettyMs(durationMs);
+    log(logs, THEME.dimWords(`(${timerName} completed in ${duration})`));
+    systemLog(`Build step duration: ${timerName} completed in ${durationMs}ms`);
+};
+export const logMissingSideFile = function (logs, sideFile, publish) {
+    logWarning(logs, `
+A "${sideFile}" file is present in the repository but is missing in the publish directory "${publish}".`);
+};
+// @todo use `terminal-link` (https://github.com/sindresorhus/terminal-link)
+// instead of `ansi-escapes` once
+// https://github.com/jamestalmage/supports-hyperlinks/pull/12 is fixed
+export const logLingeringProcesses = function (logs, commands) {
+    logWarning(logs, `
+The build completed successfully, but the following processes were still running:
+`);
+    logWarningArray(logs, commands);
+    logWarning(logs, `
+These processes have been terminated. In case this creates a problem for your build, refer to this ${ansiEscapes.link('article', 'https://answers.netlify.com/t/support-guide-how-to-address-the-warning-message-related-to-terminating-processes-in-builds/35277')} for details about why this process termination happens and how to fix it.`);
+};

package/lib/log/messages/core_steps.js

@@ -0,0 +1,75 @@
+import path from 'path';
+import { log, logArray, logErrorSubHeader, logWarningSubHeader } from '../logger.js';
+import { THEME } from '../theme.js';
+const logBundleResultFunctions = ({ functions, headerMessage, logs, error }) => {
+    const functionNames = functions.map(({ path: functionPath }) => path.basename(functionPath));
+    if (error) {
+        logErrorSubHeader(logs, headerMessage);
+    }
+    else {
+        logWarningSubHeader(logs, headerMessage);
+    }
+    logArray(logs, functionNames);
+};
+export const logBundleResults = ({ logs, results = [] }) => {
+    const resultsWithErrors = results.filter(({ bundlerErrors }) => bundlerErrors && bundlerErrors.length !== 0);
+    const resultsWithWarnings = results.filter(({ bundler, bundlerWarnings }) => bundler === 'esbuild' && bundlerWarnings && bundlerWarnings.length !== 0);
+    const modulesWithDynamicImports = [
+        ...new Set(results.flatMap((result) => result.nodeModulesWithDynamicImports || [])),
+    ];
+    if (resultsWithErrors.length !== 0) {
+        logBundleResultFunctions({
+            functions: resultsWithErrors,
+            headerMessage: 'Failed to bundle functions with selected bundler (fallback used):',
+            logs,
+            error: true,
+        });
+    }
+    if (resultsWithWarnings.length !== 0) {
+        logBundleResultFunctions({
+            functions: resultsWithWarnings,
+            headerMessage: 'Functions bundled with warnings:',
+            logs,
+            error: false,
+        });
+    }
+    if (modulesWithDynamicImports.length !== 0) {
+        logModulesWithDynamicImports({ logs, modulesWithDynamicImports });
+    }
+};
+export const logFunctionsNonExistingDir = function (logs, relativeFunctionsSrc) {
+    log(logs, `The Netlify Functions setting targets a non-existing directory: ${relativeFunctionsSrc}`);
+};
+// Print the list of Netlify Functions about to be bundled
+export const logFunctionsToBundle = function ({ logs, userFunctions, userFunctionsSrc, userFunctionsSrcExists, internalFunctions, internalFunctionsSrc, type = 'Functions', }) {
+    if (internalFunctions.length !== 0) {
+        log(logs, `Packaging ${type} from ${THEME.highlightWords(internalFunctionsSrc)} directory:`);
+        logArray(logs, internalFunctions, { indent: false });
+    }
+    if (!userFunctionsSrcExists) {
+        return;
+    }
+    if (userFunctions.length === 0) {
+        log(logs, `No ${type} were found in ${THEME.highlightWords(userFunctionsSrc)} directory`);
+        return;
+    }
+    if (internalFunctions.length !== 0) {
+        log(logs, '');
+    }
+    log(logs, `Packaging ${type} from ${THEME.highlightWords(userFunctionsSrc)} directory:`);
+    logArray(logs, userFunctions, { indent: false });
+};
+const logModulesWithDynamicImports = ({ logs, modulesWithDynamicImports }) => {
+    const externalNodeModules = modulesWithDynamicImports.map((moduleName) => `"${moduleName}"`).join(', ');
+    logWarningSubHeader(logs, `The following Node.js modules use dynamic expressions to include files:`);
+    logArray(logs, modulesWithDynamicImports);
+    log(logs, `\n  Because files included with dynamic expressions aren't bundled with your serverless functions by default,
+  this may result in an error when invoking a function. To resolve this error, you can mark these Node.js
+  modules as external in the [functions] section of your \`netlify.toml\` configuration file:
+
+  [functions]
+    external_node_modules = [${externalNodeModules}]
+
+  Visit https://ntl.fyi/dynamic-imports for more information.
+  `);
+};