@netlify/build 28.0.0-rc → 28.0.0

package/lib/env/metadata.js

@@ -0,0 +1,68 @@
+import { env } from 'process';
+import filterObj from 'filter-obj';
+// Retrieve enviroment variables used in error monitoring
+export const getEnvMetadata = function (childEnv = env) {
+    return filterObj(childEnv, isEnvMetadata);
+};
+const isEnvMetadata = function (name) {
+    return ENVIRONMENT_VARIABLES.has(name);
+};
+// This is sorted by most useful in debugging to least
+const ENVIRONMENT_VARIABLES = new Set([
+    // URL and IDs
+    'BUILD_ID',
+    'DEPLOY_ID',
+    'SITE_NAME',
+    'SITE_ID',
+    'REPOSITORY_URL',
+    'URL',
+    'DEPLOY_URL',
+    'DEPLOY_PRIME_URL',
+    // Git
+    'HEAD',
+    'COMMIT_REF',
+    'CACHED_COMMIT_REF',
+    'BRANCH',
+    'CONTEXT',
+    'PULL_REQUEST',
+    'REVIEW_ID',
+    // Node
+    'NODE_VERSION',
+    'AWS_LAMBDA_JS_RUNTIME',
+    'NPM_VERSION',
+    'YARN_VERSION',
+    'NPM_FLAGS',
+    'YARN_FLAGS',
+    'NVM_FLAGS',
+    'NODE_ENV',
+    // Go
+    'GO_VERSION',
+    'GO_IMPORT_PATH',
+    'GOCACHE',
+    'GOPATH',
+    'GOROOT',
+    // Ruby
+    'RUBY_VERSION',
+    'GEM_HOME',
+    'GEM_PATH',
+    'GIMME_GCO_ENABLED',
+    'GIMME_ENV_PREFIX',
+    'GIMME_GO_PREFIX',
+    'GIMME_NO_ENV_ALIAS',
+    'GIMME_TYPE',
+    'IRBRC',
+    'MY_RUBY_HOME',
+    // Hugo
+    'HUGO_VERSION',
+    // Java
+    'JAVA_VERSION',
+    // PHP
+    'PHP_VERSION',
+    // Python
+    'PIPENV_DEFAULT_PYTHON_VERSION',
+    'PIPENV_RUNTIME',
+    'PIPENV_VENV_IN_PROJECT',
+    // Git LFS
+    'GIT_LFS_ENABLED',
+    'GIT_LFS_FETCH_INCLUDE',
+]);

package/lib/error/api.js

@@ -0,0 +1,37 @@
+import isPlainObj from 'is-plain-obj';
+import mapObj from 'map-obj';
+import { addErrorInfo } from './info.js';
+// Wrap `api.*` methods so that they add more error information
+export const addApiErrorHandlers = function (api) {
+    if (api === undefined) {
+        return;
+    }
+    return mapObj(api, addErrorHandler);
+};
+const addErrorHandler = function (key, value) {
+    if (typeof value !== 'function') {
+        return [key, value];
+    }
+    const valueA = apiMethodHandler.bind(null, key, value);
+    return [key, valueA];
+};
+const apiMethodHandler = async function (endpoint, method, parameters, ...args) {
+    try {
+        return await method(parameters, ...args);
+    }
+    catch (error) {
+        redactError(error);
+        addErrorInfo(error, { type: 'api', location: { endpoint, parameters } });
+        throw error;
+    }
+};
+// Redact API token from the build logs
+const redactError = function (error) {
+    if (error instanceof Error &&
+        isPlainObj(error.data) &&
+        isPlainObj(error.data.headers) &&
+        typeof error.data.headers.Authorization === 'string') {
+        error.data.headers.Authorization = error.data.headers.Authorization.replace(HEX_REGEXP, 'HEX');
+    }
+};
+const HEX_REGEXP = /[\da-f]{6,}/g;

package/lib/error/build.js

