@netlify/build 35.7.1 → 35.8.0-1-experimental

package/lib/core/build.d.ts

@@ -89,4 +89,5 @@ export declare const runAndReportBuild: ({ pluginsOptions, netlifyConfig, defaul
     configMutations: never[] | undefined;
     metrics: never[] | undefined;
     returnValues: {} | undefined;
+    deployEnvVars: never[] | undefined;
 }>;

package/lib/core/build.js

@@ -86,7 +86,7 @@ const tExecBuild = async function ({ config, defaultConfig, cachedConfig, cached
     const pluginsOptions = addCorePlugins({ netlifyConfig, constants });
     // `errorParams` is purposely stateful
     Object.assign(errorParams, { netlifyConfig, pluginsOptions, siteInfo, childEnv, userNodeVersion });
-    const { pluginsOptions: pluginsOptionsA, netlifyConfig: netlifyConfigA, stepsCount, timers: timersB, configMutations, metrics, returnValues, } = await runAndReportBuild({
+    const { pluginsOptions: pluginsOptionsA, netlifyConfig: netlifyConfigA, stepsCount, timers: timersB, configMutations, metrics, returnValues, deployEnvVars, } = await runAndReportBuild({
         pluginsOptions,
         netlifyConfig,
         defaultConfig,
@@ -143,13 +143,14 @@ const tExecBuild = async function ({ config, defaultConfig, cachedConfig, cached
         configMutations,
         metrics,
         returnValues,
+        deployEnvVars,
     };
 };
 export const execBuild = measureDuration(tExecBuild, 'total', { parentTag: 'build_site' });
 // Runs a build then report any plugin statuses
 export const runAndReportBuild = async function ({ pluginsOptions, netlifyConfig, defaultConfig, configOpts, siteInfo, configPath, outputConfigPath, headersPath, redirectsPath, packagePath, buildDir, repositoryRoot, nodePath, packageJson, userNodeVersion, childEnv, context, branch, buildbotServerSocket, constants, dry, mode, api, token, errorMonitor, deployId, errorParams, logs, debug, systemLog, systemLogFile, verbose, timers, sendStatus, saveConfig, testOpts, featureFlags, timeline, devCommand, quiet, integrations, explicitSecretKeys, enhancedSecretScan, edgeFunctionsBootstrapURL, eventHandlers, }) {
     try {
-        const { stepsCount, netlifyConfig: netlifyConfigA, statuses, pluginsOptions: pluginsOptionsA, failedPlugins, timers: timersA, configMutations, metrics, returnValues, } = await initAndRunBuild({
+        const { stepsCount, netlifyConfig: netlifyConfigA, statuses, pluginsOptions: pluginsOptionsA, failedPlugins, timers: timersA, configMutations, metrics, returnValues, deployEnvVars, } = await initAndRunBuild({
             pluginsOptions,
             netlifyConfig,
             defaultConfig,
@@ -234,6 +235,7 @@ export const runAndReportBuild = async function ({ pluginsOptions, netlifyConfig
             configMutations,
             metrics,
             returnValues,
+            deployEnvVars,
         };
     }
     catch (error) {
@@ -306,7 +308,7 @@ const initAndRunBuild = async function ({ pluginsOptions, netlifyConfig, default
         systemLogFile,
     });
     try {
-        const { stepsCount, netlifyConfig: netlifyConfigA, statuses, failedPlugins, timers: timersC, configMutations, metrics, returnValues, } = await runBuild({
+        const { stepsCount, netlifyConfig: netlifyConfigA, statuses, failedPlugins, timers: timersC, configMutations, metrics, returnValues, deployEnvVars, } = await runBuild({
             childProcesses,
             pluginsOptions: pluginsOptionsA,
             netlifyConfig,
@@ -363,6 +365,7 @@ const initAndRunBuild = async function ({ pluginsOptions, netlifyConfig, default
             configMutations,
             metrics,
             returnValues,
+            deployEnvVars,
         };
     }
     finally {
@@ -400,7 +403,7 @@ const runBuild = async function ({ childProcesses, pluginsOptions, netlifyConfig
         await doDryRun({ buildDir, steps, netlifyConfig, constants, buildbotServerSocket, logs, featureFlags });
         return { netlifyConfig };
     }
-    const { stepsCount, netlifyConfig: netlifyConfigA, statuses, failedPlugins, timers: timersB, configMutations, metrics, returnValues, } = await runSteps({
+    const { stepsCount, netlifyConfig: netlifyConfigA, statuses, failedPlugins, timers: timersB, configMutations, metrics, returnValues, deployEnvVars, } = await runSteps({
         steps,
         buildbotServerSocket,
         events,
@@ -447,5 +450,6 @@ const runBuild = async function ({ childProcesses, pluginsOptions, netlifyConfig
         configMutations,
         metrics,
         returnValues,
+        deployEnvVars,
     };
 };

package/lib/core/dev.d.ts

@@ -5,6 +5,7 @@ export function startDev(devCommand: any, flags?: {}): Promise<{
     logs: import("../log/logger.js").Logs | undefined;
     configMutations: any;
     generatedFunctions: import("../steps/return_values.js").GeneratedFunction[];
+    deployEnvVars: any;
     error?: undefined;
 } | {
     success: boolean;
@@ -14,6 +15,7 @@ export function startDev(devCommand: any, flags?: {}): Promise<{
         message: string;
         stack: string;
     };
+    deployEnvVars: never[];
     netlifyConfig?: undefined;
     configMutations?: undefined;
     generatedFunctions?: undefined;

package/lib/core/dev.js

@@ -6,7 +6,7 @@ export const startDev = async (devCommand, flags = {}) => {
     const { errorMonitor, mode, logs, debug, testOpts, ...normalizedFlags } = startBuild(flags);
     const errorParams = { errorMonitor, mode, logs, debug, testOpts };
     try {
-        const { netlifyConfig: netlifyConfigA, configMutations, returnValues, } = await execBuild({
+        const { netlifyConfig: netlifyConfigA, configMutations, returnValues, deployEnvVars, } = await execBuild({
             ...normalizedFlags,
             errorMonitor,
             errorParams,
@@ -25,11 +25,12 @@ export const startDev = async (devCommand, flags = {}) => {
             logs,
             configMutations,
             generatedFunctions: getGeneratedFunctions(returnValues),
+            deployEnvVars,
         };
     }
     catch (error) {
         const { severity, message, stack } = await handleBuildError(error, errorParams);
         const { success, severityCode } = getSeverity(severity);
-        return { success, severityCode, logs, error: { message, stack } };
+        return { success, severityCode, logs, error: { message, stack }, deployEnvVars: [] };
     }
 };

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

@@ -1 +1 @@
-export function addLazyProp(object: any, propName: any, getFunc: any): void;
+export declare const addLazyProp: (object: object, propName: string, getFunc: () => unknown) => void;

package/lib/plugins/child/lazy.js

@@ -2,6 +2,8 @@ import memoizeOne from 'memoize-one';
 // Add a `object[propName]` whose value is the return value of `getFunc()`, but
 // is only retrieved when accessed.
 export const addLazyProp = function (object, propName, getFunc) {
+    // @ts-expect-error(ndhoule): dis be angry
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
     const mGetFunc = memoizeOne(getFunc, returnTrue);
     // Mutation is required due to the usage of `Object.defineProperty()`
     Object.defineProperty(object, propName, {

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

@@ -13,6 +13,7 @@ export function run({ event, error, constants, envChanges, featureFlags, netlify
     packageJson: any;
     verbose: any;
 }): Promise<{
+    deployEnvVars: any[];
     newEnvChanges: any;
     configMutations: any;
     returnValue: {

package/lib/plugins/child/run.js

@@ -13,8 +13,9 @@ export const run = async function ({ event, error, constants, envChanges, featur
         const method = methods[event];
         const runState = {};
         const generatedFunctions = [];
+        const deployEnvVars = [];
         const systemLog = getSystemLog();
-        const utils = getUtils({ event, constants, generatedFunctions, runState });
+        const utils = getUtils({ event, constants, deployEnvVars, generatedFunctions, runState });
         const netlifyConfigCopy = cloneNetlifyConfig(netlifyConfig);
         const runOptions = {
             utils,
@@ -34,6 +35,6 @@ export const run = async function ({ event, error, constants, envChanges, featur
         const newEnvChanges = getNewEnvChanges(envBefore, netlifyConfig, netlifyConfigCopy);
         const configMutations = getConfigMutations(netlifyConfig, netlifyConfigCopy, event);
         const returnValue = generatedFunctions.length ? { generatedFunctions } : undefined;
-        return { ...runState, newEnvChanges, configMutations, returnValue };
+        return { ...runState, deployEnvVars, newEnvChanges, configMutations, returnValue };
     });
 };

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

@@ -1 +1 @@
-export function show(runState: any, showArgs: any): void;
+export declare const show: (runState: Record<string, unknown>, showArgs: Record<string, unknown>) => void;

package/lib/plugins/child/status.js

@@ -17,19 +17,22 @@ const validateShowArgs = function (showArgs) {
         validateShowArgsExtraData(extraData);
     }
     catch (error) {
+        if (!(error instanceof Error)) {
+            throw error;
+        }
         error.message = `utils.status.show() ${error.message}`;
         addErrorInfo(error, { type: 'pluginValidation' });
         throw error;
     }
 };
-const validateShowArgsObject = function (showArgs) {
+function validateShowArgsObject(showArgs) {
     if (showArgs === undefined) {
         throw new Error('requires an argument');
     }
     if (!isPlainObj(showArgs)) {
         throw new Error('argument must be a plain object');
     }
-};
+}
 const validateShowArgsKeys = function (otherArgs) {
     const otherKeys = Object.keys(otherArgs).map((arg) => `"${arg}"`);
     if (otherKeys.length !== 0) {
@@ -42,12 +45,12 @@ const validateStringArg = function ([key, value]) {
     }
 };
 const validateShowArgsSummary = function (summary) {
-    if (summary === undefined || summary.trim() === '') {
+    if (typeof summary !== 'string' || summary.trim() === '') {
         throw new Error('requires specifying a "summary" property');
     }
 };
 const validateShowArgsExtraData = function (extraData) {
-    if (extraData !== undefined && Array.isArray(extraData) === false) {
+    if (extraData !== undefined && !Array.isArray(extraData)) {
         throw new TypeError('provided extra data must be an array');
     }
 };

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

@@ -1,34 +1,19 @@
-export function getUtils({ event, constants: { FUNCTIONS_SRC, INTERNAL_FUNCTIONS_SRC, CACHE_DIR }, generatedFunctions, runState, }: {
-    event: any;
-    constants: {
-        FUNCTIONS_SRC: any;
-        INTERNAL_FUNCTIONS_SRC: any;
-        CACHE_DIR: any;
-    };
-    generatedFunctions?: never[] | undefined;
-    runState: any;
-}): {
-    build: {
-        failPlugin: (message: any, opts: any) => never;
-        failBuild: any;
-        cancelBuild: any;
-    };
-    cache: {
-        save: (paths: any, optsA: any) => Promise<any>;
-        restore: (paths: any, optsA: any) => Promise<any>;
-        remove: (paths: any, optsA: any) => Promise<any>;
-        has: (paths: any, optsA: any) => Promise<any>;
-        list: (optsA: any) => Promise<string[]>;
-        getCacheDir: (optsA: any) => string;
-    };
-    run: (file: string, args?: string[] | object, options?: import("execa").Options) => import("execa").ExecaChildProcess<string>;
-    functions: {
-        add: (src: any) => Promise<void>;
-        list: any;
-        listAll: any;
-        generate: (functionPath: any) => any;
-    };
-    status: {
-        show: any;
-    };
-};
+import type { NetlifyPluginConstants } from '../../core/constants.js';
+import type { ReturnValue } from '../../steps/return_values.ts';
+import type { NetlifyPluginUtils } from '../../types/options/netlify_plugin_utils.js';
+type BuildEvent = 'onPreBuild' | 'onBuild' | 'onPostBuild' | 'onError' | 'onSuccess' | 'onEnd';
+type RunState = Record<string, unknown>;
+type DeployEnvVarsData = {
+    key: string;
+    value: string;
+    isSecret: boolean;
+    scopes: string[];
+}[];
+export declare const getUtils: ({ event, constants: { FUNCTIONS_SRC, INTERNAL_FUNCTIONS_SRC, CACHE_DIR }, generatedFunctions, runState, deployEnvVars, }: {
+    event: BuildEvent;
+    constants: NetlifyPluginConstants;
+    generatedFunctions?: ReturnValue["generatedFunctions"];
+    runState: RunState;
+    deployEnvVars: DeployEnvVarsData;
+}) => NetlifyPluginUtils;
+export {};

package/lib/plugins/child/utils.js

@@ -1,22 +1,56 @@
 import { bindOpts as cacheBindOpts } from '@netlify/cache-utils';
 import { add as functionsAdd, list as functionsList, listAll as functionsListAll } from '@netlify/functions-utils';
 import { getGitUtils } from '@netlify/git-utils';
-import { run, runCommand } from '@netlify/run-utils';
+import { run as baseRun, runCommand } from '@netlify/run-utils';
 import { failBuild, failPlugin, cancelBuild, failPluginWithWarning } from '../error.js';
 import { isSoftFailEvent } from '../events.js';
+import { isReservedEnvironmentVariableKey } from '../../utils/environment.js';
 import { addLazyProp } from './lazy.js';
 import { show } from './status.js';
 // Retrieve the `utils` argument.
-export const getUtils = function ({ event, constants: { FUNCTIONS_SRC, INTERNAL_FUNCTIONS_SRC, CACHE_DIR }, generatedFunctions = [], runState, }) {
-    run.command = runCommand;
+export const getUtils = function ({ event, constants: { FUNCTIONS_SRC, INTERNAL_FUNCTIONS_SRC, CACHE_DIR }, generatedFunctions = [], runState, deployEnvVars = [], }) {
+    const run = Object.assign(baseRun, { command: runCommand });
     const build = getBuildUtils(event);
     const cache = getCacheUtils(CACHE_DIR);
+    const deploy = getDeployUtils({ deployEnvVars });
     const functions = getFunctionsUtils(FUNCTIONS_SRC, INTERNAL_FUNCTIONS_SRC, generatedFunctions);
     const status = getStatusUtils(runState);
-    const utils = { build, cache, run, functions, status };
+    const utils = { build, cache, deploy, functions, run, status };
     addLazyProp(utils, 'git', () => getGitUtils());
     return utils;
 };
+const getDeployUtils = ({ deployEnvVars }) => {
+    const env = {
+        add(key, value, { isSecret = false, scopes = [] } = {}) {
+            // Do some basic client-side validation on the injected variables. The build happens long
+            // before we attempt to create these environment variables via the Netlify API. We want to
+            // give the user as much immediate feedback as possible, so we perform this validation in the
+            // build plugin as to direct the user on which build plugin is causing a problem.
+            if (isReservedEnvironmentVariableKey(key)) {
+                throw new Error(`utils.deploy.env.add() failed: "${key}" is a reserved environment variable in Netlify deployments. Use a different environment variable key.`);
+            }
+            let normalizedScopes = new Set(...scopes);
+            if (normalizedScopes.size === 0) {
+                normalizedScopes = new Set(
+                // If the user did not specify scopes, we assume they mean all valid scopes. Secrets are
+                // not permitted in the post-processing scope.
+                isSecret ? ['builds', 'functions', 'runtime'] : ['builds', 'functions', 'post_processing', 'runtime']);
+            }
+            if (isSecret && normalizedScopes.has('post_processing')) {
+                throw new Error(`utils.deploy.env.add() failed: The "post_processing" scope cannot be used with isSecret=true.`);
+            }
+            const existingDeployEnvVarIdx = deployEnvVars.findIndex((env) => env.key === key);
+            if (existingDeployEnvVarIdx !== -1) {
+                deployEnvVars[existingDeployEnvVarIdx] = { key, value, isSecret, scopes: Array.from(normalizedScopes) };
+            }
+            else {
+                deployEnvVars.push({ key, value, isSecret, scopes: Array.from(normalizedScopes) });
+            }
+            return env;
+        },
+    };
+    return Object.freeze({ env: Object.freeze(env) });
+};
 const getBuildUtils = function (event) {
     if (isSoftFailEvent(event)) {
         return {
@@ -36,7 +70,6 @@ const getFunctionsUtils = function (FUNCTIONS_SRC, INTERNAL_FUNCTIONS_SRC, gener
     const list = functionsList.bind(null, functionsDirectories, { fail: failBuild });
     const listAll = functionsListAll.bind(null, functionsDirectories, { fail: failBuild });
     const generate = (functionPath) => generatedFunctions.push({ path: functionPath });
-    /** @type import('../../types/options/netlify_plugin_functions_util.js').NetlifyPluginFunctionsUtil */
     return { add, list, listAll, generate };
 };
 const getStatusUtils = function (runState) {

package/lib/plugins/error.d.ts

@@ -1,4 +1,16 @@
-export function failBuild(message: any, opts: any): never;
-export function failPlugin(message: any, opts: any): never;
-export function cancelBuild(message: any, opts: any): never;
-export function failPluginWithWarning(methodName: any, event: any, message: any, opts: any): void;
+export declare const failBuild: (message: string, opts?: {
+    error: Error;
+    errorMetadata: string[];
+}) => never;
+export declare const failPlugin: (message: string, opts?: {
+    error: Error;
+    errorMetadata: string[];
+}) => never;
+export declare const cancelBuild: (message: string, opts?: {
+    error: Error;
+    errorMetadata: string[];
+}) => never;
+export declare const failPluginWithWarning: (methodName: string, event: string, message: string, opts: {
+    error: Error;
+    errorMetadata: string[];
+}) => void;

package/lib/plugins_core/deploy/buildbot_client.d.ts

@@ -1,4 +1,5 @@
 import net from 'net';
+import type { NetlifyPluginConstants } from '../../core/constants.js';
 /**
  * Creates the Buildbot IPC client we use to initiate the deploy
  */
@@ -14,10 +15,15 @@ export declare const closeBuildbotClient: (client: net.Socket) => Promise<void>;
 /**
  * Initates the deploy with the given buildbot client
  */
-export declare const deploySiteWithBuildbotClient: ({ client, events, buildDir, repositoryRoot, constants }: {
-    client: any;
-    events: any;
-    buildDir: any;
-    repositoryRoot: any;
-    constants: any;
+export declare const deploySiteWithBuildbotClient: ({ client, environment, events, buildDir, repositoryRoot, constants, }: {
+    client: net.Socket;
+    environment: {
+        key: string;
+        value: string;
+        isSecret: boolean;
+    }[];
+    events: string[];
+    buildDir: string;
+    repositoryRoot: string;
+    constants: NetlifyPluginConstants;
 }) => Promise<undefined>;

package/lib/plugins_core/deploy/buildbot_client.js

@@ -62,11 +62,15 @@ const getNextParsedResponsePromise = addAsyncErrorMessage(async (buildbotClient)
 /**
  * Initates the deploy with the given buildbot client
  */
-export const deploySiteWithBuildbotClient = async function ({ client, events, buildDir, repositoryRoot, constants }) {
-    const action = shouldWaitForPostProcessing(events) ? Action.DeploySiteAndWait : Action.DeploySite;
-    const deployDir = getDeployDir({ buildDir, repositoryRoot, constants });
-    const payload = { action, deployDir };
-    const [response] = await Promise.all([getNextParsedResponsePromise(client), writePayload(client, payload)]);
+export const deploySiteWithBuildbotClient = async function ({ client, environment, events, buildDir, repositoryRoot, constants, }) {
+    const [response] = await Promise.all([
+        getNextParsedResponsePromise(client),
+        writePayload(client, {
+            action: shouldWaitForPostProcessing(events) ? Action.DeploySiteAndWait : Action.DeploySite,
+            deployDir: getDeployDir({ buildDir, repositoryRoot, constants }),
+            environment,
+        }),
+    ]);
     if (!response.succeeded) {
         const { error, code, error_type } = response?.values || {};
         return handleDeployError(error, code, error_type);

package/lib/plugins_core/deploy/index.d.ts

@@ -1,30 +1,3 @@
-export function shouldDeploy({ buildbotServerSocket }: {
-    buildbotServerSocket: any;
-}): boolean;
-export namespace deploySite {
-    export let event: string;
-    export { coreStep };
-    export let coreStepId: string;
-    export let coreStepName: string;
-    export function coreStepDescription(): string;
-    export { shouldDeploy as condition };
-}
-declare function coreStep({ buildDir, configPath, repositoryRoot, packagePath, constants, buildbotServerSocket, events, logs, featureFlags, context, branch, configMutations, headersPath, redirectsPath, debug, saveConfig, }: {
-    buildDir: any;
-    configPath: any;
-    repositoryRoot: any;
-    packagePath: any;
-    constants: any;
-    buildbotServerSocket: any;
-    events: any;
-    logs: any;
-    featureFlags: any;
-    context: any;
-    branch: any;
-    configMutations: any;
-    headersPath: any;
-    redirectsPath: any;
-    debug: any;
-    saveConfig: any;
-}): Promise<{}>;
-export {};
+import type { CoreStep, CoreStepCondition } from '../types.js';
+export declare const shouldDeploy: CoreStepCondition;
+export declare const deploySite: CoreStep;

package/lib/plugins_core/deploy/index.js

@@ -1,7 +1,8 @@
+// eslint-disable-next-line n/no-missing-import
 import { saveUpdatedConfig, restoreUpdatedConfig } from '../../core/config.js';
 import { logDeploySuccess } from '../../log/messages/plugins.js';
 import { createBuildbotClient, connectBuildbotClient, closeBuildbotClient, deploySiteWithBuildbotClient, } from './buildbot_client.js';
-const coreStep = async function ({ buildDir, configPath, repositoryRoot, packagePath, constants, buildbotServerSocket, events, logs, featureFlags, context, branch, configMutations, headersPath, redirectsPath, debug, saveConfig, }) {
+const coreStep = async function ({ buildDir, configPath, deployEnvVars, repositoryRoot, constants, buildbotServerSocket, events, logs, featureFlags, context, branch, configMutations, headersPath, redirectsPath, debug, saveConfig, }) {
     const client = createBuildbotClient(buildbotServerSocket);
     try {
         // buildbot will emit logs. Flush the output to preserve the right order.
@@ -10,7 +11,6 @@ const coreStep = async function ({ buildDir, configPath, repositoryRoot, package
         await saveUpdatedConfig({
             configMutations,
             buildDir,
-            packagePath,
             repositoryRoot,
             configPath,
             headersPath,
@@ -22,7 +22,14 @@ const coreStep = async function ({ buildDir, configPath, repositoryRoot, package
             debug,
             saveConfig,
         });
-        await deploySiteWithBuildbotClient({ client, events, buildDir, repositoryRoot, constants });
+        await deploySiteWithBuildbotClient({
+            client,
+            environment: deployEnvVars,
+            events,
+            buildDir,
+            repositoryRoot,
+            constants,
+        });
         await restoreUpdatedConfig({
             configMutations,
             buildDir,

package/lib/plugins_core/pre_cleanup/index.js

@@ -3,9 +3,9 @@ import { resolve } from 'node:path';
 import { getBlobsDirs } from '../../utils/blobs.js';
 import { FRAMEWORKS_API_PATH } from '../../utils/frameworks_api.js';
 const coreStep = async ({ buildDir, packagePath }) => {
-    const dirs = [...getBlobsDirs(buildDir, packagePath), resolve(buildDir, packagePath || '', FRAMEWORKS_API_PATH)];
+    const paths = [...getBlobsDirs(buildDir, packagePath), resolve(buildDir, packagePath || '', FRAMEWORKS_API_PATH)];
     try {
-        await Promise.all(dirs.map((dir) => rm(dir, { recursive: true, force: true })));
+        await Promise.all(paths.map((dir) => rm(dir, { recursive: true, force: true })));
     }
     catch {
         // Ignore errors if it fails, we can continue anyway.

package/lib/plugins_core/save_artifacts/index.js

@@ -1,4 +1,5 @@
 import { saveUpdatedConfig } from '../../core/config.js';
+// eslint-disable-next-line n/no-missing-import
 import { shouldDeploy } from '../deploy/index.js';
 const coreStep = async function ({ buildDir, configPath, packagePath, outputConfigPath, repositoryRoot, logs, featureFlags, context, branch, configMutations, headersPath, redirectsPath, debug, saveConfig, }) {
     await saveUpdatedConfig({

package/lib/plugins_core/types.d.ts

@@ -14,6 +14,7 @@ export type CoreStepFunctionArgs = {
      * `undefined` if none is set.
      */
     packagePath?: string;
+    repositoryRoot: string;
     deployId: string;
     /**
      * The deploy context (e.g. 'production', 'deploy-preview', 'branch-deploy')
@@ -27,14 +28,24 @@ export type CoreStepFunctionArgs = {
     constants: NetlifyPluginConstants;
     quiet?: boolean;
     debug?: boolean;
+    events: string[];
     logs?: BufferedLogs;
     systemLog: SystemLogger;
     edgeFunctionsBootstrapURL?: string;
     featureFlags?: Record<string, any>;
+    headersPath?: string;
+    redirectsPath?: string;
+    configMutations: unknown[];
+    configPath: string;
     netlifyConfig: NetlifyConfig;
     explicitSecretKeys: $TSFixme;
     enhancedSecretScan: boolean;
-    buildbotServerSocket: $TSFixme;
+    deployEnvVars: {
+        key: string;
+        value: string;
+        isSecret: boolean;
+    }[];
+    buildbotServerSocket?: string;
     api: DynamicMethods;
 };
 export type CoreStepFunction = (args: CoreStepFunctionArgs) => Promise<object>;

package/lib/steps/core_step.d.ts

@@ -1,4 +1,5 @@
-export declare const fireCoreStep: ({ coreStep, coreStepId, coreStepName, configPath, outputConfigPath, buildDir, repositoryRoot, packagePath, constants, buildbotServerSocket, events, logs, quiet, nodePath, childEnv, context, branch, envChanges, errorParams, configOpts, netlifyConfig, defaultConfig, configMutations, headersPath, redirectsPath, featureFlags, debug, systemLog, saveConfig, userNodeVersion, explicitSecretKeys, enhancedSecretScan, edgeFunctionsBootstrapURL, deployId, outputFlusher, api, returnValues, }: {
+export declare const fireCoreStep: ({ deployEnvVars, coreStep, coreStepId, coreStepName, configPath, outputConfigPath, buildDir, repositoryRoot, packagePath, constants, buildbotServerSocket, events, logs, quiet, nodePath, childEnv, context, branch, envChanges, errorParams, configOpts, netlifyConfig, defaultConfig, configMutations, headersPath, redirectsPath, featureFlags, debug, systemLog, saveConfig, userNodeVersion, explicitSecretKeys, enhancedSecretScan, edgeFunctionsBootstrapURL, deployId, outputFlusher, api, returnValues, }: {
+    deployEnvVars: any;
     coreStep: any;
     coreStepId: any;
     coreStepName: any;

package/lib/steps/core_step.js

@@ -3,12 +3,13 @@ import { addErrorInfo, isBuildError } from '../error/info.js';
 import { addOutputFlusher } from '../log/logger.js';
 import { updateNetlifyConfig, listConfigSideFiles } from './update_config.js';
 // Fire a core step
-export const fireCoreStep = async function ({ coreStep, coreStepId, coreStepName, configPath, outputConfigPath, buildDir, repositoryRoot, packagePath, constants, buildbotServerSocket, events, logs, quiet, nodePath, childEnv, context, branch, envChanges, errorParams, configOpts, netlifyConfig, defaultConfig, configMutations, headersPath, redirectsPath, featureFlags, debug, systemLog, saveConfig, userNodeVersion, explicitSecretKeys, enhancedSecretScan, edgeFunctionsBootstrapURL, deployId, outputFlusher, api, returnValues, }) {
+export const fireCoreStep = async function ({ deployEnvVars, coreStep, coreStepId, coreStepName, configPath, outputConfigPath, buildDir, repositoryRoot, packagePath, constants, buildbotServerSocket, events, logs, quiet, nodePath, childEnv, context, branch, envChanges, errorParams, configOpts, netlifyConfig, defaultConfig, configMutations, headersPath, redirectsPath, featureFlags, debug, systemLog, saveConfig, userNodeVersion, explicitSecretKeys, enhancedSecretScan, edgeFunctionsBootstrapURL, deployId, outputFlusher, api, returnValues, }) {
     const logsA = outputFlusher ? addOutputFlusher(logs, outputFlusher) : logs;
     try {
         const configSideFiles = await listConfigSideFiles([headersPath, redirectsPath]);
         const childEnvA = setEnvChanges(envChanges, { ...childEnv });
         const { newEnvChanges = {}, configMutations: newConfigMutations = [], tags, metrics, } = await coreStep({
+            deployEnvVars,
             api,
             configPath,
             outputConfigPath,

package/lib/steps/get.d.ts

@@ -3,7 +3,7 @@ export declare const getSteps: (steps: any, eventHandlers?: any[]) => {
     steps: CoreStep[];
     events: unknown[];
 };
-export declare const getDevSteps: (command: any, steps: any, eventHandlers?: any[]) => {
+export declare const getDevSteps: (command: any, steps: any, eventHandlers: any[]) => {
     steps: CoreStep[];
     events: unknown[];
 };

package/lib/steps/get.js

@@ -22,13 +22,12 @@ export const getSteps = function (steps, eventHandlers) {
     const events = getEvents(stepsB);
     return { steps: stepsC, events };
 };
-// Get all dev steps
 export const getDevSteps = function (command, steps, eventHandlers) {
     const devCommandStep = {
         event: 'onDev',
         coreStep: async (args) => {
             const { constants, event } = args;
-            const utils = getUtils({ event, constants, runState: {} });
+            const utils = getUtils({ event, constants, runState: {}, deployEnvVars: args.deployEnvVars });
             await command({ utils, ...args });
             return {};
         },
@@ -53,7 +52,7 @@ const getEventSteps = function (eventHandlers) {
             event: event,
             coreStep: (args) => {
                 const { constants, event } = args;
-                const utils = getUtils({ event, constants, runState: {} });
+                const utils = getUtils({ event, constants, runState: {}, deployEnvVars: args.deployEnvVars });
                 return handler({ utils, ...args });
             },
             coreStepId: `options_${event}`,

package/lib/steps/plugin.d.ts

@@ -26,6 +26,7 @@ export function firePluginStep({ event, childProcess, packageName, packagePath,
     verbose: any;
     extensionMetadata: any;
 }): Promise<{
+    deployEnvVars: any;
     newEnvChanges: any;
     netlifyConfig: any;
     configMutations: any;
@@ -36,6 +37,7 @@ export function firePluginStep({ event, childProcess, packageName, packagePath,
     newError?: undefined;
 } | {
     newError: any;
+    deployEnvVars?: undefined;
     newEnvChanges?: undefined;
     netlifyConfig?: undefined;
     configMutations?: undefined;

package/lib/steps/plugin.js

@@ -18,7 +18,7 @@ export const firePluginStep = async function ({ event, childProcess, packageName
     const logsA = outputFlusher ? addOutputFlusher(logs, outputFlusher) : logs;
     try {
         const configSideFiles = await listConfigSideFiles([headersPath, redirectsPath]);
-        const { newEnvChanges, configMutations: newConfigMutations, returnValue, status, } = await callChild({
+        const { configMutations: newConfigMutations, deployEnvVars, newEnvChanges, returnValue, status, } = await callChild({
             childProcess,
             eventName: 'run',
             payload: {
@@ -52,6 +52,7 @@ export const firePluginStep = async function ({ event, childProcess, packageName
         });
         const newStatus = getSuccessStatus(status, { steps, event, packageName });
         return {
+            deployEnvVars,
             newEnvChanges,
             netlifyConfig: netlifyConfigA,
             configMutations: configMutationsA,

package/lib/steps/return.d.ts

@@ -1,4 +1,5 @@
-export function getStepReturn({ event, packageName, newError, newEnvChanges, newStatus, coreStep, coreStepName: timerName, childEnv, mode, api, errorMonitor, deployId, netlifyConfig, configMutations, headersPath, redirectsPath, logs, outputFlusher, debug, timers, durationNs, testOpts, systemLog, quiet, metrics, returnValue, }: {
+export function getStepReturn({ deployEnvVars, event, packageName, newError, newEnvChanges, newStatus, coreStep, coreStepName: timerName, childEnv, mode, api, errorMonitor, deployId, netlifyConfig, configMutations, headersPath, redirectsPath, logs, outputFlusher, debug, timers, durationNs, testOpts, systemLog, quiet, metrics, returnValue, }: {
+    deployEnvVars: any;
     event: any;
     packageName: any;
     newError: any;
@@ -46,6 +47,7 @@ export function getStepReturn({ event, packageName, newError, newEnvChanges, new
 }> | {
     newError: any;
 } | {
+    deployEnvVars: any;
     newEnvChanges: any;
     netlifyConfig: any;
     configMutations: any;

package/lib/steps/return.js

@@ -1,7 +1,7 @@
 import { logTimer } from '../log/messages/core.js';
 import { handleStepError } from './error.js';
 // Retrieve the return value of a step
-export const getStepReturn = function ({ event, packageName, newError, newEnvChanges, newStatus, coreStep, coreStepName: timerName = `${packageName} ${event}`, childEnv, mode, api, errorMonitor, deployId, netlifyConfig, configMutations, headersPath, redirectsPath, logs, outputFlusher, debug, timers, durationNs, testOpts, systemLog, quiet, metrics, returnValue, }) {
+export const getStepReturn = function ({ deployEnvVars, event, packageName, newError, newEnvChanges, newStatus, coreStep, coreStepName: timerName = `${packageName} ${event}`, childEnv, mode, api, errorMonitor, deployId, netlifyConfig, configMutations, headersPath, redirectsPath, logs, outputFlusher, debug, timers, durationNs, testOpts, systemLog, quiet, metrics, returnValue, }) {
     if (newError !== undefined) {
         return handleStepError({
             event,
@@ -22,6 +22,7 @@ export const getStepReturn = function ({ event, packageName, newError, newEnvCha
         logTimer(logs, durationNs, timerName, systemLog, outputFlusher);
     }
     return {
+        deployEnvVars,
         newEnvChanges,
         netlifyConfig,
         configMutations,

package/lib/steps/run_core_steps.js

@@ -108,7 +108,7 @@ const executeBuildStep = async function ({ config, packagePath, defaultConfig, c
     }
 };
 const runBuildStep = async function ({ defaultConfig, netlifyConfig, buildDir, nodePath, constants, logs, debug, featureFlags, packagePath, childEnv, buildSteps, repositoryRoot, systemLog, edgeFunctionsBootstrapURL, deployId, quiet, }) {
-    const { netlifyConfig: netlifyConfigA, configMutations } = await runSteps({
+    const { netlifyConfig: netlifyConfigA, configMutations, deployEnvVars, } = await runSteps({
         steps: getBuildSteps(buildSteps),
         buildDir,
         nodePath,
@@ -127,5 +127,5 @@ const runBuildStep = async function ({ defaultConfig, netlifyConfig, buildDir, n
         deployId,
         quiet,
     });
-    return { netlifyConfig: netlifyConfigA, configMutations };
+    return { deployEnvVars, netlifyConfig: netlifyConfigA, configMutations };
 };

package/lib/steps/run_step.d.ts

@@ -1,4 +1,5 @@
-export declare const runStep: ({ event, childProcess, packageName, coreStep, coreStepId, coreStepName, coreStepDescription, coreStepQuiet, pluginPackageJson, loadedFrom, origin, condition, configPath, outputConfigPath, buildDir, packagePath, repositoryRoot, nodePath, index, childEnv, context, branch, envChanges, constants, steps, buildbotServerSocket, events, mode, api, errorMonitor, deployId, errorParams, error, failedPlugins, configOpts, netlifyConfig, defaultConfig, configMutations, headersPath, redirectsPath, logs, debug, systemLog, verbose, saveConfig, timers, testOpts, featureFlags, quiet, userNodeVersion, explicitSecretKeys, enhancedSecretScan, edgeFunctionsBootstrapURL, extensionMetadata, returnValues, }: {
+export declare const runStep: ({ deployEnvVars, event, childProcess, packageName, coreStep, coreStepId, coreStepName, coreStepDescription, coreStepQuiet, pluginPackageJson, loadedFrom, origin, condition, configPath, outputConfigPath, buildDir, packagePath, repositoryRoot, nodePath, index, childEnv, context, branch, envChanges, constants, steps, buildbotServerSocket, events, mode, api, errorMonitor, deployId, errorParams, error, failedPlugins, configOpts, netlifyConfig, defaultConfig, configMutations, headersPath, redirectsPath, logs, debug, systemLog, verbose, saveConfig, timers, testOpts, featureFlags, quiet, userNodeVersion, explicitSecretKeys, enhancedSecretScan, edgeFunctionsBootstrapURL, extensionMetadata, returnValues, }: {
+    deployEnvVars: any;
     event: any;
     childProcess: any;
     packageName: any;

package/lib/steps/run_step.js

@@ -11,7 +11,7 @@ import { firePluginStep } from './plugin.js';
 import { getStepReturn } from './return.js';
 const tracer = trace.getTracer('steps');
 // Run a step (core, build command or plugin)
-export const runStep = async function ({ event, childProcess, packageName, coreStep, coreStepId, coreStepName, coreStepDescription, coreStepQuiet, pluginPackageJson, loadedFrom, origin, condition, configPath, outputConfigPath, buildDir, packagePath, repositoryRoot, nodePath, index, childEnv, context, branch, envChanges, constants, steps, buildbotServerSocket, events, mode, api, errorMonitor, deployId, errorParams, error, failedPlugins, configOpts, netlifyConfig, defaultConfig, configMutations, headersPath, redirectsPath, logs, debug, systemLog, verbose, saveConfig, timers, testOpts, featureFlags, quiet, userNodeVersion, explicitSecretKeys, enhancedSecretScan, edgeFunctionsBootstrapURL, extensionMetadata, returnValues, }) {
+export const runStep = async function ({ deployEnvVars, event, childProcess, packageName, coreStep, coreStepId, coreStepName, coreStepDescription, coreStepQuiet, pluginPackageJson, loadedFrom, origin, condition, configPath, outputConfigPath, buildDir, packagePath, repositoryRoot, nodePath, index, childEnv, context, branch, envChanges, constants, steps, buildbotServerSocket, events, mode, api, errorMonitor, deployId, errorParams, error, failedPlugins, configOpts, netlifyConfig, defaultConfig, configMutations, headersPath, redirectsPath, logs, debug, systemLog, verbose, saveConfig, timers, testOpts, featureFlags, quiet, userNodeVersion, explicitSecretKeys, enhancedSecretScan, edgeFunctionsBootstrapURL, extensionMetadata, returnValues, }) {
     // Add relevant attributes to the upcoming span context
     const attributes = {
         'build.execution.step.name': coreStepName,
@@ -62,7 +62,7 @@ export const runStep = async function ({ event, childProcess, packageName, coreS
             };
         const outputFlusher = new OutputFlusher(logPluginStart);
         const fireStep = getFireStep(packageName, coreStepId, event);
-        const { newEnvChanges, netlifyConfig: netlifyConfigA = netlifyConfig, configMutations: configMutationsA = configMutations, headersPath: headersPathA = headersPath, redirectsPath: redirectsPathA = redirectsPath, newError, newStatus, timers: timersA, durationNs, metrics, returnValue, } = await fireStep({
+        const { deployEnvVars: newDeployEnvVars, newEnvChanges, netlifyConfig: netlifyConfigA = netlifyConfig, configMutations: configMutationsA = configMutations, headersPath: headersPathA = headersPath, redirectsPath: redirectsPathA = redirectsPath, newError, newStatus, timers: timersA, durationNs, metrics, returnValue, } = await fireStep({
             extensionMetadata,
             defaultConfig,
             event,
@@ -111,8 +111,10 @@ export const runStep = async function ({ event, childProcess, packageName, coreS
             deployId,
             api,
             returnValues,
+            deployEnvVars,
         });
         const newValues = await getStepReturn({
+            deployEnvVars: newDeployEnvVars,
             event,
             packageName,
             newError,
@@ -206,9 +208,10 @@ const getFireStep = function (packageName, coreStepId, event) {
     const parentTag = normalizeTagName(packageName);
     return measureDuration(tFireStep, event, { parentTag, category: 'pluginEvent' });
 };
-const tFireStep = function ({ defaultConfig, event, childProcess, packageName, pluginPackageJson, loadedFrom, outputFlusher, origin, coreStep, coreStepId, coreStepName, configPath, outputConfigPath, buildDir, repositoryRoot, packagePath, nodePath, childEnv, context, branch, envChanges, constants, steps, buildbotServerSocket, events, error, logs, debug, quiet, systemLog, verbose, saveConfig, errorParams, configOpts, netlifyConfig, configMutations, headersPath, redirectsPath, featureFlags, userNodeVersion, explicitSecretKeys, enhancedSecretScan, edgeFunctionsBootstrapURL, deployId, extensionMetadata, api, returnValues, }) {
+const tFireStep = function ({ deployEnvVars, defaultConfig, event, childProcess, packageName, pluginPackageJson, loadedFrom, outputFlusher, origin, coreStep, coreStepId, coreStepName, configPath, outputConfigPath, buildDir, repositoryRoot, packagePath, nodePath, childEnv, context, branch, envChanges, constants, steps, buildbotServerSocket, events, error, logs, debug, quiet, systemLog, verbose, saveConfig, errorParams, configOpts, netlifyConfig, configMutations, headersPath, redirectsPath, featureFlags, userNodeVersion, explicitSecretKeys, enhancedSecretScan, edgeFunctionsBootstrapURL, deployId, extensionMetadata, api, returnValues, }) {
     if (coreStep !== undefined) {
         return fireCoreStep({
+            deployEnvVars,
             coreStep,
             coreStepId,
             coreStepName,

package/lib/steps/run_steps.d.ts

@@ -44,4 +44,5 @@ export function runSteps({ defaultConfig, steps, buildbotServerSocket, events, c
     configMutations: never[];
     metrics: never[];
     returnValues: {};
+    deployEnvVars: never[];
 }>;

package/lib/steps/run_steps.js

@@ -8,8 +8,9 @@ import { runStep } from './run_step.js';
 // If an error arises, runs `onError` events.
 // Runs `onEnd` events at the end, whether an error was thrown or not.
 export const runSteps = async function ({ defaultConfig, steps, buildbotServerSocket, events, configPath, outputConfigPath, headersPath, redirectsPath, buildDir, packagePath, repositoryRoot, nodePath, childEnv, context, branch, constants, mode, api, errorMonitor, deployId, errorParams, netlifyConfig, configOpts, logs, debug, systemLog, verbose, saveConfig, timers, testOpts, featureFlags, quiet, userNodeVersion, explicitSecretKeys, enhancedSecretScan, edgeFunctionsBootstrapURL, }) {
-    const { index: stepsCount, error: errorA, netlifyConfig: netlifyConfigC, statuses: statusesB, failedPlugins: failedPluginsA, timers: timersC, configMutations: configMutationsB, metrics: metricsC, returnValues, } = await pReduce(steps, async ({ index, error, failedPlugins, envChanges, netlifyConfig: netlifyConfigA, configMutations, headersPath: headersPathA, redirectsPath: redirectsPathA, statuses, timers: timersA, metrics: metricsA, returnValues, }, { event, childProcess, packageName, extensionMetadata, coreStep, coreStepId, coreStepName, coreStepDescription, pluginPackageJson, loadedFrom, origin, condition, quiet: coreStepQuiet, }) => {
-        const { newIndex = index, newError = error, failedPlugin = [], newEnvChanges = {}, netlifyConfig: netlifyConfigB = netlifyConfigA, configMutations: configMutationsA = configMutations, headersPath: headersPathB = headersPathA, redirectsPath: redirectsPathB = redirectsPathA, newStatus, timers: timersB = timersA, metrics: metricsB = [], returnValue, } = await runStep({
+    const { index: stepsCount, error: errorA, netlifyConfig: netlifyConfigC, statuses: statusesB, failedPlugins: failedPluginsA, timers: timersC, configMutations: configMutationsB, metrics: metricsC, returnValues, deployEnvVars, } = await pReduce(steps, async ({ deployEnvVars, index, error, failedPlugins, envChanges, netlifyConfig: netlifyConfigA, configMutations, headersPath: headersPathA, redirectsPath: redirectsPathA, statuses, timers: timersA, metrics: metricsA, returnValues, }, { event, childProcess, packageName, extensionMetadata, coreStep, coreStepId, coreStepName, coreStepDescription, pluginPackageJson, loadedFrom, origin, condition, quiet: coreStepQuiet, }) => {
+        const { newIndex = index, newError = error, deployEnvVars: newDeployEnvVars = [], failedPlugin = [], newEnvChanges = {}, netlifyConfig: netlifyConfigB = netlifyConfigA, configMutations: configMutationsA = configMutations, headersPath: headersPathB = headersPathA, redirectsPath: redirectsPathB = redirectsPathA, newStatus, timers: timersB = timersA, metrics: metricsB = [], returnValue, } = await runStep({
+            deployEnvVars,
             event,
             childProcess,
             packageName,
@@ -78,6 +79,7 @@ export const runSteps = async function ({ defaultConfig, steps, buildbotServerSo
         return {
             index: newIndex,
             error: newError,
+            deployEnvVars: Array.from([...deployEnvVars, ...newDeployEnvVars].reduce((acc, env) => acc.set(env.key, env), new Map()).values()),
             failedPlugins: [...failedPlugins, ...failedPlugin],
             envChanges: { ...envChanges, ...newEnvChanges },
             netlifyConfig: netlifyConfigB,
@@ -91,6 +93,7 @@ export const runSteps = async function ({ defaultConfig, steps, buildbotServerSo
         };
     }, {
         index: 0,
+        deployEnvVars: [],
         failedPlugins: [],
         envChanges: {},
         netlifyConfig,
@@ -117,5 +120,6 @@ export const runSteps = async function ({ defaultConfig, steps, buildbotServerSo
         configMutations: configMutationsB,
         metrics: metricsC,
         returnValues,
+        deployEnvVars,
     };
 };

package/lib/types/options/netlify_plugin_deploy_util.d.ts

@@ -0,0 +1,9 @@
+export interface NetlifyPluginDeployUtilEnv {
+    add(key: string, value: string, options?: {
+        isSecret?: boolean;
+        scopes?: ('builds' | 'functions' | 'post_processing' | 'runtime')[];
+    }): this;
+}
+export interface NetlifyPluginDeployUtil {
+    readonly env: NetlifyPluginDeployUtilEnv;
+}

package/lib/types/options/netlify_plugin_deploy_util.js

@@ -0,0 +1 @@
+export {};

package/lib/types/options/netlify_plugin_utils.d.ts

@@ -1,14 +1,16 @@
 import type { NetlifyPluginBuildUtil } from './netlify_plugin_build_util.js';
 import type { NetlifyPluginCacheUtil } from './netlify_plugin_cache_util.js';
+import type { NetlifyPluginDeployUtil } from './netlify_plugin_deploy_util.js';
 import type { NetlifyPluginFunctionsUtil } from './netlify_plugin_functions_util.js';
 import type { NetlifyPluginGitUtil } from './netlify_plugin_git_util.js';
 import type { NetlifyPluginRunUtil } from './netlify_plugin_run_util.js';
 import type { NetlifyPluginStatusUtil } from './netlify_plugin_status_util.js';
 export interface NetlifyPluginUtils {
     build: NetlifyPluginBuildUtil;
-    status: NetlifyPluginStatusUtil;
     cache: NetlifyPluginCacheUtil;
-    run: NetlifyPluginRunUtil;
-    git: NetlifyPluginGitUtil;
+    deploy: NetlifyPluginDeployUtil;
     functions: NetlifyPluginFunctionsUtil;
+    git: NetlifyPluginGitUtil;
+    run: NetlifyPluginRunUtil;
+    status: NetlifyPluginStatusUtil;
 }

package/lib/utils/environment.d.ts

@@ -0,0 +1 @@
+export declare const isReservedEnvironmentVariableKey: (key: string) => boolean;

package/lib/utils/environment.js

@@ -0,0 +1,42 @@
+// This is not the final source of truth about which environment variable keys are reserved and
+// which are not; the Netlify API will ultimately reject illegal environment variables when creating
+// a deploy. We do local validation to let a user or plugin developer know as soon as is possible
+// that an injected environment variable will later fail the build.
+const RESERVED_ENV_VAR_KEYS = new Set([
+    // AWS-specific env vars
+    'AWS_REGION',
+    'AWS_EXECUTION_ENV',
+    'AWS_LAMBDA_FUNCTION_NAME',
+    'AWS_LAMBDA_FUNCTION_MEMORY_SIZE',
+    'AWS_LAMBDA_FUNCTION_VERSION',
+    'AWS_LAMBDA_LOG_GROUP_NAME',
+    'AWS_LAMBDA_LOG_STREAM_NAME',
+    'AWS_ACCESS_KEY_ID',
+    'AWS_SECRET_ACCESS_KEY',
+    'AWS_SESSION_TOKEN',
+    'AWS_LAMBDA_RUNTIME_API',
+    // Build metadata https://docs.netlify.com/configure-builds/environment-variables/#build-metadata
+    'NETLIFY',
+    'BUILD_ID',
+    'CONTEXT',
+    // Git metadata https://docs.netlify.com/configure-builds/environment-variables/#git-metadata
+    'REPOSITORY_URL',
+    'BRANCH',
+    'HEAD',
+    'COMMIT_REF',
+    'CACHED_COMMIT_REF',
+    'PULL_REQUEST',
+    'REVIEW_ID',
+    // Deploy URLs and metadata// https://docs.netlify.com/configure-builds/environment-variables/#deploy-urls-and-metadata
+    'URL',
+    'DEPLOY_URL',
+    'DEPLOY_PRIME_URL',
+    'DEPLOY_ID',
+    'SITE_NAME',
+    'SITE_ID',
+    'NETLIFY_IMAGES_CDN_DOMAIN',
+    'INCOMING_HOOK_TITLE',
+    'INCOMING_HOOK_URL',
+    'INCOMING_HOOK_BODY',
+]);
+export const isReservedEnvironmentVariableKey = (key) => RESERVED_ENV_VAR_KEYS.has(key);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/build",
-  "version": "35.7.1",
+  "version": "35.8.0-1-experimental",
   "description": "Netlify build module",
   "type": "module",
   "exports": "./lib/index.js",
@@ -151,6 +151,5 @@
   },
   "engines": {
     "node": ">=18.14.0"
-  },
-  "gitHead": "3916fb7641d4e6fa8c2bede1e72d35ac8b87d8d8"
+  }
 }