@netlify/build 36.4.0 → 36.4.2

package/lib/core/bin.js

@@ -1,7 +1,6 @@
 #!/usr/bin/env node
 import { readFileSync } from 'fs';
 import process from 'process';
-import { includeKeys } from 'filter-obj';
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
 import { normalizeCliFeatureFlags } from './feature_flags.js';
@@ -16,7 +15,7 @@ const packJson = JSON.parse(readFileSync(new URL('../../package.json', import.me
 // sense only in CLI, such as CLI flags parsing and exit code.
 const runCli = async function () {
     const flags = parseFlags();
-    const flagsA = includeKeys(flags, isUserFlag);
+    const flagsA = Object.fromEntries(Object.entries(flags).filter(isUserFlag));
     const state = { done: false };
     process.on('exit', onExit.bind(undefined, state));
     const { severityCode, logs } = await buildSite(flagsA);
@@ -41,7 +40,7 @@ Options can also be specified as environment variables prefixed with
 NETLIFY_BUILD_. For example the environment variable NETLIFY_BUILD_DRY=true can
 be used instead of the CLI flag --dry.`;
 // Remove `yargs`-specific options, shortcuts, dash-cased and aliases
-const isUserFlag = function (key, value) {
+const isUserFlag = function ([key, value]) {
     return value !== undefined && !INTERNAL_KEYS.has(key) && key.length !== 1 && !key.includes('-');
 };
 const INTERNAL_KEYS = new Set(['help', 'version', '_', '$0', 'dryRun']);

package/lib/core/constants.js

@@ -1,6 +1,6 @@
 import { relative, normalize, join } from 'path';
 import { getCacheDir } from '@netlify/cache-utils';
-import { pathExists } from 'path-exists';
+import { pathExists } from '../utils/path_exists.js';
 import { ROOT_PACKAGE_JSON } from '../utils/json.js';
 /**
  * Retrieve constants passed to plugins

package/lib/core/dry.js

@@ -1,9 +1,20 @@
-import pFilter from 'p-filter';
 import { logDryRunStart, logDryRunStep, logDryRunEnd } from '../log/messages/dry.js';
 import { runsOnlyOnBuildFailure } from '../plugins/events.js';
 // If the `dry` flag is specified, do a dry run
 export const doDryRun = async function ({ buildDir, steps, netlifyConfig, constants, buildbotServerSocket, logs, featureFlags, }) {
-    const successSteps = await pFilter(steps, ({ event, condition }) => shouldIncludeStep({ buildDir, event, condition, netlifyConfig, constants, buildbotServerSocket, featureFlags }));
+    const includedSteps = await Promise.all(steps.map(async (step) => {
+        const shouldInclude = await shouldIncludeStep({
+            buildDir,
+            event: step.event,
+            condition: step.condition,
+            netlifyConfig,
+            constants,
+            buildbotServerSocket,
+            featureFlags,
+        });
+        return shouldInclude ? step : null;
+    }));
+    const successSteps = includedSteps.filter(Boolean);
     const eventWidth = Math.max(...successSteps.map(getEventLength));
     const stepsCount = successSteps.length;
     logDryRunStart({ logs, eventWidth, stepsCount });

package/lib/core/missing_side_file.js

@@ -1,6 +1,6 @@
 import { relative } from 'path';
-import { pathExists } from 'path-exists';
 import { logMissingSideFile } from '../log/messages/core.js';
+import { pathExists } from '../utils/path_exists.js';
 // Some files like `_headers` and `_redirects` must be copied to the publishing
 // directory to be used in production. When those are present in the repository
 // but not in the publish directory, this most likely indicates that the build

package/lib/env/changes.js

@@ -1,5 +1,4 @@
 import { env } from 'process';
-import { includeKeys } from 'filter-obj';
 // If plugins modify `process.env`, this is propagated in other plugins and in
 // `build.command`. Since those are different processes, we figure out when they
 // do this and communicate the new `process.env` to other processes.
@@ -9,8 +8,8 @@ export const getNewEnvChanges = function (envBefore, netlifyConfig, netlifyConfi
     return { ...processEnvChanges, ...netlifyConfigEnvChanges };
 };
 const diffEnv = function (envBefore, envAfter) {
-    const envChanges = includeKeys(envAfter, (name, value) => value !== envBefore[name]);
-    const deletedEnv = includeKeys(envBefore, (name) => envAfter[name] === undefined);
+    const envChanges = Object.fromEntries(Object.entries(envAfter).filter(([name, value]) => value !== envBefore[name]));
+    const deletedEnv = Object.fromEntries(Object.entries(envBefore).filter(([name]) => envAfter[name] === undefined));
     const deletedEnvA = Object.fromEntries(Object.entries(deletedEnv).map(setToNull));
     return { ...envChanges, ...deletedEnvA };
 };

package/lib/env/main.d.ts

@@ -1,4 +1,6 @@
 export declare const getChildEnv: ({ envOpt, env: allConfigEnv }: {
     envOpt: any;
     env: any;
-}) => Partial<any>;
+}) => {
+    [k: string]: unknown;
+};

package/lib/env/main.js

@@ -1,12 +1,11 @@
 import { env } from 'process';
-import { includeKeys } from 'filter-obj';
 import { getParentColorEnv } from '../log/colors.js';
 // Retrieve the environment variables passed to plugins and `build.command`
 // When run locally, this tries to emulate the production environment.
 export const getChildEnv = function ({ envOpt, env: allConfigEnv }) {
     const parentColorEnv = getParentColorEnv();
     const parentEnv = { ...env, ...allConfigEnv, ...envOpt, ...parentColorEnv };
-    return includeKeys(parentEnv, shouldKeepEnv);
+    return Object.fromEntries(Object.entries(parentEnv).filter(([key]) => shouldKeepEnv(key)));
 };
 const shouldKeepEnv = function (key) {
     return !REMOVED_PARENT_ENV.has(key.toLowerCase());

package/lib/env/metadata.d.ts

@@ -1 +1,3 @@
-export function getEnvMetadata(childEnv?: NodeJS.ProcessEnv): Partial<NodeJS.ProcessEnv>;
+export function getEnvMetadata(childEnv?: NodeJS.ProcessEnv): {
+    [k: string]: string | undefined;
+};

package/lib/env/metadata.js

@@ -1,8 +1,7 @@
 import { env } from 'process';
-import { includeKeys } from 'filter-obj';
 // Retrieve environment variables used in error monitoring
 export const getEnvMetadata = function (childEnv = env) {
-    return includeKeys(childEnv, isEnvMetadata);
+    return Object.fromEntries(Object.entries(childEnv).filter(([name]) => isEnvMetadata(name)));
 };
 const isEnvMetadata = function (name) {
     return ENVIRONMENT_VARIABLES.has(name);

package/lib/error/api.js

@@ -1,4 +1,4 @@
-import isPlainObj from 'is-plain-obj';
+import { isPlainObject } from '../utils/is_plain_object.js';
 import { addErrorInfo } from './info.js';
 // Wrap `api.*` methods so that they add more error information
 export const addApiErrorHandlers = function (api) {
@@ -27,8 +27,8 @@ const apiMethodHandler = async function (endpoint, method, parameters, ...args)
 // Redact API token from the build logs
 const redactError = function (error) {
     if (error instanceof Error &&
-        isPlainObj(error.data) &&
-        isPlainObj(error.data.headers) &&
+        isPlainObject(error.data) &&
+        isPlainObject(error.data.headers) &&
         typeof error.data.headers.Authorization === 'string') {
         error.data.headers.Authorization = error.data.headers.Authorization.replace(HEX_REGEXP, 'HEX');
     }

package/lib/error/handle.js

@@ -1,5 +1,5 @@
 import { cwd as getCwd } from 'process';
-import { pathExists } from 'path-exists';
+import { pathExists } from '../utils/path_exists.js';
 import { logBuildError } from '../log/messages/core.js';
 import { removeErrorColors } from './colors.js';
 import { getErrorInfo } from './info.js';

package/lib/error/parse/clean_stack.js

@@ -1,6 +1,5 @@
 import { stripVTControlCharacters } from 'node:util';
 import { cwd } from 'process';
-import cleanStack from 'clean-stack';
 // Clean stack traces:
 //  - remove our internal code, e.g. the logic spawning plugins
 //  - remove node modules and Node.js internals
@@ -29,11 +28,7 @@ const cleanStackLine = function (lines, line) {
     if (shouldRemoveStackLine(lineB)) {
         return lines;
     }
-    const lineC = cleanStack(lineB);
-    if (lineC === '') {
-        return lines;
-    }
-    return `${lines}\n${lineC}`;
+    return `${lines}\n${lineB}`;
 };
 // `process.cwd()` can sometimes fail: directory name too long, current
 // directory has been removed, access denied.
@@ -49,7 +44,9 @@ const getCwd = function () {
 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);
+    return (INTERNAL_STACK_STRINGS.some((stackString) => lineA.includes(stackString)) ||
+        INTERNAL_STACK_REGEXP.test(lineA) ||
+        NODE_STACK_REGEXP.test(lineA));
 };
 const INTERNAL_STACK_STRINGS = [
     // Anonymous function
@@ -58,9 +55,8 @@ const INTERNAL_STACK_STRINGS = [
     // nyc internal code
     'node_modules/append-transform',
     'node_modules/signal-exit',
-    // Node internals
-    '(node:',
 ];
+const NODE_STACK_REGEXP = /\bnode:|\(native\)|\bat native\b/;
 // 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+/;

package/lib/install/main.js

@@ -1,7 +1,7 @@
 import { homedir } from 'os';
 import { execa } from 'execa';
-import { pathExists } from 'path-exists';
 import { addErrorInfo } from '../error/info.js';
+import { pathExists } from '../utils/path_exists.js';
 // Install Node.js dependencies in a specific directory
 export const installDependencies = function ({ packageRoot, isLocal }) {
     return runCommand({ packageRoot, isLocal, type: 'install' });

package/lib/install/missing.js

@@ -1,8 +1,8 @@
 import { promises as fs } from 'node:fs';
 import { normalize } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { pathExists } from 'path-exists';
 import { logInstallMissingPlugins, logInstallIntegrations } from '../log/messages/install.js';
+import { pathExists } from '../utils/path_exists.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`

package/lib/log/messages/core.js

@@ -1,4 +1,3 @@
-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';
@@ -38,14 +37,12 @@ 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
+const ansiLink = (text, url) => `\u001B]8;;${url}\u0007${text}\u001B]8;;\u0007`;
 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.`);
+These processes have been terminated. In case this creates a problem for your build, refer to this ${ansiLink('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/mutations.js

@@ -1,6 +1,6 @@
 import { promises as fs } from 'fs';
 import { inspect } from 'util';
-import { pathExists } from 'path-exists';
+import { pathExists } from '../../utils/path_exists.js';
 import { log, logMessage, logSubHeader } from '../logger.js';
 export const logConfigMutations = function (logs, newConfigMutations, debug) {
     const configMutationsToLog = debug ? newConfigMutations : newConfigMutations.filter(shouldLogConfigMutation);

package/lib/plugins/child/diff.js

@@ -1,6 +1,6 @@
 import { isDeepStrictEqual } from 'util';
-import isPlainObj from 'is-plain-obj';
 import rfdc from 'rfdc';
+import { isPlainObject } from '../../utils/is_plain_object.js';
 const clone = rfdc();
 // Copy `netlifyConfig` so we can compare before/after mutating it
 export function cloneNetlifyConfig(netlifyConfig) {
@@ -26,7 +26,7 @@ function diffObjects(objA, objB, parentKeys) {
         const valueA = objA[key];
         const valueB = objB[key];
         const keys = [...parentKeys, key];
-        if (isPlainObj(valueA) && isPlainObj(valueB)) {
+        if (isPlainObject(valueA) && isPlainObject(valueB)) {
             return diffObjects(valueA, valueB, keys);
         }
         if (isDeepStrictEqual(valueA, valueB)) {

package/lib/plugins/child/load.d.ts

@@ -7,7 +7,9 @@ export declare const load: ({ pluginPath, inputs, packageJson, verbose, netlifyC
 }) => Promise<{
     events: string[];
     context: {
-        methods: Partial<any>;
+        methods: {
+            [k: string]: unknown;
+        };
         inputs: any;
         packageJson: any;
         verbose: any;

package/lib/plugins/child/load.js

@@ -1,4 +1,3 @@
-import { includeKeys } from 'filter-obj';
 import { getLogic } from './logic.js';
 import { registerTypeScript } from './typescript.js';
 import { validatePlugin } from './validate.js';
@@ -11,12 +10,12 @@ export const load = async function ({ pluginPath, inputs, packageJson, verbose,
     const tsNodeService = registerTypeScript(pluginPath);
     const logic = await getLogic({ pluginPath, inputs, tsNodeService, netlifyConfig });
     validatePlugin(logic);
-    const methods = includeKeys(logic, isEventHandler);
+    const methods = Object.fromEntries(Object.entries(logic).filter(([, value]) => isEventHandler(value)));
     const events = Object.keys(methods);
     // Context passed to every event handler
     const context = { methods, inputs, packageJson, verbose };
     return { events, context };
 };
-const isEventHandler = function (_event, value) {
+const isEventHandler = function (value) {
     return typeof value === 'function';
 };

package/lib/plugins/child/status.js

@@ -1,5 +1,5 @@
-import isPlainObj from 'is-plain-obj';
 import { addErrorInfo } from '../../error/info.js';
+import { isPlainObject } from '../../utils/is_plain_object.js';
 // Report status information to the UI
 export const show = function (runState, showArgs) {
     validateShowArgs(showArgs);
@@ -29,7 +29,7 @@ function validateShowArgsObject(showArgs) {
     if (showArgs === undefined) {
         throw new Error('requires an argument');
     }
-    if (!isPlainObj(showArgs)) {
+    if (!isPlainObject(showArgs)) {
         throw new Error('argument must be a plain object');
     }
 }

package/lib/plugins/compatibility.js

@@ -1,4 +1,3 @@
-import pLocate from 'p-locate';
 import semver from 'semver';
 import { CONDITIONS } from './plugin_conditions.js';
 /**
@@ -47,7 +46,9 @@ export const getExpectedVersion = async function ({ versions, nodeVersion, packa
 const getCompatibleEntry = async function ({ versions, nodeVersion, packageJson, packageName, packagePath, buildDir, pinnedVersion, featureFlags, systemLog = () => {
     // no-op
 }, }) {
-    const compatibleEntry = await pLocate(versions, async ({ version, overridePinnedVersion, conditions }) => {
+    let compatibleEntry;
+    for (const entry of versions) {
+        const { version, overridePinnedVersion, conditions } = entry;
         // When there's a `pinnedVersion`, we typically pick the first version that
         // matches that range. The exception is if `overridePinnedVersion` is also
         // present. This property says that if the pinned version is within a given
@@ -57,14 +58,18 @@ const getCompatibleEntry = async function ({ versions, nodeVersion, packageJson,
         // If there's a pinned version and this entry doesn't satisfy that range,
         // discard it. The exception is if this entry overrides the pinned version.
         if (pinnedVersion && !overridesPin && !semver.satisfies(version, pinnedVersion, { includePrerelease: true })) {
-            return false;
+            continue;
         }
         // no conditions means nothing to filter
         if (conditions.length === 0 && pinnedVersion === undefined) {
-            return false;
+            continue;
         }
-        return (await Promise.all(conditions.map(async ({ type, condition }) => CONDITIONS[type].test(condition, { nodeVersion, packageJson, packagePath, buildDir })))).every(Boolean);
-    });
+        const isCompatible = (await Promise.all(conditions.map(async ({ type, condition }) => CONDITIONS[type].test(condition, { nodeVersion, packageJson, packagePath, buildDir })))).every(Boolean);
+        if (isCompatible) {
+            compatibleEntry = entry;
+            break;
+        }
+    }
     if (compatibleEntry) {
         systemLog(`Used compatible version '${compatibleEntry.version}' for plugin '${packageName}' (pinned version is ${pinnedVersion})`);
         return compatibleEntry;
@@ -91,12 +96,19 @@ const getCompatibleEntry = async function ({ versions, nodeVersion, packageJson,
  * the conditions (if any), without taking into account the pinned version.
  */
 const getFirstCompatibleEntry = async function ({ versions, nodeVersion, packageJson, packagePath, buildDir, }) {
-    const compatibleEntry = await pLocate(versions, async ({ conditions }) => {
+    let compatibleEntry;
+    for (const entry of versions) {
+        const { conditions } = entry;
         if (conditions.length === 0) {
-            return true;
+            compatibleEntry = entry;
+            break;
         }
-        return (await Promise.all(conditions.map(async ({ type, condition }) => CONDITIONS[type].test(condition, { nodeVersion, packageJson, packagePath, buildDir })))).every(Boolean);
-    });
+        const isCompatible = (await Promise.all(conditions.map(async ({ type, condition }) => CONDITIONS[type].test(condition, { nodeVersion, packageJson, packagePath, buildDir })))).every(Boolean);
+        if (isCompatible) {
+            compatibleEntry = entry;
+            break;
+        }
+    }
     if (compatibleEntry) {
         return compatibleEntry;
     }

package/lib/plugins/ipc.js

@@ -1,7 +1,6 @@
 import crypto from 'crypto';
 import process from 'process';
 import { promisify } from 'util';
-import { pEvent } from 'p-event';
 import { jsonToError, errorToJson } from '../error/build.js';
 import { addErrorInfo } from '../error/info.js';
 import { logSendingEventToChild, logSentEventToChild, logReceivedEventFromChild, logSendingEventToParent, } from '../log/messages/ipc.js';
@@ -24,38 +23,36 @@ export const callChild = async function ({ childProcess, eventName, payload, log
 //    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: (data) => data?.[0] === callId });
-    const errorPromise = pEvent(childProcess, 'message', { filter: (data) => data?.[0] === '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();
-    }
+    return new Promise((resolve, reject) => {
+        const onMessage = function (data) {
+            if (data?.[0] === callId) {
+                cleanup();
+                resolve(data[1]);
+            }
+            else if (data?.[0] === 'error') {
+                cleanup();
+                reject(jsonToError(data[1]));
+            }
+        };
+        const onExit = function (exitCode, signal) {
+            cleanup();
+            reject(getChildExitError(`Plugin exited with exit code ${exitCode} and signal ${signal}.`));
+        };
+        const cleanup = function () {
+            childProcess.removeListener('message', onMessage);
+            childProcess.removeListener('exit', onExit);
+        };
+        childProcess.on('message', onMessage);
+        childProcess.on('exit', onExit);
+    });
 };
 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

package/lib/plugins/list.js

@@ -1,5 +1,5 @@
 import { pluginsUrl, pluginsList as oldPluginsList } from '@netlify/plugins-list';
-import isPlainObj from 'is-plain-obj';
+import { isPlainObject } from '../utils/is_plain_object.js';
 import { logPluginsList, logPluginsFetchError } from '../log/messages/plugins.js';
 import { CONDITIONS } from './plugin_conditions.js';
 /** 1 minute HTTP request timeout */
@@ -49,7 +49,7 @@ const fetchPluginsList = async function ({ logs, pluginsListUrl, }) {
     }
 };
 const isValidPluginsList = function (pluginsList) {
-    return Array.isArray(pluginsList) && pluginsList.every(isPlainObj);
+    return Array.isArray(pluginsList) && pluginsList.every(isPlainObject);
 };
 const normalizePluginsList = function (pluginsList) {
     return Object.fromEntries(pluginsList.map(normalizePluginItem));

package/lib/plugins/manifest/validate.js

@@ -1,5 +1,5 @@
-import isPlainObj from 'is-plain-obj';
 import { THEME } from '../../log/theme.js';
+import { isPlainObject } from '../../utils/is_plain_object.js';
 // Validate `manifest.yml` syntax
 export const validateManifest = function (manifest, rawManifest) {
     try {
@@ -17,7 +17,7 @@ ${rawManifest.trim()}`;
     }
 };
 const validateBasic = function (manifest) {
-    if (!isPlainObj(manifest)) {
+    if (!isPlainObject(manifest)) {
         throw new Error('must be a plain object');
     }
 };
@@ -46,7 +46,7 @@ const validateInputs = function ({ inputs }) {
     inputs.forEach(validateInput);
 };
 const isArrayOfObjects = function (objects) {
-    return Array.isArray(objects) && objects.every(isPlainObj);
+    return Array.isArray(objects) && objects.every(isPlainObject);
 };
 const validateInput = function (input, index) {
     try {

package/lib/plugins/spawn.js

@@ -111,22 +111,32 @@ export const stopPlugins = async function ({ childProcesses, logs, verbose, plug
 };
 const stopPlugin = async function ({ childProcess, logs, pluginOptions: { packageName, inputs, pluginPath, pluginPackageJson: packageJson = {} }, netlifyConfig, verbose, }) {
     if (childProcess.connected) {
-        // reliable stop tracing inside child processes
-        await callChild({
-            childProcess,
-            eventName: 'shutdown',
-            payload: {
-                packageName,
-                pluginPath,
-                inputs,
-                packageJson,
+        try {
+            // reliable stop tracing inside child processes
+            await callChild({
+                childProcess,
+                eventName: 'shutdown',
+                payload: {
+                    packageName,
+                    pluginPath,
+                    inputs,
+                    packageJson,
+                    verbose,
+                    netlifyConfig,
+                },
+                logs,
                 verbose,
-                netlifyConfig,
-            },
-            logs,
-            verbose,
-        });
-        childProcess.disconnect();
+            });
+        }
+        catch {
+            // The child process may exit before responding, e.g. when it already
+            // failed. It is being terminated anyway, so ignore the error
+        }
+        finally {
+            if (childProcess.connected) {
+                childProcess.disconnect();
+            }
+        }
     }
     // On Windows with Node 21+, there's a bug where attempting to kill a child process
     // results in an EPERM error. Ignore the error in that case.

package/lib/plugins_core/blobs_upload/index.js

@@ -1,6 +1,5 @@
 import { getDeployStore } from '@netlify/blobs';
 import { inspect } from 'node:util';
-import pMap from 'p-map';
 import { DEFAULT_API_HOST } from '../../core/normalize_flags.js';
 import { logError } from '../../log/logger.js';
 import { getFileWithMetadata, getKeysToUpload, scanForBlobs } from '../../utils/blobs.js';
@@ -38,12 +37,25 @@ const coreStep = async function ({ logs, deployId, buildDir, packagePath, consta
     }
     systemLog(`Uploading ${blobsToUpload.length} blobs to deploy store...`);
     try {
-        await pMap(blobsToUpload, async ({ key, contentPath, metadataPath }) => {
-            const { data, metadata } = await getFileWithMetadata(key, contentPath, metadataPath);
-            // `data` is a `Buffer`, typed by @types/node as `Buffer<ArrayBufferLike>`, which TS
-            // rejects as a `BlobPart`; the runtime value is a valid blob part.
-            await blobStore.set(key, new Blob([data]), { metadata });
-        }, { concurrency: 10 });
+        const queue = blobsToUpload[Symbol.iterator]();
+        let stopQueue = false;
+        await Promise.all(Array.from({ length: 10 }, async () => {
+            while (!stopQueue) {
+                const next = queue.next();
+                if (next.done) {
+                    return;
+                }
+                const { key, contentPath, metadataPath } = next.value;
+                try {
+                    const { data, metadata } = await getFileWithMetadata(key, contentPath, metadataPath);
+                    await blobStore.set(key, new Blob([data]), { metadata });
+                }
+                catch (error) {
+                    stopQueue = true;
+                    throw error;
+                }
+            }
+        }));
     }
     catch (err) {
         logError(logs, `Error uploading blobs to deploy store: ${err.message}`);

package/lib/plugins_core/db_setup/migrations.js

@@ -1,6 +1,6 @@
 import { copyFile, mkdir } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
-import { pathExists } from 'path-exists';
+import { pathExists } from '../../utils/path_exists.js';
 import { readMigrationEntries, getMigrationsSrc } from './utils.js';
 import { validateMigrations, formatValidationErrors } from './validation.js';
 const condition = async ({ featureFlags, constants, buildDir }) => {

package/lib/plugins_core/db_setup/utils.js

@@ -1,6 +1,6 @@
 import { readdir, stat } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
-import { pathExists } from 'path-exists';
+import { pathExists } from '../../utils/path_exists.js';
 // TODO: Remove once we drop support for the legacy `netlify/db/migrations` directory.
 const LEGACY_DB_MIGRATIONS_SRC = 'netlify/db/migrations';
 /**

package/lib/plugins_core/deploy/buildbot_client.js

@@ -1,7 +1,7 @@
+import { once } from 'events';
 import net from 'net';
 import { normalize, resolve, relative } from 'path';
 import { promisify } from 'util';
-import { pEvent } from 'p-event';
 import { addErrorInfo } from '../../error/info.js';
 import { runsAfterDeploy } from '../../plugins/events.js';
 import { addAsyncErrorMessage } from '../../utils/errors.js';
@@ -41,7 +41,7 @@ const getConnectionOpts = function (buildbotServerSocket) {
  * Emits the connect event
  */
 export const connectBuildbotClient = addAsyncErrorMessage(async (client) => {
-    await pEvent(client, 'connect');
+    await once(client, 'connect');
 }, 'Could not connect to buildbot');
 /**
  * Closes the buildbot client and its connection
@@ -56,7 +56,7 @@ const writePayload = addAsyncErrorMessage(async (buildbotClient, payload) => {
     await promisify(buildbotClient.write.bind(buildbotClient))(JSON.stringify(payload));
 }, 'Could not send payload to buildbot');
 const getNextParsedResponsePromise = addAsyncErrorMessage(async (buildbotClient) => {
-    const data = await pEvent(buildbotClient, 'data');
+    const [data] = await once(buildbotClient, 'data');
     return JSON.parse(data);
 }, 'Invalid response from buildbot');
 /**

package/lib/plugins_core/dev_blobs_upload/index.js

@@ -1,5 +1,4 @@
 import { getDeployStore } from '@netlify/blobs';
-import pMap from 'p-map';
 import { log, logError } from '../../log/logger.js';
 import { getFileWithMetadata, getKeysToUpload, scanForBlobs } from '../../utils/blobs.js';
 import { getBlobs } from '../../utils/frameworks_api.js';
@@ -42,15 +41,28 @@ const coreStep = async function ({ debug, logs, deployId, buildDir, quiet, packa
         log(logs, `Uploading ${blobsToUpload.length} blobs to deploy store...`);
     }
     try {
-        await pMap(blobsToUpload, async ({ key, contentPath, metadataPath }) => {
-            if (debug && !quiet) {
-                log(logs, `- Uploading blob ${key}`, { indent: true });
+        const queue = blobsToUpload[Symbol.iterator]();
+        let stopQueue = false;
+        await Promise.all(Array.from({ length: 10 }, async () => {
+            while (!stopQueue) {
+                const next = queue.next();
+                if (next.done) {
+                    return;
+                }
+                const { key, contentPath, metadataPath } = next.value;
+                if (debug && !quiet) {
+                    log(logs, `- Uploading blob ${key}`, { indent: true });
+                }
+                try {
+                    const { data, metadata } = await getFileWithMetadata(key, contentPath, metadataPath);
+                    await blobStore.set(key, new Blob([data]), { metadata });
+                }
+                catch (err) {
+                    stopQueue = true;
+                    throw err;
+                }
             }
-            const { data, metadata } = await getFileWithMetadata(key, contentPath, metadataPath);
-            // `data` is a `Buffer`, typed by @types/node as `Buffer<ArrayBufferLike>`, which TS
-            // rejects as a `BlobPart`; the runtime value is a valid blob part.
-            await blobStore.set(key, new Blob([data]), { metadata });
-        }, { concurrency: 10 });
+        }));
     }
     catch (err) {
         logError(logs, `Error uploading blobs to deploy store: ${err.message}`);

package/lib/plugins_core/edge_functions/index.js

@@ -1,7 +1,7 @@
 import { promises as fs } from 'fs';
 import { dirname, join, resolve } from 'path';
 import { bundle, find } from '@netlify/edge-bundler';
-import { pathExists } from 'path-exists';
+import { pathExists } from '../../utils/path_exists.js';
 import { log, reduceLogLines } from '../../log/logger.js';
 import { logFunctionsToBundle } from '../../log/messages/core_steps.js';
 import { FRAMEWORKS_API_EDGE_FUNCTIONS_PATH, FRAMEWORKS_API_EDGE_FUNCTIONS_IMPORT_MAP, } from '../../utils/frameworks_api.js';

package/lib/plugins_core/frameworks_api/util.js

@@ -1,7 +1,7 @@
 import { promises as fs } from 'fs';
 import { resolve } from 'path';
-import isPlainObject from 'is-plain-obj';
 import { FRAMEWORKS_API_CONFIG_PATH } from '../../utils/frameworks_api.js';
+import { isPlainObject } from '../../utils/is_plain_object.js';
 export const loadConfigFile = async (buildDir, packagePath) => {
     const configPath = resolve(buildDir, packagePath ?? '', FRAMEWORKS_API_CONFIG_PATH);
     try {

package/lib/plugins_core/functions/index.js

@@ -1,6 +1,6 @@
 import { resolve } from 'path';
 import { zipFunctions } from '@netlify/zip-it-and-ship-it';
-import { pathExists } from 'path-exists';
+import { pathExists } from '../../utils/path_exists.js';
 import { addErrorInfo } from '../../error/info.js';
 import { log } from '../../log/logger.js';
 import { getGeneratedFunctions } from '../../steps/return_values.js';

package/lib/plugins_core/functions/server_entry.js

@@ -1,6 +1,6 @@
 import { mkdir, readdir, writeFile } from 'fs/promises';
 import { join, resolve } from 'path';
-import { pathExists } from 'path-exists';
+import { pathExists } from '../../utils/path_exists.js';
 import { addErrorInfo } from '../../error/info.js';
 export const SERVER_ENTRY_FUNCTION_NAME = '___netlify-server';
 const SERVER_ENTRY_DIR = 'netlify/server';

package/lib/plugins_core/functions_install/index.js

@@ -1,5 +1,5 @@
-import { pathExists } from 'path-exists';
 import { installFunctionDependencies } from '../../install/functions.js';
+import { pathExists } from '../../utils/path_exists.js';
 // Plugin to package Netlify functions with @netlify/zip-it-and-ship-it
 export const onPreBuild = async function ({ constants: { FUNCTIONS_SRC, IS_LOCAL } }) {
     if (!(await pathExists(FUNCTIONS_SRC))) {

package/lib/steps/update_config.d.ts

@@ -23,4 +23,4 @@ export function updateNetlifyConfig({ configOpts, netlifyConfig, defaultConfig,
     headersPath: any;
     redirectsPath: any;
 }>;
-export function listConfigSideFiles(sideFiles: any): Promise<string[]>;
+export function listConfigSideFiles(sideFiles: any): Promise<any[]>;

package/lib/steps/update_config.js

@@ -1,10 +1,9 @@
 import { isDeepStrictEqual } from 'util';
-import pFilter from 'p-filter';
-import { pathExists } from 'path-exists';
 import { resolveUpdatedConfig } from '../core/config.js';
 import { addErrorInfo } from '../error/info.js';
 import { logConfigOnUpdate } from '../log/messages/config.js';
 import { logConfigMutations, systemLogConfigMutations } from '../log/messages/mutations.js';
+import { pathExists } from '../utils/path_exists.js';
 // If `netlifyConfig` was updated or `_redirects` was created, the configuration
 // is updated by calling `@netlify/config` again.
 export const updateNetlifyConfig = async function ({ configOpts, netlifyConfig, defaultConfig, headersPath, redirectsPath, configMutations, newConfigMutations, configSideFiles, errorParams, logs, systemLog, debug, source = '', }) {
@@ -51,8 +50,8 @@ const haveConfigSideFilesChanged = async function (configSideFiles, headersPath,
 // sometimes have higher priority and should therefore be deleted in order to
 // apply any configuration update on `netlify.toml`.
 export const listConfigSideFiles = async function (sideFiles) {
-    const configSideFiles = await pFilter(sideFiles, pathExists);
-    return configSideFiles.sort();
+    const existingSideFiles = await Promise.all(sideFiles.map(async (sideFile) => ((await pathExists(sideFile)) ? sideFile : null)));
+    return existingSideFiles.filter(Boolean).sort();
 };
 // Validate each new configuration change
 const validateConfigMutations = function (newConfigMutations) {

package/lib/utils/blobs.d.ts

@@ -38,7 +38,7 @@ export declare const getKeysToUpload: (blobsDir: string) => Promise<{
 }[]>;
 /** Read a file and its metadata file from the blobs directory */
 export declare const getFileWithMetadata: (key: string, contentPath: string, metadataPath?: string) => Promise<{
-    data: Buffer;
+    data: Buffer<ArrayBuffer>;
     metadata: Record<string, string>;
 }>;
 export {};

package/lib/utils/is_plain_object.d.ts

@@ -0,0 +1 @@
+export declare const isPlainObject: (value: unknown) => value is Record<string, unknown>;

package/lib/utils/is_plain_object.js

@@ -0,0 +1,7 @@
+export const isPlainObject = (value) => {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+};

package/lib/utils/omit.js

@@ -1,3 +1,2 @@
-import { excludeKeys } from 'filter-obj';
-// lodash.omit is 1400 lines of codes. filter-obj is much smaller and simpler.
-export const omit = (obj, keys) => excludeKeys(obj, (key) => keys.includes(key));
+// lodash.omit is 1400 lines of codes. This is much smaller and simpler.
+export const omit = (obj, keys) => Object.fromEntries(Object.entries(obj).filter(([key]) => !keys.includes(key)));

package/lib/utils/path_exists.d.ts

@@ -0,0 +1 @@
+export declare const pathExists: (path: string) => Promise<boolean>;

package/lib/utils/path_exists.js

@@ -0,0 +1,10 @@
+import { access } from 'node:fs/promises';
+export const pathExists = async (path) => {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};

package/lib/utils/remove_falsy.js

@@ -1,8 +1,7 @@
-import { includeKeys } from 'filter-obj';
 // Remove falsy values from object
 export const removeFalsy = function (obj) {
-    return includeKeys(obj, isDefined);
+    return Object.fromEntries(Object.entries(obj).filter(([, value]) => isDefined(value)));
 };
-const isDefined = function (_key, value) {
+const isDefined = function (value) {
     return value !== undefined && value !== '';
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/build",
-  "version": "36.4.0",
+  "version": "36.4.2",
   "description": "Netlify build module",
   "type": "module",
   "exports": "./lib/index.js",
@@ -68,40 +68,31 @@
   "dependencies": {
     "@bugsnag/js": "^8.0.0",
     "@netlify/blobs": "^10.4.4",
-    "@netlify/cache-utils": "^7.1.1",
+    "@netlify/cache-utils": "^7.1.2",
     "@netlify/config": "^25.2.3",
-    "@netlify/edge-bundler": "16.0.3",
+    "@netlify/edge-bundler": "16.0.4",
     "@netlify/functions-utils": "^7.1.5",
-    "@netlify/git-utils": "^7.1.0",
+    "@netlify/git-utils": "^7.1.1",
     "@netlify/opentelemetry-utils": "^3.1.0",
     "@netlify/plugins-list": "^6.81.6",
     "@netlify/run-utils": "^7.1.0",
     "@netlify/zip-it-and-ship-it": "15.4.0",
     "@sindresorhus/slugify": "^2.0.0",
-    "ansi-escapes": "^7.0.0",
     "ansis": "^4.1.0",
-    "clean-stack": "^5.0.0",
     "execa": "^8.0.0",
     "fast-string-width": "^3.0.2",
     "fdir": "^6.0.1",
     "figures": "^6.0.0",
-    "filter-obj": "^6.0.0",
     "hot-shots": "11.4.0",
     "ignore": "^7.0.0",
     "indent-string": "^5.0.0",
-    "is-plain-obj": "^4.0.0",
     "keep-func-props": "^6.0.0",
     "log-process-errors": "^11.0.0",
     "memoize-one": "^6.0.0",
     "minimatch": "^10.2.4",
     "os-name": "^6.0.0",
-    "p-event": "^6.0.0",
-    "p-filter": "^4.0.0",
-    "p-locate": "^6.0.0",
-    "p-map": "^7.0.0",
     "p-reduce": "^3.0.0",
     "package-directory": "^8.0.0",
-    "path-exists": "^5.0.0",
     "pretty-ms": "^9.0.0",
     "ps-list": "^8.0.0",
     "read-package-up": "^11.0.0",
@@ -152,5 +143,5 @@
   "engines": {
     "node": ">=22.12.0"
   },
-  "gitHead": "aaee524cfed2fc082e6cb7268ce7230071b39068"
+  "gitHead": "b858a683acc2054b39d923c45ca9fe8d87bd7d78"
 }