@@ -0,0 +1,36 @@
+import safeJsonStringify from 'safe-json-stringify';
+import { CUSTOM_ERROR_KEY } from './info.js';
+// Retrieve error information from child process and re-build it in current
+// process. We need this since errors static properties are not kept by
+// `v8.serialize()`.
+export const jsonToError = function ({ name, message, stack, ...errorProps }) {
+    const error = new Error('');
+    assignErrorProps(error, { name, message, stack });
+    // Assign static error properties (if any)
+    // We need to mutate the `error` directly to preserve its `name`, `stack`, etc.
+    Object.assign(error, errorProps);
+    return error;
+};
+// Make sure `name`, `message` and `stack` are not enumerable
+const assignErrorProps = function (error, values) {
+    ERROR_PROPS.forEach((name) => {
+        assignErrorProp(error, name, values[name]);
+    });
+};
+const ERROR_PROPS = ['name', 'message', 'stack'];
+const assignErrorProp = function (error, name, value) {
+    // `Object.defineProperty()` requires direct mutation
+    Object.defineProperty(error, name, { value, enumerable: false, writable: true, configurable: true });
+};
+// Inverse of `jsonToError()`.
+export const errorToJson = function (error) {
+    const { name, message, stack, [CUSTOM_ERROR_KEY]: customError, ...errorProps } = error;
+    // diagnosticText is not enumerable in TSError so we need to grab it manually. destructuring won't work.
+    if (error.diagnosticText) {
+        errorProps.diagnosticText = error.diagnosticText;
+    }
+    return {
+        ...safeJsonStringify.ensureProperties(errorProps),
+        ...safeJsonStringify.ensureProperties({ name, message, stack, [CUSTOM_ERROR_KEY]: customError }),
+    };
+};

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

@@ -1,8 +1,7 @@
 // Cancel builds, for example when a plugin uses `utils.build.cancelBuild()`
 export const cancelBuild = async function ({ api, deployId }) {
-  if (api === undefined || !deployId) {
-    return
-  }
-
-  await api.cancelSiteDeploy({ deploy_id: deployId })
-}
+    if (api === undefined || !deployId) {
+        return;
+    }
+    await api.cancelSiteDeploy({ deploy_id: deployId });
+};

package/lib/error/colors.js

@@ -0,0 +1,9 @@
+import stripAnsi from 'strip-ansi';
+// Remove ANSI sequences from `error.message`
+export const removeErrorColors = function (error) {
+    if (!(error instanceof Error)) {
+        return;
+    }
+    error.message = stripAnsi(error.message);
+    error.stack = stripAnsi(error.stack);
+};

package/lib/error/handle.js

@@ -0,0 +1,46 @@
+import { cwd as getCwd } from 'process';
+import { pathExists } from 'path-exists';
+import { logBuildError } from '../log/messages/core.js';
+import { logOldCliVersionError } from '../log/old_version.js';
+import { removeErrorColors } from './colors.js';
+import { getErrorInfo } from './info.js';
+import { reportBuildError } from './monitor/report.js';
+import { parseErrorInfo } from './parse/parse.js';
+// Logs and reports a build failure
+export const handleBuildError = async function (error, { errorMonitor, netlifyConfig, childEnv, mode, logs, debug, testOpts }) {
+    const basicErrorInfo = parseErrorInfo(error);
+    if (await isCancelCrash(error)) {
+        return basicErrorInfo;
+    }
+    removeErrorColors(error);
+    // Some errors, such as telemetry ones, should not be logged
+    if (basicErrorInfo.showInBuildLog) {
+        logBuildError({ error, netlifyConfig, mode, logs, debug, testOpts });
+    }
+    logOldCliVersionError({ mode, testOpts });
+    await reportBuildError({ error, errorMonitor, childEnv, logs, testOpts });
+    return basicErrorInfo;
+};
+// When builds are canceled, the whole filesystem is being deleted.
+// However, the process (and build) keeps going. Because no files exist anymore,
+// the build eventually crashes with a randomly odd error. Those should not be
+// logged nor reported.
+// However builds canceled with `utils.build.cancelBuild()` should still show
+// "Build canceled by ..."
+const isCancelCrash = async function (error) {
+    const [{ type }] = getErrorInfo(error);
+    if (type === 'cancelBuild') {
+        return false;
+    }
+    try {
+        // TODO: find a better way to detect that the build is being cancelled.
+        // Otherwise bugs due to (for example) the build command removing
+        // `process.cwd` are currently not logged/reported.
+        const cwd = getCwd();
+        return !(await pathExists(cwd));
+        // `process.cwd()` fails when the current directory does not exist
+    }
+    catch {
+        return true;
+    }
+};

