@netlify/build 33.5.1 → 34.0.1

package/lib/core/build.d.ts

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

package/lib/core/build.js

@@ -85,7 +85,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, } = await runAndReportBuild({
+    const { pluginsOptions: pluginsOptionsA, netlifyConfig: netlifyConfigA, stepsCount, timers: timersB, configMutations, metrics, returnValues, } = await runAndReportBuild({
         pluginsOptions,
         netlifyConfig,
         defaultConfig,
@@ -141,13 +141,14 @@ const tExecBuild = async function ({ config, defaultConfig, cachedConfig, cached
         timers: timersB,
         configMutations,
         metrics,
+        returnValues,
     };
 };
 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, } = await initAndRunBuild({
+        const { stepsCount, netlifyConfig: netlifyConfigA, statuses, pluginsOptions: pluginsOptionsA, failedPlugins, timers: timersA, configMutations, metrics, returnValues, } = await initAndRunBuild({
             pluginsOptions,
             netlifyConfig,
             defaultConfig,
@@ -231,6 +232,7 @@ export const runAndReportBuild = async function ({ pluginsOptions, netlifyConfig
             timers: timersA,
             configMutations,
             metrics,
+            returnValues,
         };
     }
     catch (error) {
@@ -303,7 +305,7 @@ const initAndRunBuild = async function ({ pluginsOptions, netlifyConfig, default
         systemLogFile,
     });
     try {
-        const { stepsCount, netlifyConfig: netlifyConfigA, statuses, failedPlugins, timers: timersC, configMutations, metrics, } = await runBuild({
+        const { stepsCount, netlifyConfig: netlifyConfigA, statuses, failedPlugins, timers: timersC, configMutations, metrics, returnValues, } = await runBuild({
             childProcesses,
             pluginsOptions: pluginsOptionsA,
             netlifyConfig,
@@ -359,6 +361,7 @@ const initAndRunBuild = async function ({ pluginsOptions, netlifyConfig, default
             timers: timersC,
             configMutations,
             metrics,
+            returnValues,
         };
     }
     finally {
@@ -396,7 +399,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, } = await runSteps({
+    const { stepsCount, netlifyConfig: netlifyConfigA, statuses, failedPlugins, timers: timersB, configMutations, metrics, returnValues, } = await runSteps({
         steps,
         buildbotServerSocket,
         events,
@@ -442,5 +445,6 @@ const runBuild = async function ({ childProcesses, pluginsOptions, netlifyConfig
         timers: timersB,
         configMutations,
         metrics,
+        returnValues,
     };
 };

package/lib/core/dev.d.ts

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

package/lib/core/dev.js

@@ -1,11 +1,12 @@
 import { handleBuildError } from '../error/handle.js';
+import { getGeneratedFunctions } from '../steps/return_values.js';
 import { execBuild, startBuild } from './build.js';
 import { getSeverity } from './severity.js';
 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 } = await execBuild({
+        const { netlifyConfig: netlifyConfigA, configMutations, returnValues, } = await execBuild({
             ...normalizedFlags,
             errorMonitor,
             errorParams,
@@ -17,7 +18,14 @@ export const startDev = async (devCommand, flags = {}) => {
             devCommand,
         });
         const { success, severityCode } = getSeverity('success');
-        return { success, severityCode, netlifyConfig: netlifyConfigA, logs, configMutations };
+        return {
+            success,
+            severityCode,
+            netlifyConfig: netlifyConfigA,
+            logs,
+            configMutations,
+            generatedFunctions: getGeneratedFunctions(returnValues),
+        };
     }
     catch (error) {
         const { severity, message, stack } = await handleBuildError(error, errorParams);

package/lib/core/main.js

@@ -4,6 +4,7 @@ import { handleBuildError } from '../error/handle.js';
 import { reportError } from '../error/report.js';
 import { getSystemLogger } from '../log/logger.js';
 import { logTimer, logBuildSuccess } from '../log/messages/core.js';
+import { getGeneratedFunctions } from '../steps/return_values.js';
 import { trackBuildComplete } from '../telemetry/main.js';
 import { reportTimers } from '../time/report.js';
 import { execBuild, startBuild } from './build.js';
@@ -32,7 +33,7 @@ export async function buildSite(flags = {}) {
     const rootCtx = context.with(getGlobalContext(), () => setMultiSpanAttributes(attributes));
     return await tracer.startActiveSpan('exec-build', {}, rootCtx, async (span) => {
         try {
-            const { pluginsOptions, netlifyConfig: netlifyConfigA, siteInfo, userNodeVersion, stepsCount, timers, durationNs, configMutations, metrics, } = await execBuild({
+            const { pluginsOptions, netlifyConfig: netlifyConfigA, siteInfo, userNodeVersion, stepsCount, timers, durationNs, configMutations, metrics, returnValues, } = await execBuild({
                 ...flagsA,
                 buildId,
                 systemLogFile,
@@ -77,7 +78,14 @@ export async function buildSite(flags = {}) {
                 testOpts,
                 errorParams,
             });
-            return { success, severityCode, netlifyConfig: netlifyConfigA, logs, configMutations };
+            return {
+                success,
+                severityCode,
+                netlifyConfig: netlifyConfigA,
+                logs,
+                configMutations,
+                generatedFunctions: getGeneratedFunctions(returnValues),
+            };
         }
         catch (error) {
             const { severity } = await handleBuildError(error, errorParams);

package/lib/log/messages/core_steps.js

@@ -50,15 +50,19 @@ export const logFunctionsNonExistingDir = function (logs, relativeFunctionsSrc)
 // Print the list of Netlify Functions about to be bundled
 export const logFunctionsToBundle = function ({ logs, userFunctions, userFunctionsSrc, userFunctionsSrcExists, internalFunctions, internalFunctionsSrc, frameworkFunctions, generatedFunctions, type = 'Functions', }) {
     let needsSpace = false;
-    if (generatedFunctions.length !== 0) {
-        for (const id in generatedFunctions) {
-            const { displayName, generatorType, functionNames } = generatedFunctions[id];
-            if (needsSpace)
-                log(logs, '');
-            log(logs, `Packaging ${type} generated by ${THEME.highlightWords(displayName)} ${generatorType}:`);
-            logArray(logs, functionNames, { indent: false });
-            needsSpace = true;
+    for (const id in generatedFunctions) {
+        if (generatedFunctions[id].length === 0) {
+            continue;
         }
+        // Getting the generator block from the first function, since it will be
+        // the same for all of them.
+        const { generator } = generatedFunctions[id][0];
+        const functionNames = generatedFunctions[id].map((func) => path.basename(func.path));
+        if (needsSpace)
+            log(logs, '');
+        log(logs, `Packaging ${type} generated by ${THEME.highlightWords(generator.displayName)} ${generator.type}:`);
+        logArray(logs, functionNames, { indent: false });
+        needsSpace = true;
     }
     if (internalFunctions.length !== 0) {
         if (needsSpace)

package/lib/plugins_core/edge_functions/index.js

@@ -123,7 +123,7 @@ const logFunctions = async ({ frameworksAPISrcPath, internalSrcDirectory, intern
         internalFunctionsSrc: internalSrcDirectory,
         frameworkFunctions: frameworkFunctions.map(({ name }) => name),
         type: 'Edge Functions',
-        generatedFunctions: [],
+        generatedFunctions: {},
     });
 };
 export const bundleEdgeFunctions = {

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

@@ -49,5 +49,5 @@ export declare const bundleFunctions: {
     }) => Promise<boolean>;
 };
 export declare const zipItAndShipIt: {
-    zipFunctions(relativeSrcFolders: string | string[], destFolder: string, args_2?: import("@netlify/zip-it-and-ship-it").ZipFunctionsOptions | undefined): Promise<FunctionResult[]>;
+    zipFunctions(input: import("packages/zip-it-and-ship-it/dist/zip.js").ZipFunctionsPaths, destFolder: string, args_2?: import("@netlify/zip-it-and-ship-it").ZipFunctionsOptions | undefined): Promise<FunctionResult[]>;
 };

package/lib/plugins_core/functions/index.js

@@ -1,8 +1,9 @@
-import { basename, resolve } from 'path';
+import { resolve } from 'path';
 import { RUNTIME, 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 { FRAMEWORKS_API_FUNCTIONS_ENDPOINT } from '../../utils/frameworks_api.js';
 import { getZipError } from './error.js';
@@ -63,8 +64,15 @@ const zipFunctionsAndLogResults = async ({ branch, buildDir, childEnv, featureFl
     try {
         // Printing an empty line before bundling output.
         log(logs, '');
-        const sourceDirectories = [internalFunctionsSrc, frameworkFunctionsSrc, functionsSrc, ...generatedFunctions].filter(Boolean);
-        const results = await zipItAndShipIt.zipFunctions(sourceDirectories, functionsDist, zisiParameters);
+        const results = await zipItAndShipIt.zipFunctions({
+            generated: {
+                directories: [internalFunctionsSrc, frameworkFunctionsSrc].filter(Boolean),
+                functions: generatedFunctions,
+            },
+            user: {
+                directories: [functionsSrc].filter(Boolean),
+            },
+        }, functionsDist, zisiParameters);
         validateCustomRoutes(results);
         const bundlers = Array.from(getBundlers(results));
         logBundleResults({ logs, results });
@@ -98,7 +106,7 @@ const coreStep = async function ({ childEnv, constants: { INTERNAL_FUNCTIONS_SRC
             log(logs, '');
         }
     }
-    const generatedFunctions = getGeneratedFunctionPaths(returnValues);
+    const generatedFunctions = getGeneratedFunctions(returnValues);
     logFunctionsToBundle({
         logs,
         userFunctions,
@@ -107,7 +115,7 @@ const coreStep = async function ({ childEnv, constants: { INTERNAL_FUNCTIONS_SRC
         internalFunctions,
         internalFunctionsSrc: relativeInternalFunctionsSrc,
         frameworkFunctions,
-        generatedFunctions: getGeneratedFunctionsByGenerator(returnValues),
+        generatedFunctions: getGeneratedFunctionsByGenerator(generatedFunctions),
     });
     if (userFunctions.length === 0 &&
         internalFunctions.length === 0 &&
@@ -130,7 +138,7 @@ const coreStep = async function ({ childEnv, constants: { INTERNAL_FUNCTIONS_SRC
         repositoryRoot,
         userNodeVersion,
         systemLog,
-        generatedFunctions,
+        generatedFunctions: generatedFunctions.map((func) => func.path),
     });
     const metrics = getMetrics(internalFunctions, userFunctions);
     return {
@@ -166,25 +174,14 @@ const hasFunctionsDirectories = async function ({ buildDir, constants: { INTERNA
     }
     return false;
 };
-// Takes a list of return values and produces an array with the paths of all
-// generated functions.
-const getGeneratedFunctionPaths = (returnValues) => {
-    return Object.values(returnValues).flatMap((returnValue) => returnValue.generatedFunctions?.map((func) => func.path) || []);
-};
 // Takes a list of return values and produces an object with the names of the
 // generated functions for each generator. This is used for printing logs only.
-const getGeneratedFunctionsByGenerator = (returnValues) => {
+const getGeneratedFunctionsByGenerator = (generatedFunctions) => {
     const result = {};
-    for (const id in returnValues) {
-        const { displayName, generatedFunctions, generatorType } = returnValues[id];
-        if (!generatedFunctions || generatedFunctions.length === 0) {
-            continue;
-        }
-        result[id] = {
-            displayName,
-            generatorType,
-            functionNames: generatedFunctions.map((func) => basename(func.path)),
-        };
+    for (const func of generatedFunctions) {
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        result[func.generator.name] = result[func.generator.name] || [];
+        result[func.generator.name].push(func);
     }
     return result;
 };

package/lib/plugins_core/functions/zisi.js

@@ -36,7 +36,6 @@ export const getZisiParameters = ({ branch, buildDir, childEnv, featureFlags, fu
         featureFlags: zisiFeatureFlags,
         repositoryRoot,
         configFileDirectories,
-        internalSrcFolder: internalFunctionsSrc,
         systemLog,
     };
 };

package/lib/plugins_core/secrets_scanning/index.js

@@ -12,7 +12,6 @@ const coreStep = async function ({ buildDir, logs, netlifyConfig, explicitSecret
     // When the flag is disabled, we may still run the scan if a secrets scan would otherwise take place anyway
     // In this case, we hide any output to the user and simply gather the information in our logs
     const enhancedScanShouldRunInActiveMode = featureFlags?.enhanced_secret_scan_impacts_builds ?? false;
-    const useMinimalChunks = featureFlags?.secret_scanning_minimal_chunks;
     systemLog?.({ passedSecretKeys, buildDir });
     if (!isSecretsScanningEnabled(envVars)) {
         logSecretsScanSkipMessage(logs, 'Secrets scanning disabled via SECRETS_SCAN_ENABLED flag set to false.');
@@ -63,7 +62,6 @@ const coreStep = async function ({ buildDir, logs, netlifyConfig, explicitSecret
             filePaths,
             enhancedScanning: enhancedScanShouldRun,
             omitValuesFromEnhancedScan: getOmitValuesFromEnhancedScanForEnhancedScanFromEnv(envVars),
-            useMinimalChunks,
         });
         secretMatches = scanResults.matches.filter((match) => !match.enhancedMatch);
         enhancedSecretMatches = scanResults.matches.filter((match) => match.enhancedMatch);

package/lib/plugins_core/secrets_scanning/utils.d.ts

@@ -9,7 +9,6 @@ interface ScanArgs {
     filePaths: string[];
     enhancedScanning?: boolean;
     omitValuesFromEnhancedScan?: unknown[];
-    useMinimalChunks: boolean;
 }
 interface MatchResult {
     lineNumber: number;
@@ -98,7 +97,7 @@ export declare function getFilePathsToScan({ env, base }: {
  * @param scanArgs {ScanArgs} scan options
  * @returns promise with all of the scan results, if any
  */
-export declare function scanFilesForKeyValues({ env, keys, filePaths, base, enhancedScanning, omitValuesFromEnhancedScan, useMinimalChunks, }: ScanArgs): Promise<ScanResults>;
+export declare function scanFilesForKeyValues({ env, keys, filePaths, base, enhancedScanning, omitValuesFromEnhancedScan, }: ScanArgs): Promise<ScanResults>;
 /**
  * ScanResults are all of the finds for all keys and their disparate locations. Scanning is
  * async in streams so order can change a lot. Some matches are the result of an env var explictly being marked as secret,

package/lib/plugins_core/secrets_scanning/utils.js

@@ -1,6 +1,5 @@
 import { createReadStream, promises as fs, existsSync } from 'node:fs';
 import path from 'node:path';
-import { createInterface } from 'node:readline';
 import { fdir } from 'fdir';
 import { minimatch } from 'minimatch';
 import { LIKELY_SECRET_PREFIXES, SAFE_LISTED_VALUES } from './secret_prefixes.js';
@@ -221,7 +220,7 @@ const omitPathMatches = (relativePath, omitPaths) => {
  * @param scanArgs {ScanArgs} scan options
  * @returns promise with all of the scan results, if any
  */
-export async function scanFilesForKeyValues({ env, keys, filePaths, base, enhancedScanning, omitValuesFromEnhancedScan = [], useMinimalChunks = false, }) {
+export async function scanFilesForKeyValues({ env, keys, filePaths, base, enhancedScanning, omitValuesFromEnhancedScan = [], }) {
     const scanResults = {
         matches: [],
         scannedFilesCount: 0,
@@ -242,14 +241,19 @@ export async function scanFilesForKeyValues({ env, keys, filePaths, base, enhanc
     }, {});
     scanResults.scannedFilesCount = filePaths.length;
     let settledPromises = [];
-    const searchStream = useMinimalChunks ? searchStreamMinimalChunks : searchStreamReadline;
     // process the scanning in batches to not run into memory issues by
     // processing all files at the same time.
     while (filePaths.length > 0) {
         const chunkSize = 200;
         const batch = filePaths.splice(0, chunkSize);
         settledPromises = settledPromises.concat(await Promise.allSettled(batch.map((file) => {
-            return searchStream({ basePath: base, file, keyValues, enhancedScanning, omitValuesFromEnhancedScan });
+            return searchStreamMinimalChunks({
+                basePath: base,
+                file,
+                keyValues,
+                enhancedScanning,
+                omitValuesFromEnhancedScan,
+            });
         })));
     }
     settledPromises.forEach((result) => {
@@ -259,125 +263,6 @@ export async function scanFilesForKeyValues({ env, keys, filePaths, base, enhanc
     });
     return scanResults;
 }
-/**
- * Search stream implementation using node:readline
- */
-const searchStreamReadline = ({ basePath, file, keyValues, enhancedScanning, omitValuesFromEnhancedScan = [], }) => {
-    return new Promise((resolve, reject) => {
-        const filePath = path.resolve(basePath, file);
-        const inStream = createReadStream(filePath);
-        const rl = createInterface({ input: inStream, terminal: false });
-        const matches = [];
-        const keyVals = [].concat(...Object.values(keyValues));
-        function getKeyForValue(val) {
-            let key = '';
-            for (const [secretKeyName, valuePermutations] of Object.entries(keyValues)) {
-                if (valuePermutations.includes(val)) {
-                    key = secretKeyName;
-                }
-            }
-            return key;
-        }
-        // how many lines is the largest multiline string
-        let maxMultiLineCount = 1;
-        keyVals.forEach((valVariant) => {
-            maxMultiLineCount = Math.max(maxMultiLineCount, valVariant.split('\n').length);
-        });
-        const lines = [];
-        let lineNumber = 0;
-        rl.on('line', function (line) {
-            // iterating here so the first line will always appear as line 1 to be human friendly
-            // and match what an IDE would show for a line number.
-            lineNumber++;
-            if (typeof line === 'string') {
-                if (enhancedScanning) {
-                    matches.push(...findLikelySecrets({ text: line, omitValuesFromEnhancedScan }).map(({ prefix }) => ({
-                        key: prefix,
-                        file,
-                        lineNumber,
-                        enhancedMatch: true,
-                    })));
-                }
-                if (maxMultiLineCount > 1) {
-                    lines.push(line);
-                }
-                // only track the max number of lines needed to match our largest
-                // multiline value. If we get above that remove the first value from the list
-                if (lines.length > maxMultiLineCount) {
-                    lines.shift();
-                }
-                keyVals.forEach((valVariant) => {
-                    // matching of single/whole values
-                    if (line.includes(valVariant)) {
-                        matches.push({
-                            file,
-                            lineNumber,
-                            key: getKeyForValue(valVariant),
-                            enhancedMatch: false,
-                        });
-                        return;
-                    }
-                    // matching of multiline values
-                    if (isMultiLineVal(valVariant)) {
-                        // drop empty values at beginning and end
-                        const multiStringLines = valVariant.split('\n');
-                        // drop early if we don't have enough lines for all values
-                        if (lines.length < multiStringLines.length) {
-                            return;
-                        }
-                        let stillMatches = true;
-                        let fullMatch = false;
-                        multiStringLines.forEach((valLine, valIndex) => {
-                            if (valIndex === 0) {
-                                // first lines have to end with the line value
-                                if (!lines[valIndex].endsWith(valLine)) {
-                                    stillMatches = false;
-                                }
-                            }
-                            else if (valIndex !== multiStringLines.length - 1) {
-                                // middle lines have to have full line match
-                                // middle lines
-                                if (lines[valIndex] !== valLine) {
-                                    stillMatches = false;
-                                }
-                            }
-                            else {
-                                // last lines have start with the value
-                                if (!lines[valIndex].startsWith(valLine)) {
-                                    stillMatches = false;
-                                }
-                                if (stillMatches === true) {
-                                    fullMatch = true;
-                                }
-                            }
-                        });
-                        if (fullMatch) {
-                            matches.push({
-                                file,
-                                lineNumber: lineNumber - lines.length + 1,
-                                key: getKeyForValue(valVariant),
-                                enhancedMatch: false,
-                            });
-                            return;
-                        }
-                    }
-                });
-            }
-        });
-        rl.on('error', function (error) {
-            if (error?.code === 'EISDIR') {
-                // file path is a directory - do nothing
-                resolve(matches);
-            }
-            else {
-                reject(error);
-            }
-        });
-        rl.on('close', function () {
-            resolve(matches);
-        });
-    });
-};
 /**
  * Search stream implementation using just read stream that allows to buffer less content
  */
@@ -610,6 +495,3 @@ export function groupScanResultsByKeyAndScanType(scanResults) {
     sortMatches(enhancedSecretMatchesByKeys);
     return { secretMatches: secretMatchesByKeys, enhancedSecretMatches: enhancedSecretMatchesByKeys };
 }
-function isMultiLineVal(v) {
-    return typeof v === 'string' && v.includes('\n');
-}

package/lib/steps/return_values.d.ts

@@ -0,0 +1,18 @@
+type GeneratorType = 'build plugin' | 'extension';
+export interface GeneratedFunction {
+    generator: {
+        displayName: string;
+        name: string;
+        type: GeneratorType;
+    };
+    path: string;
+}
+export interface ReturnValue {
+    displayName?: string;
+    generatedFunctions?: {
+        path: string;
+    }[];
+    generatorType: GeneratorType;
+}
+export declare const getGeneratedFunctions: (returnValues?: Record<string, ReturnValue>) => GeneratedFunction[];
+export {};

package/lib/steps/return_values.js

@@ -0,0 +1,13 @@
+export const getGeneratedFunctions = (returnValues) => {
+    return Object.entries(returnValues ?? {}).flatMap(([name, returnValue]) => {
+        const generator = {
+            displayName: returnValue.displayName ?? name,
+            name,
+            type: returnValue.generatorType,
+        };
+        return (returnValue.generatedFunctions?.map((func) => ({
+            generator,
+            path: func.path,
+        })) ?? []);
+    });
+};

package/lib/steps/run_steps.js

@@ -67,7 +67,7 @@ export const runSteps = async function ({ defaultConfig, steps, buildbotServerSo
             edgeFunctionsBootstrapURL,
         });
         const statusesA = addStatus({ newStatus, statuses, event, packageName, pluginPackageJson });
-        /** @type import('../types/step.js').ReturnValue */
+        /** @type import('../steps/return_values.js').ReturnValue */
         const augmentedReturnValue = returnValue
             ? {
                 ...returnValue,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/build",
-  "version": "33.5.1",
+  "version": "34.0.1",
   "description": "Netlify build module",
   "type": "module",
   "exports": "./lib/index.js",
@@ -67,16 +67,16 @@
   "license": "MIT",
   "dependencies": {
     "@bugsnag/js": "^8.0.0",
-    "@netlify/blobs": "^10.0.2",
+    "@netlify/blobs": "^10.0.4",
     "@netlify/cache-utils": "^6.0.3",
-    "@netlify/config": "^23.0.11",
-    "@netlify/edge-bundler": "14.0.6",
-    "@netlify/functions-utils": "^6.0.13",
+    "@netlify/config": "^23.1.0",
+    "@netlify/edge-bundler": "14.0.7",
+    "@netlify/functions-utils": "^6.0.15",
     "@netlify/git-utils": "^6.0.2",
     "@netlify/opentelemetry-utils": "^2.0.1",
     "@netlify/plugins-list": "^6.80.0",
     "@netlify/run-utils": "^6.0.2",
-    "@netlify/zip-it-and-ship-it": "12.2.1",
+    "@netlify/zip-it-and-ship-it": "13.0.1",
     "@sindresorhus/slugify": "^2.0.0",
     "ansi-escapes": "^7.0.0",
     "chalk": "^5.0.0",
@@ -156,5 +156,5 @@
   "engines": {
     "node": ">=18.14.0"
   },
-  "gitHead": "a317a69700be1392b54976ef34b456ac47d75f5a"
+  "gitHead": "e471abe7b07fb8a34110d06bd8857c89f1d84142"
 }

package/lib/types/step.d.ts

@@ -1,9 +0,0 @@
-interface GeneratedFunction {
-    path: string;
-}
-export interface ReturnValue {
-    displayName: string;
-    generatedFunctions?: GeneratedFunction[];
-    generatorType: 'build plugin' | 'extension';
-}
-export {};

package/lib/types/step.js

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