@netlify/build 35.13.9 → 35.14.0-node22eos

package/lib/log/messages/core_steps.d.ts

@@ -2,6 +2,14 @@ export function logBundleResults({ logs, results }: {
     logs: any;
     results: import("@netlify/zip-it-and-ship-it").FunctionResult[];
 }): void;
+export function trackBundleResults({ results, systemLog }: {
+    results: import("@netlify/zip-it-and-ship-it").FunctionResult[];
+    systemLog: (...args: unknown[]) => void;
+}): {
+    bundlers: import("@netlify/zip-it-and-ship-it").NodeBundlerName[];
+    fallbackCount: number;
+    warningsCount: number;
+};
 export function logFunctionsNonExistingDir(logs: any, relativeFunctionsSrc: any): void;
 export function logFunctionsToBundle({ logs, userFunctions, userFunctionsSrc, userFunctionsSrcExists, internalFunctions, internalFunctionsSrc, frameworkFunctions, generatedFunctions, type, }: {
     logs: any;

package/lib/log/messages/core_steps.js

@@ -1,4 +1,6 @@
 import path from 'path';
+import { RUNTIME } from '@netlify/zip-it-and-ship-it';
+import { trace } from '@opentelemetry/api';
 import { log, logArray, logError, logErrorSubHeader, logWarningSubHeader } from '../logger.js';
 import { THEME } from '../theme.js';
 const logBundleResultFunctions = ({ functions, headerMessage, logs, error }) => {
@@ -12,7 +14,7 @@ const logBundleResultFunctions = ({ functions, headerMessage, logs, error }) =>
     logArray(logs, functionNames);
 };
 /**
- * Logs the result of bundling functions
+ * Logs the result of bundling functions (user facing)
  *
  * @param {object} options
  * @param {any} options.logs
@@ -44,6 +46,58 @@ export const logBundleResults = ({ logs, results = [] }) => {
         logModulesWithDynamicImports({ logs, modulesWithDynamicImports });
     }
 };
+/**
+ * Sibling of `logBundleResults`. Derives structured telemetry from the same
+ * `results` array and emits it to the system log and the active span. Returns
+ * summary stats the caller can use for metric tags.
+ *
+ * @param {object} options
+ * @param {import("@netlify/zip-it-and-ship-it").FunctionResult[]} options.results
+ * @param {(...args: unknown[]) => void} options.systemLog
+ * @returns {{
+ *   bundlers: import("@netlify/zip-it-and-ship-it").NodeBundlerName[],
+ *   fallbackCount: number,
+ *   warningsCount: number,
+ * }}
+ */
+export const trackBundleResults = ({ results = [], systemLog }) => {
+    // `bundlerErrors` is only set when the user requested `esbuild_zisi` (esbuild
+    // with zisi fallback), esbuild failed, and zisi succeeded. The final
+    // `bundler` reflects the fallback, so this is our "silent fallback" signal.
+    const perFunction = results.map((result) => ({
+        name: result.name,
+        runtime: result.runtime,
+        bundler: result.runtime === RUNTIME.JAVASCRIPT ? result.bundler : null,
+        hadFallback: (result.bundlerErrors?.length ?? 0) > 0,
+        hadWarnings: (result.bundlerWarnings?.length ?? 0) > 0,
+    }));
+    // Exclude both `null` (non-JS runtimes) and `undefined` (prebuilt `.zip`
+    // JS functions, which zip-it-and-ship-it passes through with no bundler).
+    const jsResults = perFunction.filter((p) => p.bundler != null);
+    const bundlers = [...new Set(jsResults.map((p) => p.bundler))];
+    const bundlerCounts = jsResults.reduce((acc, p) => ({ ...acc, [p.bundler]: (acc[p.bundler] ?? 0) + 1 }), {});
+    const fallbackCount = perFunction.filter((p) => p.hadFallback).length;
+    const warningsCount = perFunction.filter((p) => p.hadWarnings).length;
+    systemLog({
+        msg: 'Functions bundling completed',
+        bundlers,
+        bundlerCounts,
+        fallbackCount,
+        warningsCount,
+        functions: perFunction,
+    });
+    const span = trace.getActiveSpan();
+    if (span) {
+        span.setAttribute('build.execution.step.bundler', bundlers);
+        span.setAttribute('build.execution.step.functions_count', perFunction.length);
+        span.setAttribute('build.execution.step.bundler.fallback_count', fallbackCount);
+        span.setAttribute('build.execution.step.bundler.warnings_count', warningsCount);
+        for (const [bundler, count] of Object.entries(bundlerCounts)) {
+            span.setAttribute(`build.execution.step.bundler.${bundler}.count`, count);
+        }
+    }
+    return { bundlers, fallbackCount, warningsCount };
+};
 export const logFunctionsNonExistingDir = function (logs, relativeFunctionsSrc) {
     log(logs, `The Netlify Functions setting targets a non-existing directory: ${relativeFunctionsSrc}`);
 };

package/lib/plugins/node_version.d.ts

@@ -15,9 +15,11 @@ export type PluginsOptions = {
  * usually the system's Node.js version.
  * If the user Node version does not satisfy our supported engine range use our own system Node version
  */
-export declare const addPluginsNodeVersion: ({ pluginsOptions, nodePath, userNodeVersion, logs }: {
+export declare const addPluginsNodeVersion: ({ featureFlags, pluginsOptions, nodePath, userNodeVersion, logs, systemLog, }: {
+    featureFlags: any;
     pluginsOptions: any;
     nodePath: any;
     userNodeVersion: any;
     logs: any;
+    systemLog: any;
 }) => Promise<any[]>;

package/lib/plugins/node_version.js

@@ -1,12 +1,15 @@
+import { dirname } from 'path';
 import { execPath, version as currentVersion } from 'process';
 import semver from 'semver';
 import link from 'terminal-link';
 import { logWarning, logWarningSubHeader } from '../log/logger.js';
+import { getPackageJson } from '../utils/package.js';
 /**
  * This node version is minimum required to run the plugins code.
  * If the users preferred Node.js version is below that we have to fall back to the system node version
  */
 const MINIMUM_REQUIRED_NODE_VERSION = '>=18.14.0';
+const UPCOMING_MINIMUM_REQUIRED_NODE_VERSION = '>=22.12.0';
 /**
  * Local plugins and `package.json`-installed plugins use user's preferred Node.js version if higher than our minimum
  * supported version. Else default to the system Node version.
@@ -14,17 +17,19 @@ const MINIMUM_REQUIRED_NODE_VERSION = '>=18.14.0';
  * usually the system's Node.js version.
  * If the user Node version does not satisfy our supported engine range use our own system Node version
  */
-export const addPluginsNodeVersion = function ({ pluginsOptions, nodePath, userNodeVersion, logs }) {
+export const addPluginsNodeVersion = function ({ featureFlags, pluginsOptions, nodePath, userNodeVersion, logs, systemLog, }) {
     const currentNodeVersion = semver.clean(currentVersion);
     return Promise.all(pluginsOptions.map((pluginOptions) => addPluginNodeVersion({
+        featureFlags,
         pluginOptions,
         currentNodeVersion,
         userNodeVersion,
         nodePath,
         logs,
+        systemLog,
     })));
 };
-const addPluginNodeVersion = async function ({ pluginOptions, pluginOptions: { loadedFrom, packageName }, currentNodeVersion, userNodeVersion, nodePath, logs, }) {
+const addPluginNodeVersion = async function ({ featureFlags, pluginOptions, pluginOptions: { loadedFrom, packageName, pluginPath }, currentNodeVersion, userNodeVersion, nodePath, logs, systemLog, }) {
     const systemNode = { ...pluginOptions, nodePath: execPath, nodeVersion: currentNodeVersion };
     const userNode = { ...pluginOptions, nodePath, nodeVersion: userNodeVersion };
     const isLocalPlugin = loadedFrom === 'local' || loadedFrom === 'package.json';
@@ -32,12 +37,50 @@ const addPluginNodeVersion = async function ({ pluginOptions, pluginOptions: { l
     if (isUIOrAutoInstalledPlugin) {
         return systemNode;
     }
+    if (featureFlags.build_warn_upcoming_system_version_change &&
+        !semver.satisfies(userNodeVersion, UPCOMING_MINIMUM_REQUIRED_NODE_VERSION)) {
+        logWarningSubHeader(logs, `Warning: Starting June 16, 2026 plugin "${packageName}" will be executed with Node.js version 22.`);
+        logWarning(logs, `  We're upgrading our system Node.js minimum on that day, which means the plugin cannot be executed with your defined Node.js version ${userNodeVersion}.
+
+  Please make sure your plugin supports being run on Node.js 22.
+
+  Read more about our minimum required version in our ${link('forums announcement', 'https://answers.netlify.com/t/build-plugins-end-of-support-for-node-js-18-node-js-20/162662')}`);
+        if (pluginPath) {
+            const pluginDir = dirname(pluginPath);
+            const { packageJson: pluginPackageJson, packageDir } = await getPackageJson(pluginDir);
+            // `getPackageJson` walks up to the nearest `package.json`. For a `package.json`-installed
+            // plugin that's the plugin's own manifest, but for a local single-file plugin
+            // (e.g. `./plugins/foo.js`) it resolves an ancestor — typically the *site's*
+            // `package.json`, whose `engines.node` describes the site rather than the plugin. Only
+            // trust the resolved range when the manifest belongs to the plugin: an installed package,
+            // or a local plugin shipping its own `package.json` alongside its entry file.
+            const pluginOwnsPackageJson = loadedFrom === 'package.json' || packageDir === pluginDir;
+            const pluginNodeVersionRange = pluginOwnsPackageJson ? pluginPackageJson.engines?.node : undefined;
+            // Ensure Node.js version is compatible with plugin's `engines.node`
+            if (!pluginOwnsPackageJson) {
+                systemLog(`plugin "${packageName}" node support range could not be determined (no own package.json)`);
+            }
+            else if (!pluginNodeVersionRange) {
+                systemLog(`plugin "${packageName}" does not specify node support range`);
+            }
+            else if (semver.satisfies('22.12.0', pluginNodeVersionRange)) {
+                systemLog(`plugin "${packageName}" node support range includes v22`);
+            }
+            else {
+                logWarning(logs, `  In its package.json, the plugin "${packageName}" declares a Node.js version range ("${pluginNodeVersionRange}") that does not include Node.js 22. Please upgrade the plugin so it can be run on Node.js 22.`);
+                systemLog(`plugin "${packageName}" node support range does NOT include v22`);
+            }
+        }
+        else {
+            systemLog(`plugin "${packageName}" pluginPath not available`);
+        }
+    }
     if (semver.satisfies(userNodeVersion, MINIMUM_REQUIRED_NODE_VERSION)) {
         return userNode;
     }
     logWarningSubHeader(logs, `Warning: ${packageName} will be executed with Node.js version ${currentNodeVersion}`);
     logWarning(logs, `  The plugin cannot be executed with your defined Node.js version ${userNodeVersion}
 
-  Read more about our minimum required version in our ${link('forums announcement', 'https://answers.netlify.com/t/build-plugins-end-of-support-for-node-js-14-node-js-16/136405')}`);
+  Read more about our minimum required version in our ${link('forums announcement', 'https://answers.netlify.com/t/build-plugins-end-of-support-for-node-js-18-node-js-20/162662')}`);
     return systemNode;
 };

package/lib/plugins/resolve.js

@@ -15,10 +15,12 @@ export const resolvePluginsPath = async function ({ pluginsOptions, siteInfo, bu
     const autoPluginsDir = getAutoPluginsDir(buildDir, packagePath);
     const pluginsOptionsA = await Promise.all(pluginsOptions.map((pluginOptions) => resolvePluginPath({ pluginOptions, buildDir, packagePath, autoPluginsDir })));
     const pluginsOptionsB = await addPluginsNodeVersion({
+        featureFlags,
         pluginsOptions: pluginsOptionsA,
         nodePath,
         userNodeVersion,
         logs,
+        systemLog,
     });
     const pluginsOptionsC = await addPinnedVersions({ pluginsOptions: pluginsOptionsB, api, siteInfo, sendStatus });
     const pluginsOptionsD = await addExpectedVersions({

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

@@ -1,40 +1,8 @@
 import { zipFunctions, type FunctionResult } from '@netlify/zip-it-and-ship-it';
+import type { CoreStepFunction } from '../types.js';
 export declare const bundleFunctions: {
     event: string;
-    coreStep: ({ childEnv, constants: { INTERNAL_FUNCTIONS_SRC: relativeInternalFunctionsSrc, IS_LOCAL: isRunningLocally, FUNCTIONS_SRC: relativeFunctionsSrc, FUNCTIONS_DIST: relativeFunctionsDist, }, buildDir, branch, packagePath, logs, netlifyConfig, featureFlags, repositoryRoot, userNodeVersion, systemLog, returnValues, }: {
-        childEnv: any;
-        constants: {
-            INTERNAL_FUNCTIONS_SRC: any;
-            IS_LOCAL: any;
-            FUNCTIONS_SRC: any;
-            FUNCTIONS_DIST: any;
-        };
-        buildDir: any;
-        branch: any;
-        packagePath: any;
-        logs: any;
-        netlifyConfig: any;
-        featureFlags: any;
-        repositoryRoot: any;
-        userNodeVersion: any;
-        systemLog: any;
-        returnValues: any;
-    }) => Promise<{
-        tags?: undefined;
-        metrics?: undefined;
-    } | {
-        tags: {
-            bundler: ("zisi" | "nft" | "esbuild" | "none" | "esbuild_zisi")[];
-        };
-        metrics: {
-            type: string;
-            name: string;
-            value: number;
-            tags: {
-                type: string;
-            };
-        }[];
-    }>;
+    coreStep: CoreStepFunction;
     coreStepId: string;
     coreStepName: string;
     coreStepDescription: () => string;

package/lib/plugins_core/functions/index.js

@@ -1,20 +1,14 @@
 import { resolve } from 'path';
-import { RUNTIME, zipFunctions } from '@netlify/zip-it-and-ship-it';
+import { zipFunctions } from '@netlify/zip-it-and-ship-it';
 import { pathExists } from 'path-exists';
 import { addErrorInfo } from '../../error/info.js';
 import { log } from '../../log/logger.js';
 import { getGeneratedFunctions } from '../../steps/return_values.js';
-import { logBundleResults, logFunctionsNonExistingDir, logFunctionsToBundle } from '../../log/messages/core_steps.js';
+import { logBundleResults, logFunctionsNonExistingDir, logFunctionsToBundle, trackBundleResults, } from '../../log/messages/core_steps.js';
 import { FRAMEWORKS_API_FUNCTIONS_PATH } from '../../utils/frameworks_api.js';
 import { getZipError } from './error.js';
 import { getUserAndInternalFunctions, validateFunctionsSrc } from './utils.js';
 import { getZisiParameters } from './zisi.js';
-// Get a list of all unique bundlers in this run
-const getBundlers = (results = []) => 
-// using a Set to filter duplicates
-new Set(results
-    .map((bundle) => (bundle.runtime === RUNTIME.JAVASCRIPT ? bundle.bundler : null))
-    .filter(Boolean));
 // see https://docs.netlify.com/functions/trigger-on-events/#available-triggers
 const eventTriggeredFunctions = new Set([
     'deploy-building',
@@ -74,9 +68,9 @@ const zipFunctionsAndLogResults = async ({ branch, buildDir, childEnv, featureFl
             },
         }, functionsDist, zisiParameters);
         validateCustomRoutes(results);
-        const bundlers = Array.from(getBundlers(results));
         logBundleResults({ logs, results });
-        return { bundlers };
+        const summary = trackBundleResults({ results, systemLog });
+        return summary;
     }
     catch (error) {
         throw await getZipError(error, functionsSrc);
@@ -86,7 +80,7 @@ const zipFunctionsAndLogResults = async ({ branch, buildDir, childEnv, featureFl
 const coreStep = async function ({ childEnv, constants: { INTERNAL_FUNCTIONS_SRC: relativeInternalFunctionsSrc, IS_LOCAL: isRunningLocally, FUNCTIONS_SRC: relativeFunctionsSrc, FUNCTIONS_DIST: relativeFunctionsDist, }, buildDir, branch, packagePath, logs, netlifyConfig, featureFlags, repositoryRoot, userNodeVersion, systemLog, returnValues, }) {
     const functionsSrc = relativeFunctionsSrc === undefined ? undefined : resolve(buildDir, relativeFunctionsSrc);
     const functionsDist = resolve(buildDir, relativeFunctionsDist);
-    const internalFunctionsSrc = resolve(buildDir, relativeInternalFunctionsSrc);
+    const internalFunctionsSrc = resolve(buildDir, relativeInternalFunctionsSrc ?? '');
     const internalFunctionsSrcExists = await pathExists(internalFunctionsSrc);
     const frameworkFunctionsSrc = resolve(buildDir, packagePath || '', FRAMEWORKS_API_FUNCTIONS_PATH);
     const frameworkFunctionsSrcExists = await pathExists(frameworkFunctionsSrc);
@@ -123,7 +117,7 @@ const coreStep = async function ({ childEnv, constants: { INTERNAL_FUNCTIONS_SRC
         generatedFunctions.length === 0) {
         return {};
     }
-    const { bundlers } = await zipFunctionsAndLogResults({
+    const { bundlers, fallbackCount, warningsCount } = await zipFunctionsAndLogResults({
         branch,
         buildDir,
         childEnv,
@@ -140,10 +134,14 @@ const coreStep = async function ({ childEnv, constants: { INTERNAL_FUNCTIONS_SRC
         systemLog,
         generatedFunctions: generatedFunctions.map((func) => func.path),
     });
-    const metrics = getMetrics(internalFunctions, userFunctions);
+    const fallback = fallbackCount > 0 ? 'true' : 'false';
+    const warnings = warningsCount > 0 ? 'true' : 'false';
+    const metrics = getMetrics(internalFunctions, userFunctions, { bundlers, fallback, warnings });
     return {
         tags: {
             bundler: bundlers,
+            fallback,
+            warnings,
         },
         metrics,
     };
@@ -203,19 +201,19 @@ export const zipItAndShipIt = {
         return await zipFunctions(...args);
     },
 };
-const getMetrics = (internalFunctions, userFunctions) => {
+const getMetrics = (internalFunctions, userFunctions, { bundlers, fallback, warnings }) => {
     return [
         {
             type: 'increment',
             name: 'buildbot.build.functions',
             value: internalFunctions.length,
-            tags: { type: 'lambda:generated' },
+            tags: { type: 'lambda:generated', bundler: bundlers, fallback, warnings },
         },
         {
             type: 'increment',
             name: 'buildbot.build.functions',
             value: userFunctions.length,
-            tags: { type: 'lambda:user' },
+            tags: { type: 'lambda:user', bundler: bundlers, fallback, warnings },
         },
     ];
 };

package/lib/plugins_core/types.d.ts

@@ -1,7 +1,8 @@
 import { type DynamicMethods } from 'packages/js-client/lib/types.js';
-import { NetlifyPluginConstants } from '../core/constants.js';
-import { BufferedLogs } from '../log/logger.js';
-import { NetlifyConfig } from '../types/config/netlify_config.js';
+import type { NetlifyPluginConstants } from '../core/constants.js';
+import type { BufferedLogs } from '../log/logger.js';
+import type { NetlifyConfig } from '../types/config/netlify_config.js';
+import type { ReturnValue } from '../steps/return_values.js';
 type $TSFixme = any;
 export type CoreStepFunctionArgs = {
     /**
@@ -46,6 +47,9 @@ export type CoreStepFunctionArgs = {
         isSecret: boolean;
         scopes: string[];
     }[];
+    userNodeVersion?: string;
+    childEnv: $TSFixme;
+    returnValues: Record<string, ReturnValue>;
     buildbotServerSocket?: string;
     api: DynamicMethods;
 };

package/lib/types/config/functions.d.ts

@@ -1,9 +1,25 @@
 type GlobPattern = string;
 type FunctionsObject = {
+    /**
+     * marks the function as a [background function](https://docs.netlify.com/functions/background-functions/), which is invoked asynchronously and can run for up to 15 minutes.
+     */
+    background?: boolean;
     /**
      * a list of additional paths to include in the function bundle. Although our build system includes statically referenced files (like `import * from "./some-file.js"`) by default, `included_files` lets you specify additional files or directories and reference them dynamically in function code. You can use `*` to match any character or prefix an entry with `!` to exclude files. Paths are relative to the [base directory](https://docs.netlify.com/configure-builds/get-started/#definitions-1).
      */
     included_files?: string[];
+    /**
+     * the amount of memory allocated to the function, expressed either as a number of MB or as a string with a unit (e.g. `"2gb"`). Mutually exclusive with `vcpu`.
+     */
+    memory?: number | string;
+    /**
+     * the [region](https://docs.netlify.com/functions/optional-configuration/#region) the function should run in, identified by its airport code (e.g. `"cmh"`).
+     */
+    region?: string;
+    /**
+     * the number of vCPUs allocated to the function (between `0.5` and `2`). Mutually exclusive with `memory`.
+     */
+    vcpu?: number;
 } & ({
     /**
      * the function bundling method used in [`@netlify/zip-it-and-ship-it`](https://github.com/netlify/zip-it-and-ship-it).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/build",
-  "version": "35.13.9",
+  "version": "35.14.0-node22eos",
   "description": "Netlify build module",
   "type": "module",
   "exports": "./lib/index.js",
@@ -151,6 +151,5 @@
   },
   "engines": {
     "node": ">=18.14.0"
-  },
-  "gitHead": "42d439a0a7c6e12f2444ce3feb66b030e8e4be81"
+  }
 }