package/lib/error/info.js

@@ -0,0 +1,37 @@
+// Add information related to an error without colliding with existing properties
+export const addDefaultErrorInfo = function (error, info) {
+    if (!canHaveErrorInfo(error)) {
+        return;
+    }
+    error[CUSTOM_ERROR_KEY] = { ...info, ...error[CUSTOM_ERROR_KEY] };
+};
+// Retrieve error information added by our system
+export const addErrorInfo = function (error, info) {
+    if (!canHaveErrorInfo(error)) {
+        return;
+    }
+    error[CUSTOM_ERROR_KEY] = { ...error[CUSTOM_ERROR_KEY], ...info };
+};
+export const getErrorInfo = function (error) {
+    if (!isBuildError(error)) {
+        return [{}, error];
+    }
+    const { [CUSTOM_ERROR_KEY]: errorInfo, ...errorA } = error;
+    return [errorInfo, errorA];
+};
+// Change error type from one to another
+export const changeErrorType = function (error, oldType, newType) {
+    const [{ type }] = getErrorInfo(error);
+    if (type === oldType) {
+        addErrorInfo(error, { type: newType });
+    }
+};
+export const isBuildError = function (error) {
+    return canHaveErrorInfo(error) && error[CUSTOM_ERROR_KEY] !== undefined;
+};
+// Exceptions that are not objects (including `Error` instances) cannot have an
+// `CUSTOM_ERROR_KEY` property
+const canHaveErrorInfo = function (error) {
+    return error != null;
+};
+export const CUSTOM_ERROR_KEY = 'customErrorInfo';

package/lib/error/monitor/location.js

@@ -0,0 +1,16 @@
+// Retrieve plugin's location and build logs
+export const getLocationMetadata = function (location, envMetadata) {
+    const buildLogs = getBuildLogs(envMetadata);
+    if (buildLogs === undefined && location === undefined) {
+        return;
+    }
+    return { buildLogs, ...location };
+};
+// Retrieve the URL to the build logs
+const getBuildLogs = function ({ SITE_NAME, DEPLOY_ID }) {
+    if (SITE_NAME === undefined || DEPLOY_ID === undefined) {
+        return;
+    }
+    return `${NETLIFY_ORIGIN}/sites/${SITE_NAME}/deploys/${DEPLOY_ID}`;
+};
+const NETLIFY_ORIGIN = 'https://app.netlify.com';

package/lib/error/monitor/normalize.js

@@ -0,0 +1,86 @@
+// We group errors by `error.message`. However some `error.message` contain
+// unique IDs, etc. which defeats that grouping. So we normalize those to make
+// them consistent
+export const normalizeGroupingMessage = function (message, type) {
+    const messageA = removeDependenciesLogs(message, type);
+    const messageB = NORMALIZE_REGEXPS.reduce(normalizeMessage, messageA);
+    // If this is a functions bundling error, we'll use additional normalization
+    // rules to group errors more aggressively.
+    if (type === 'functionsBundling') {
+        return FUNCTIONS_BUNDLING_REGEXPS.reduce(normalizeMessage, messageB);
+    }
+    return messageB;
+};
+// Discard debug/info installation information
+const removeDependenciesLogs = function (message, type) {
+    if (type !== 'dependencies') {
+        return message;
+    }
+    return message.split('\n').filter(isErrorLine).join('\n');
+};
+const isErrorLine = function (line) {
+    return ERROR_LINES.some((errorLine) => line.startsWith(errorLine));
+};
+const ERROR_LINES = [
+    // Prefix for npm
+    'npm ERR!',
+    // Prefix for Yarn
+    'error',
+];
+const normalizeMessage = function (message, [regExp, replacement]) {
+    return message.replace(regExp, replacement);
+};
+const NORMALIZE_REGEXPS = [
+    // Base64 URL
+    [/(data:[^;]+;base64),[\w+/-=]+/g, 'dataURI'],
+    // File paths
+    [/(["'`, ]|^)([^"'`, \n]*[/\\][^"'`, \n]*)(?=["'`, ]|$)/gm, '$1/file/path'],
+    // Semantic versions
+    [/\d+\.\d+\.\d+(-\d+)?/g, '1.0.0'],
+    [/version "[^"]+"/g, 'version "1.0.0"'],
+    // Cypress plugin prints the user's platform
+    [/^Platform: .*/gm, ''],
+    // URLs
+    [/https?:[\w.+~!$&'()*,;=:@/?#]+/g, 'https://domain.com'],
+    // Numbers, e.g. number of issues/problems
+    [/\d+/g, '0'],
+    // Hexadecimal strings
+    [/[\da-fA-F-]{6,}/g, 'hex'],
+    // On unknown inputs, we print the inputs
+    [/(does not accept any inputs but you specified: ).*/, '$1'],
+    [/(Unknown inputs for plugin).*/, '$1'],
+    [/(Plugin inputs should be one of: ).*/, '$1'],
+    // On required inputs, we print the inputs
+    [/^Plugin inputs[^]*/gm, ''],
+    [/(Required inputs for plugin).*/gm, '$1'],
+    // Netlify Functions validation check
+    [/(should target a directory, not a regular file):.*/, '$1'],
+    // zip-it-and-ship-it error when there is an `import()` but dependencies
+    // were not installed
+    [/(Cannot find module) '([^']+)'/g, "$1 'moduleName'"],
+    [/(A Netlify Function is using) "[^"]+"/g, '$1 "moduleName"'],
+    // Deploy upload errors include the filename
+    [/(Upload cancelled).*/g, '$1'],
+    [/(aborting upload of file).*/g, '$1'],
+    // netlify-plugin-inline-critical-css errors prints a list of file paths
+    [/Searched in: .*/g, ''],
+    // netlify-plugin-subfont prints font name in errors
+    [/(is not supported yet): .*/, '$1'],
+    // netlify-plugin-subfont prints generic information in every error that
+    // is highly build-specific
+    [/^(vers?ions|Plugin configuration|Subfont called with): {[^}]+}/gm, ''],
+    [/^Resolved entry points: \[[^\]]+]/gm, ''],
+    // netlify-plugin-minify-html parse error
+    [/(Parse Error):[^]*/, '$1'],
+    // Multiple empty lines
+    [/^\s*$/gm, ''],
+];
+const FUNCTIONS_BUNDLING_REGEXPS = [
+    // String literals and identifiers
+    [/"([^"]+)"/g, '""'],
+    [/'([^']+)'/g, "''"],
+    [/`([^`]+)`/g, '``'],
+    // Rust crates
+    [/(?:Downloaded \S+ v[\d.]+\s*)+/gm, 'Downloaded crates'],
+    [/(?:Compiling \S+ v[\d.]+\s*)+/gm, 'Compiled crates'],
+];

package/lib/error/monitor/print.js

@@ -0,0 +1,20 @@
+import { log } from '../../log/logger.js';
+// Print event payload instead of sending actual request during tests
+export const printEventForTest = function ({ name: errorClass, message: errorMessage }, { context, groupingHash, severity, unhandled, _metadata: { location, plugin: { packageName, homepage } = {}, pluginPackageJson, tsConfig, env: { BUILD_ID } = {}, other, }, }, logs) {
+    const eventString = JSON.stringify({
+        errorClass,
+        errorMessage,
+        context,
+        groupingHash,
+        severity,
+        unhandled,
+        location,
+        packageName,
+        pluginPackageJson: pluginPackageJson !== undefined,
+        homepage,
+        tsConfig,
+        BUILD_ID,
+        other,
+    }, null, 2);
+    log(logs, `\nError monitoring payload:\n${eventString}`);
+};

package/lib/error/monitor/report.js

@@ -0,0 +1,120 @@
+import { type as osType, freemem, totalmem } from 'os';
+import { promisify } from 'util';
+import osName from 'os-name';
+import { getEnvMetadata } from '../../env/metadata.js';
+import { log } from '../../log/logger.js';
+import { parseErrorInfo } from '../parse/parse.js';
+import { getHomepage } from '../parse/plugin.js';
+import { getLocationMetadata } from './location.js';
+import { normalizeGroupingMessage } from './normalize.js';
+import { printEventForTest } from './print.js';
+// Report a build failure for monitoring purpose
+export const reportBuildError = async function ({ error, errorMonitor, childEnv, logs, testOpts }) {
+    if (errorMonitor === undefined) {
+        return;
+    }
+    const { errorInfo, type, severity, title, group = title } = parseErrorInfo(error);
+    const severityA = getSeverity(severity, errorInfo);
+    const groupA = getGroup(group, errorInfo);
+    const groupingHash = getGroupingHash(groupA, error, type, errorInfo);
+    const metadata = getMetadata(errorInfo, childEnv, groupingHash);
+    const app = getApp();
+    const eventProps = getEventProps({ severity: severityA, group: groupA, groupingHash, metadata, app });
+    const errorName = updateErrorName(error, type);
+    try {
+        await reportError({ errorMonitor, error, logs, testOpts, eventProps });
+    }
+    finally {
+        error.name = errorName;
+    }
+};
+// Plugin authors test their plugins as local plugins. Errors there are more
+// like development errors, and should be reported as `info` only.
+const getSeverity = function (severity, { location: { loadedFrom } = {} }) {
+    if (loadedFrom === 'local' || severity === 'none') {
+        return 'info';
+    }
+    return severity;
+};
+const getGroup = function (group, errorInfo) {
+    if (typeof group !== 'function') {
+        return group;
+    }
+    return group(errorInfo);
+};
+const getGroupingHash = function (group, error, type, errorInfo = {}) {
+    // If the error has a `normalizedMessage`, we use it as the grouping hash.
+    if (errorInfo.normalizedMessage) {
+        return errorInfo.normalizedMessage;
+    }
+    const message = error instanceof Error && typeof error.message === 'string' ? error.message : String(error);
+    const messageA = normalizeGroupingMessage(message, type);
+    return `${group}\n${messageA}`;
+};
+const getMetadata = function ({ location, plugin, tsConfig }, childEnv, groupingHash) {
+    const pluginMetadata = getPluginMetadata({ location, plugin });
+    const envMetadata = getEnvMetadata(childEnv);
+    const locationMetadata = getLocationMetadata(location, envMetadata);
+    return { location: locationMetadata, ...pluginMetadata, tsConfig, env: envMetadata, other: { groupingHash } };
+};
+const getPluginMetadata = function ({ location, plugin }) {
+    if (plugin === undefined) {
+        return {};
+    }
+    const { pluginPackageJson, ...pluginA } = plugin;
+    const homepage = getHomepage(pluginPackageJson, location);
+    return { plugin: { ...pluginA, homepage }, pluginPackageJson };
+};
+const getApp = function () {
+    return {
+        osName: osType(),
+        osVersion: osName(),
+        freeMemory: freemem(),
+        totalMemory: totalmem(),
+    };
+};
+// `error.name` is shown proeminently in the Bugsnag UI. We need to update it to
+// match error `type` since it is more granular and useful.
+// But we change it back after Bugsnag is done reporting.
+const updateErrorName = function (error, type) {
+    const { name } = error;
+    // This might fail if `name` is a getter or is non-writable.
+    try {
+        error.name = type;
+    }
+    catch {
+        // continue regardless error
+    }
+    return name;
+};
+const reportError = async function ({ errorMonitor, error, logs, testOpts, eventProps }) {
+    if (testOpts.errorMonitor) {
+        printEventForTest(error, eventProps, logs);
+        return;
+    }
+    try {
+        await promisify(errorMonitor.notify)(error, (event) => onError(event, eventProps));
+        // Failsafe
+    }
+    catch {
+        log(logs, `Error monitor could not notify\n${error.stack}`);
+    }
+};
+const getEventProps = function ({ severity, group, groupingHash, metadata, app }) {
+    // `unhandled` is used to calculate Releases "stabiity score", which is
+    // basically the percentage of unhandled errors. Since we handle all errors,
+    // we need to implement this according to error types.
+    const unhandled = severity === 'error';
+    return { severity, context: group, groupingHash, _metadata: metadata, app, unhandled };
+};
+// Add more information to Bugsnag events
+const onError = function (event, eventProps) {
+    // Bugsnag client requires directly mutating the `event`
+    Object.assign(event, {
+        ...eventProps,
+        unhandled: event.unhandled || eventProps.unhandled,
+        _metadata: { ...event._metadata, ...eventProps._metadata },
+        app: { ...event.app, ...eventProps.app },
+    });
+    return true;
+};

package/lib/error/monitor/start.js

@@ -0,0 +1,58 @@
+import { fileURLToPath } from 'url';
+import Bugsnag from '@bugsnag/js';
+import memoizeOne from 'memoize-one';
+import { log } from '../../log/logger.js';
+import { ROOT_PACKAGE_JSON } from '../../utils/json.js';
+const projectRoot = fileURLToPath(new URL('../../..', import.meta.url));
+// Start a client to monitor errors
+export const startErrorMonitor = function ({ flags: { mode }, logs, bugsnagKey }) {
+    if (!bugsnagKey) {
+        return;
+    }
+    const isTest = isBugsnagTest(bugsnagKey);
+    const releaseStage = getReleaseStage(mode);
+    const logger = getLogger(logs, isTest);
+    try {
+        const errorMonitor = startBugsnag({
+            apiKey: bugsnagKey,
+            appVersion: `${ROOT_PACKAGE_JSON.name} ${ROOT_PACKAGE_JSON.version}`,
+            appType: ROOT_PACKAGE_JSON.name,
+            releaseStage,
+            logger,
+            projectRoot,
+        });
+        // Allows knowing the percentage of failed builds per release
+        if (!isTest) {
+            errorMonitor.startSession();
+        }
+        return errorMonitor;
+        // Failsafe
+    }
+    catch (error) {
+        log(logs, `Error monitor could not start\n${error.stack}`);
+    }
+};
+const isBugsnagTest = function (bugsnagKey) {
+    return bugsnagKey === BUGSNAG_TEST_KEY;
+};
+const BUGSNAG_TEST_KEY = '00000000000000000000000000000000';
+// Bugsnag.start() caches a global instance and warns on duplicate calls.
+// This ensures the warning message is not shown when calling the main function
+// several times.
+const startBugsnag = memoizeOne(Bugsnag.start.bind(Bugsnag), () => true);
+// Based the release stage on the `mode`
+const getReleaseStage = function (mode = DEFAULT_RELEASE_STAGE) {
+    return mode;
+};
+const DEFAULT_RELEASE_STAGE = 'unknown';
+// We don't want Bugsnag logs except on warnings/errors.
+// We also want to use our own `log` utility, unprefixed.
+// In tests, we don't print Bugsnag because it sometimes randomly fails to
+// send sessions, which prints warning messags in test snapshots.
+const getLogger = function (logs, isTest) {
+    const logFunc = isTest ? noop : log.bind(null, logs);
+    return { debug: noop, info: noop, warn: logFunc, error: logFunc };
+};
+const noop = function () {
+    // this is a noop function
+};

package/lib/error/parse/clean_stack.js

@@ -0,0 +1,70 @@
+import { cwd } from 'process';
+import cleanStack from 'clean-stack';
+import stripAnsi from 'strip-ansi';
+// Clean stack traces:
+//  - remove our internal code, e.g. the logic spawning plugins
+//  - remove node modules and Node.js internals
+//  - strip process.cwd()
+//  - remove colors
+// Keep non stack trace lines as is.
+// We do not use libraries that patch `Error.prepareStackTrace()` because they
+// tend to create issues.
+export const cleanStacks = function ({ stack, rawStack, debug }) {
+    if (stack === undefined) {
+        return;
+    }
+    // Internal errors / bugs keep their full stack trace
+    // Same in debug mode
+    if (rawStack || debug) {
+        return stack;
+    }
+    return stack.split('\n').reduce(cleanStackLine, '').replace(INITIAL_NEWLINES, '');
+};
+const cleanStackLine = function (lines, line) {
+    const lineA = line.replace(getCwd(), '');
+    const lineB = stripAnsi(lineA);
+    if (!STACK_LINE_REGEXP.test(lineB)) {
+        return `${lines}\n${lineA}`;
+    }
+    if (shouldRemoveStackLine(lineB)) {
+        return lines;
+    }
+    const lineC = cleanStack(lineB);
+    if (lineC === '') {
+        return lines;
+    }
+    return `${lines}\n${lineC}`;
+};
+// `process.cwd()` can sometimes fail: directory name too long, current
+// directory has been removed, access denied.
+const getCwd = function () {
+    try {
+        return cwd();
+    }
+    catch {
+        return '';
+    }
+};
+// Check if a line is part of a stack trace
+const STACK_LINE_REGEXP = /^\s+at /;
+const shouldRemoveStackLine = function (line) {
+    const lineA = normalizePathSlashes(line);
+    return INTERNAL_STACK_STRINGS.some((stackString) => lineA.includes(stackString)) || INTERNAL_STACK_REGEXP.test(lineA);
+};
+const INTERNAL_STACK_STRINGS = [
+    // Anonymous function
+    '<anonymous>',
+    '(index 0)',
+    // nyc internal code
+    'node_modules/append-transform',
+    'node_modules/signal-exit',
+    // Node internals
+    '(node:',
+];
+// This is only needed for local builds and tests
+const INTERNAL_STACK_REGEXP = /(lib\/|tests\/helpers\/|tests\/.*\/tests.js|node_modules)/;
+const INITIAL_NEWLINES = /^\n+/;
+const normalizePathSlashes = function (line) {
+    return line.replace(BACKLASH_REGEXP, '/');
+};
+const BACKLASH_REGEXP = /\\/g;

package/lib/error/parse/location.js

@@ -0,0 +1,50 @@
+import { getBuildCommandDescription, getPluginOrigin } from '../../log/description.js';
+// Retrieve an error's location to print in logs.
+// Each error type has its own logic (or none if there's no location to print).
+export const getLocationInfo = function ({ stack, location, locationType }) {
+    // No location to print
+    if (locationType === undefined && stack === undefined) {
+        return;
+    }
+    // The location is only the stack trace
+    if (locationType === undefined) {
+        return stack;
+    }
+    const locationString = LOCATIONS[locationType](location);
+    return [locationString, stack].filter(Boolean).join('\n');
+};
+const getBuildCommandLocation = function ({ buildCommand, buildCommandOrigin }) {
+    const description = getBuildCommandDescription(buildCommandOrigin);
+    return `In ${description}:
+${buildCommand}`;
+};
+const getFunctionsBundlingLocation = function ({ functionName, functionType }) {
+    if (functionType === 'edge') {
+        return 'While bundling edge function';
+    }
+    return `While bundling function "${functionName}"`;
+};
+const getCoreStepLocation = function ({ coreStepName }) {
+    return `During ${coreStepName}`;
+};
+const getBuildFailLocation = function ({ event, packageName, loadedFrom, origin }) {
+    const eventMessage = getEventMessage(event);
+    const pluginOrigin = getPluginOrigin(loadedFrom, origin);
+    return `${eventMessage} "${packageName}" ${pluginOrigin}`;
+};
+const getEventMessage = function (event) {
+    if (event === 'load') {
+        return `While loading`;
+    }
+    return `In "${event}" event in`;
+};
+const getApiLocation = function ({ endpoint, parameters }) {
+    return `While calling the Netlify API endpoint '${endpoint}' with:\n${JSON.stringify(parameters, null, 2)}`;
+};
+const LOCATIONS = {
+    buildCommand: getBuildCommandLocation,
+    functionsBundling: getFunctionsBundlingLocation,
+    coreStep: getCoreStepLocation,
+    buildFail: getBuildFailLocation,
+    api: getApiLocation,
+};