@netlify/build 29.48.2 → 29.49.1

package/lib/core/build.d.ts

@@ -16,18 +16,18 @@ export declare const startBuild: (flags: Partial<BuildFlags>) => {
     cacheDir: string;
     sendStatus: boolean;
     saveConfig: boolean;
-    apiHost?: string | undefined;
+    apiHost?: string;
     testOpts: import("./types.js").TestOptions;
     statsd: {
         port: number;
     };
-    timeline: string;
+    timeline: "build" | string;
     cachedConfig: Record<string, unknown>;
     siteId: string;
     dry: false;
-    context: string;
+    context: "production" | string;
     statsdOpts: {
-        host?: number | undefined;
+        host?: number;
         port: number;
     };
 };

package/lib/core/build.js

@@ -280,9 +280,10 @@ const initAndRunBuild = async function ({ pluginsOptions, netlifyConfig, configO
         context,
         systemLog,
     });
-    const pluginsEnv = featureFlags.build_inject_blobs_context
-        ? { ...childEnv, ...getBlobsEnvironmentContext({ api, deployId: deployId, siteId: siteInfo?.id, token }) }
-        : childEnv;
+    const pluginsEnv = {
+        ...childEnv,
+        ...getBlobsEnvironmentContext({ api, deployId: deployId, siteId: siteInfo?.id, token }),
+    };
     if (pluginsOptionsA?.length) {
         const buildPlugins = {};
         for (const plugin of pluginsOptionsA) {
@@ -394,7 +395,7 @@ const runBuild = async function ({ childProcesses, pluginsOptions, netlifyConfig
     });
     const { steps, events } = timeline === 'dev' ? getDevSteps(devCommand, pluginsSteps, eventHandlers) : getSteps(pluginsSteps, eventHandlers);
     if (dry) {
-        await doDryRun({ buildDir, steps, netlifyConfig, constants, buildbotServerSocket, logs });
+        await doDryRun({ buildDir, steps, netlifyConfig, constants, buildbotServerSocket, logs, featureFlags });
         return { netlifyConfig };
     }
     const { stepsCount, netlifyConfig: netlifyConfigA, statuses, failedPlugins, timers: timersB, configMutations, metrics, } = await runSteps({

package/lib/core/dry.d.ts

@@ -1,8 +1,9 @@
-export function doDryRun({ buildDir, steps, netlifyConfig, constants, buildbotServerSocket, logs }: {
+export function doDryRun({ buildDir, steps, netlifyConfig, constants, buildbotServerSocket, logs, featureFlags, }: {
     buildDir: any;
     steps: any;
     netlifyConfig: any;
     constants: any;
     buildbotServerSocket: any;
     logs: any;
+    featureFlags: any;
 }): Promise<void>;

package/lib/core/dry.js

@@ -2,22 +2,22 @@ import pFilter from 'p-filter';
 import { logDryRunStart, logDryRunStep, logDryRunEnd } from '../log/messages/dry.js';
 import { runsOnlyOnBuildFailure } from '../plugins/events.js';
 // If the `dry` flag is specified, do a dry run
-export const doDryRun = async function ({ buildDir, steps, netlifyConfig, constants, buildbotServerSocket, logs }) {
-    const successSteps = await pFilter(steps, ({ event, condition }) => shouldIncludeStep({ buildDir, event, condition, netlifyConfig, constants, buildbotServerSocket }));
+export const doDryRun = async function ({ buildDir, steps, netlifyConfig, constants, buildbotServerSocket, logs, featureFlags, }) {
+    const successSteps = await pFilter(steps, ({ event, condition }) => shouldIncludeStep({ buildDir, event, condition, netlifyConfig, constants, buildbotServerSocket, featureFlags }));
     const eventWidth = Math.max(...successSteps.map(getEventLength));
     const stepsCount = successSteps.length;
     logDryRunStart({ logs, eventWidth, stepsCount });
-    successSteps.forEach((step, index) => {
-        if (step.quiet) {
-            return;
-        }
+    successSteps
+        .filter((step) => !step.quiet)
+        .forEach((step, index) => {
         logDryRunStep({ logs, step, index, netlifyConfig, eventWidth, stepsCount });
     });
     logDryRunEnd(logs);
 };
-const shouldIncludeStep = async function ({ buildDir, event, condition, netlifyConfig, constants, buildbotServerSocket, }) {
+const shouldIncludeStep = async function ({ buildDir, event, condition, netlifyConfig, constants, buildbotServerSocket, featureFlags, }) {
     return (!runsOnlyOnBuildFailure(event) &&
-        (condition === undefined || (await condition({ buildDir, constants, netlifyConfig, buildbotServerSocket }))));
+        (condition === undefined ||
+            (await condition({ buildDir, constants, netlifyConfig, buildbotServerSocket, featureFlags }))));
 };
 const getEventLength = function ({ event }) {
     return event.length;

package/lib/core/feature_flags.js

@@ -10,13 +10,10 @@ const getFeatureFlag = function (name) {
 };
 // Default values for feature flags
 export const DEFAULT_FEATURE_FLAGS = {
-    build_inject_blobs_context: false,
     buildbot_zisi_trace_nft: false,
     buildbot_zisi_esbuild_parser: false,
-    buildbot_zisi_system_log: false,
-    edge_functions_cache_cli: false,
-    edge_functions_system_logger: false,
     netlify_build_reduced_output: false,
     netlify_build_updated_plugin_compatibility: false,
+    netlify_build_frameworks_api: false,
     netlify_build_plugin_system_log: false,
 };

package/lib/log/description.d.ts

@@ -1,3 +1,3 @@
 export declare const getBuildCommandDescription: (buildCommandOrigin: any) => any;
 /** Retrieve human-friendly plugin origin */
-export declare const getPluginOrigin: (loadedFrom: 'package.json' | string, origin: string) => string;
+export declare const getPluginOrigin: (loadedFrom: "package.json" | string, origin: string) => string;

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

@@ -3,13 +3,14 @@ export function logBundleResults({ logs, results }: {
     results?: any[] | undefined;
 }): void;
 export function logFunctionsNonExistingDir(logs: any, relativeFunctionsSrc: any): void;
-export function logFunctionsToBundle({ logs, userFunctions, userFunctionsSrc, userFunctionsSrcExists, internalFunctions, internalFunctionsSrc, type, }: {
+export function logFunctionsToBundle({ logs, userFunctions, userFunctionsSrc, userFunctionsSrcExists, internalFunctions, internalFunctionsSrc, frameworkFunctions, type, }: {
     logs: any;
     userFunctions: any;
     userFunctionsSrc: any;
     userFunctionsSrcExists: any;
     internalFunctions: any;
     internalFunctionsSrc: any;
+    frameworkFunctions: any;
     type?: string | undefined;
 }): void;
 export function logSecretsScanSkipMessage(logs: any, msg: any): void;

package/lib/log/messages/core_steps.js

@@ -41,11 +41,18 @@ export const logFunctionsNonExistingDir = function (logs, relativeFunctionsSrc)
     log(logs, `The Netlify Functions setting targets a non-existing directory: ${relativeFunctionsSrc}`);
 };
 // Print the list of Netlify Functions about to be bundled
-export const logFunctionsToBundle = function ({ logs, userFunctions, userFunctionsSrc, userFunctionsSrcExists, internalFunctions, internalFunctionsSrc, type = 'Functions', }) {
+export const logFunctionsToBundle = function ({ logs, userFunctions, userFunctionsSrc, userFunctionsSrcExists, internalFunctions, internalFunctionsSrc, frameworkFunctions, type = 'Functions', }) {
     if (internalFunctions.length !== 0) {
         log(logs, `Packaging ${type} from ${THEME.highlightWords(internalFunctionsSrc)} directory:`);
         logArray(logs, internalFunctions, { indent: false });
     }
+    if (frameworkFunctions.length !== 0) {
+        if (internalFunctions.length !== 0) {
+            log(logs, '');
+        }
+        log(logs, `Packaging ${type} generated by your framework:`);
+        logArray(logs, frameworkFunctions, { indent: false });
+    }
     if (!userFunctionsSrcExists) {
         return;
     }
@@ -53,7 +60,7 @@ export const logFunctionsToBundle = function ({ logs, userFunctions, userFunctio
         log(logs, `No ${type} were found in ${THEME.highlightWords(userFunctionsSrc)} directory`);
         return;
     }
-    if (internalFunctions.length !== 0) {
+    if (internalFunctions.length !== 0 || frameworkFunctions.length !== 0) {
         log(logs, '');
     }
     log(logs, `Packaging ${type} from ${THEME.highlightWords(userFunctionsSrc)} directory:`);

package/lib/log/output_flusher.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 import { Transform } from 'stream';
 import type { StandardStreams } from './stream.js';
 declare const flusherSymbol: unique symbol;

package/lib/log/stream.d.ts

@@ -1,5 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
 import type { ChildProcess } from '../plugins/spawn.js';
 import { Logs } from './logger.js';
 import type { OutputFlusher } from './output_flusher.js';

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

@@ -20,7 +20,7 @@ export function getUtils({ event, constants: { FUNCTIONS_SRC, INTERNAL_FUNCTIONS
         list: (optsA: any) => Promise<string[]>;
         getCacheDir: (optsA: any) => string;
     };
-    run: (file: string, args?: object | string[] | undefined, options?: Record<string, unknown> | undefined) => import("execa").ExecaChildProcess<string>;
+    run: (file: string, args?: string[] | object, options?: Record<string, unknown>) => import("execa").ExecaChildProcess<string>;
     functions: {
         add: (src: any) => Promise<void>;
         list: any;

package/lib/plugins/options.d.ts

@@ -10,9 +10,9 @@ export declare const getSpawnInfo: () => {
         pluginPackageJson: PackageJson;
     };
     location: {
-        event: 'load';
+        event: "load";
         packageName: string;
-        loadedFrom: 'core';
-        origin: 'core';
+        loadedFrom: "core";
+        origin: "core";
     };
 };

package/lib/plugins_core/blobs_upload/index.js

@@ -5,6 +5,7 @@ import semver from 'semver';
 import { DEFAULT_API_HOST } from '../../core/normalize_flags.js';
 import { logError } from '../../log/logger.js';
 import { getFileWithMetadata, getKeysToUpload, scanForBlobs } from '../../utils/blobs.js';
+import { getBlobs } from '../../utils/frameworks_api.js';
 const coreStep = async function ({ logs, deployId, buildDir, packagePath, constants: { SITE_ID, NETLIFY_API_TOKEN, NETLIFY_API_HOST }, systemLog, }) {
     // This should never happen due to the condition check
     if (!deployId || !NETLIFY_API_TOKEN) {
@@ -29,22 +30,23 @@ const coreStep = async function ({ logs, deployId, buildDir, packagePath, consta
         systemLog('No blobs to upload to deploy store.');
         return {};
     }
-    // If using the deploy config API, configure the store to use the region that
-    // was configured for the deploy.
-    if (!blobs.isLegacyDirectory) {
+    // If using the deploy config API or the Frameworks API, configure the store
+    // to use the region that was configured for the deploy. We don't do it for
+    // the legacy file-based upload API since that would be a breaking change.
+    if (blobs.apiVersion > 1) {
         storeOpts.experimentalRegion = 'auto';
     }
     const blobStore = getDeployStore(storeOpts);
-    const keys = await getKeysToUpload(blobs.directory);
-    if (keys.length === 0) {
+    const blobsToUpload = blobs.apiVersion >= 3 ? await getBlobs(blobs.directory) : await getKeysToUpload(blobs.directory);
+    if (blobsToUpload.length === 0) {
         systemLog('No blobs to upload to deploy store.');
         return {};
     }
-    systemLog(`Uploading ${keys.length} blobs to deploy store`);
+    systemLog(`Uploading ${blobsToUpload.length} blobs to deploy store...`);
     try {
-        await pMap(keys, async (key) => {
+        await pMap(blobsToUpload, async ({ key, contentPath, metadataPath }) => {
             systemLog(`Uploading blob ${key}`);
-            const { data, metadata } = await getFileWithMetadata(blobs.directory, key);
+            const { data, metadata } = await getFileWithMetadata(key, contentPath, metadataPath);
             await blobStore.set(key, data, { metadata });
         }, { concurrency: 10 });
     }

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

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 import net from 'net';
 /**
  * Creates the Buildbot IPC client we use to initiate the deploy

package/lib/plugins_core/deploy_config/index.js

@@ -1,33 +1,55 @@
-import { promises as fs } from 'fs';
-import { resolve } from 'path';
 import { mergeConfigs } from '@netlify/config';
 import { getConfigMutations } from '../../plugins/child/diff.js';
-import { filterConfig } from './util.js';
+import { filterConfig, loadConfigFile } from './util.js';
 // The properties that can be set using this API. Each element represents a
 // path using dot-notation — e.g. `["build", "functions"]` represents the
 // `build.functions` property.
-const ALLOWED_PROPERTIES = [['images', 'remote_images']];
+const ALLOWED_PROPERTIES = [
+    ['build', 'functions'],
+    ['build', 'publish'],
+    ['functions', '*'],
+    ['functions', '*', '*'],
+    ['headers'],
+    ['images', 'remote_images'],
+    ['redirects'],
+];
+// For array properties, any values set in this API will be merged with the
+// main configuration file in such a way that user-defined values always take
+// precedence. The exception are these properties that let frameworks set
+// values that should be evaluated before any user-defined values. They use
+// a special notation where `redirects!` represents "forced redirects", etc.
+const OVERRIDE_PROPERTIES = new Set(['redirects!']);
 const coreStep = async function ({ buildDir, netlifyConfig, packagePath, systemLog = () => {
     // no-op
 }, }) {
-    const configPath = resolve(buildDir, packagePath ?? '', '.netlify/deploy/v1/config.json');
-    let config = {};
+    let config;
     try {
-        const data = await fs.readFile(configPath, 'utf8');
-        config = JSON.parse(data);
+        config = await loadConfigFile(buildDir, packagePath);
     }
     catch (err) {
-        // If the file doesn't exist, this is a non-error.
-        if (err.code === 'ENOENT') {
-            return {};
-        }
-        systemLog(`Failed to read Deploy Configuration API: ${err.message}`);
+        systemLog(`Failed to read Frameworks API: ${err.message}`);
         throw new Error('An error occured while processing the platform configurarion defined by your framework');
     }
+    if (!config) {
+        return {};
+    }
+    const configOverrides = {};
+    for (const key in config) {
+        // If the key uses the special notation for defining mutations that should
+        // take precedence over user-defined properties, extract the canonical
+        // property, set it on a different object, and delete it from the main one.
+        if (OVERRIDE_PROPERTIES.has(key)) {
+            const canonicalKey = key.slice(0, -1);
+            configOverrides[canonicalKey] = config[key];
+            delete config[key];
+        }
+    }
     // Filtering out any properties that can't be mutated using this API.
     const filteredConfig = filterConfig(config, [], ALLOWED_PROPERTIES, systemLog);
     // Merging the config extracted from the API with the initial config.
-    const newConfig = mergeConfigs([filteredConfig, netlifyConfig], { concatenateArrays: true });
+    const newConfig = mergeConfigs([filteredConfig, netlifyConfig, configOverrides], {
+        concatenateArrays: true,
+    });
     // Diffing the initial and the new configs to compute the mutations (what
     // changed between them).
     const configMutations = getConfigMutations(netlifyConfig, newConfig, applyDeployConfig.event);
@@ -38,9 +60,8 @@ const coreStep = async function ({ buildDir, netlifyConfig, packagePath, systemL
 export const applyDeployConfig = {
     event: 'onBuild',
     coreStep,
-    coreStepId: 'deploy_config',
-    coreStepName: 'Applying Deploy Configuration',
+    coreStepId: 'frameworks_api_config',
+    coreStepName: 'Applying configuration from Frameworks API',
     coreStepDescription: () => '',
-    condition: ({ featureFlags }) => featureFlags?.netlify_build_deploy_configuration_api,
     quiet: true,
 };

package/lib/plugins_core/deploy_config/util.d.ts

@@ -1,4 +1,6 @@
+import type { NetlifyConfig } from '../../index.js';
 import { SystemLogger } from '../types.js';
+export declare const loadConfigFile: (buildDir: string, packagePath?: string) => Promise<Partial<NetlifyConfig> | undefined>;
 /**
  * Checks whether a property can be defined using the Deploy Configuration API.
  */

package/lib/plugins_core/deploy_config/util.js

@@ -1,5 +1,35 @@
+import { promises as fs } from 'fs';
+import { resolve } from 'path';
 import isPlainObject from 'is-plain-obj';
 import mapObject, { mapObjectSkip } from 'map-obj';
+import { FRAMEWORKS_API_CONFIG_ENDPOINT } from '../../utils/frameworks_api.js';
+export const loadConfigFile = async (buildDir, packagePath) => {
+    const configPath = resolve(buildDir, packagePath ?? '', FRAMEWORKS_API_CONFIG_ENDPOINT);
+    try {
+        const data = await fs.readFile(configPath, 'utf8');
+        return JSON.parse(data);
+    }
+    catch (err) {
+        // If the file doesn't exist, this is a non-error.
+        if (err.code !== 'ENOENT') {
+            throw err;
+        }
+    }
+    // The first version of this API was called "Deploy Configuration API" and it
+    // had `.netlify/deploy` as its base directory. For backwards-compatibility,
+    // we need to support that path for the config file.
+    const legacyConfigPath = resolve(buildDir, packagePath ?? '', '.netlify/deploy/v1/config.json');
+    try {
+        const data = await fs.readFile(legacyConfigPath, 'utf8');
+        return JSON.parse(data);
+    }
+    catch (err) {
+        // If the file doesn't exist, this is a non-error.
+        if (err.code !== 'ENOENT') {
+            throw err;
+        }
+    }
+};
 /**
  * Checks whether a property matches a template that may contain wildcards.
  * Both the property and the template use a dot-notation represented as an

package/lib/plugins_core/dev_blobs_upload/index.js

@@ -4,6 +4,7 @@ import pMap from 'p-map';
 import semver from 'semver';
 import { log, logError } from '../../log/logger.js';
 import { getFileWithMetadata, getKeysToUpload, scanForBlobs } from '../../utils/blobs.js';
+import { getBlobs } from '../../utils/frameworks_api.js';
 const coreStep = async function ({ debug, logs, deployId, buildDir, quiet, packagePath, constants: { SITE_ID, NETLIFY_API_TOKEN, NETLIFY_API_HOST }, }) {
     // This should never happen due to the condition check
     if (!deployId || !NETLIFY_API_TOKEN) {
@@ -30,28 +31,29 @@ const coreStep = async function ({ debug, logs, deployId, buildDir, quiet, packa
         }
         return {};
     }
-    // If using the deploy config API, configure the store to use the region that
-    // was configured for the deploy.
-    if (!blobs.isLegacyDirectory) {
+    // If using the deploy config API or the Frameworks API, configure the store
+    // to use the region that was configured for the deploy. We don't do it for
+    // the legacy file-based upload API since that would be a breaking change.
+    if (blobs.apiVersion > 1) {
         storeOpts.experimentalRegion = 'auto';
     }
     const blobStore = getDeployStore(storeOpts);
-    const keys = await getKeysToUpload(blobs.directory);
-    if (keys.length === 0) {
+    const blobsToUpload = blobs.apiVersion >= 3 ? await getBlobs(blobs.directory) : await getKeysToUpload(blobs.directory);
+    if (blobsToUpload.length === 0) {
         if (!quiet) {
             log(logs, 'No blobs to upload to deploy store.');
         }
         return {};
     }
     if (!quiet) {
-        log(logs, `Uploading ${keys.length} blobs to deploy store...`);
+        log(logs, `Uploading ${blobsToUpload.length} blobs to deploy store...`);
     }
     try {
-        await pMap(keys, async (key) => {
+        await pMap(blobsToUpload, async ({ key, contentPath, metadataPath }) => {
             if (debug && !quiet) {
                 log(logs, `- Uploading blob ${key}`, { indent: true });
             }
-            const { data, metadata } = await getFileWithMetadata(blobs.directory, key);
+            const { data, metadata } = await getFileWithMetadata(key, contentPath, metadataPath);
             await blobStore.set(key, data, { metadata });
         }, { concurrency: 10 });
     }

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

@@ -1,7 +1,7 @@
 import { Metric } from '../../core/report_metrics.js';
 export declare const bundleEdgeFunctions: {
     event: string;
-    coreStep: ({ buildDir, constants: { EDGE_FUNCTIONS_DIST: distDirectory, EDGE_FUNCTIONS_SRC: srcDirectory, INTERNAL_EDGE_FUNCTIONS_SRC: internalSrcDirectory, IS_LOCAL: isRunningLocally, }, debug, systemLog, featureFlags, logs, netlifyConfig, edgeFunctionsBootstrapURL, }: {
+    coreStep: ({ buildDir, packagePath, constants: { EDGE_FUNCTIONS_DIST: distDirectory, EDGE_FUNCTIONS_SRC: srcDirectory, INTERNAL_EDGE_FUNCTIONS_SRC: internalSrcDirectory, IS_LOCAL: isRunningLocally, }, debug, systemLog, featureFlags, logs, netlifyConfig, edgeFunctionsBootstrapURL, }: {
         buildDir: string;
         packagePath: string;
         constants: Record<string, string>;
@@ -17,11 +17,13 @@ export declare const bundleEdgeFunctions: {
     coreStepId: string;
     coreStepName: string;
     coreStepDescription: () => string;
-    condition: ({ buildDir, constants: { INTERNAL_EDGE_FUNCTIONS_SRC, EDGE_FUNCTIONS_SRC }, }: {
+    condition: ({ buildDir, constants: { INTERNAL_EDGE_FUNCTIONS_SRC, EDGE_FUNCTIONS_SRC }, featureFlags, packagePath, }: {
         buildDir: any;
         constants: {
             INTERNAL_EDGE_FUNCTIONS_SRC: any;
             EDGE_FUNCTIONS_SRC: any;
         };
+        featureFlags: any;
+        packagePath: any;
     }) => Promise<boolean>;
 };

package/lib/plugins_core/edge_functions/index.js

@@ -4,23 +4,36 @@ import { bundle, find } from '@netlify/edge-bundler';
 import { pathExists } from 'path-exists';
 import { log, reduceLogLines } from '../../log/logger.js';
 import { logFunctionsToBundle } from '../../log/messages/core_steps.js';
+import { FRAMEWORKS_API_EDGE_FUNCTIONS_ENDPOINT, FRAMEWORKS_API_EDGE_FUNCTIONS_IMPORT_MAP, } from '../../utils/frameworks_api.js';
 import { tagBundlingError } from './lib/error.js';
 import { validateEdgeFunctionsManifest } from './validate_manifest/validate_edge_functions_manifest.js';
 // TODO: Replace this with a custom cache directory.
 const DENO_CLI_CACHE_DIRECTORY = '.netlify/plugins/deno-cli';
 const IMPORT_MAP_FILENAME = 'edge-functions-import-map.json';
-const coreStep = async function ({ buildDir, constants: { EDGE_FUNCTIONS_DIST: distDirectory, EDGE_FUNCTIONS_SRC: srcDirectory, INTERNAL_EDGE_FUNCTIONS_SRC: internalSrcDirectory, IS_LOCAL: isRunningLocally, }, debug, systemLog, featureFlags, logs, netlifyConfig, edgeFunctionsBootstrapURL, }) {
-    const { edge_functions: declarations = [] } = netlifyConfig;
-    const { deno_import_map: userDefinedImportMap } = netlifyConfig.functions['*'];
+const coreStep = async function ({ buildDir, packagePath, constants: { EDGE_FUNCTIONS_DIST: distDirectory, EDGE_FUNCTIONS_SRC: srcDirectory, INTERNAL_EDGE_FUNCTIONS_SRC: internalSrcDirectory, IS_LOCAL: isRunningLocally, }, debug, systemLog, featureFlags, logs, netlifyConfig, edgeFunctionsBootstrapURL, }) {
+    const { edge_functions: declarations = [], functions } = netlifyConfig;
+    const { deno_import_map: userDefinedImportMap } = functions['*'];
+    const importMapPaths = [userDefinedImportMap];
     const distPath = resolve(buildDir, distDirectory);
     const internalSrcPath = resolve(buildDir, internalSrcDirectory);
     const distImportMapPath = join(dirname(internalSrcPath), IMPORT_MAP_FILENAME);
     const srcPath = srcDirectory ? resolve(buildDir, srcDirectory) : undefined;
-    const sourcePaths = [internalSrcPath, srcPath].filter(Boolean);
-    logFunctions({ internalSrcDirectory, internalSrcPath, logs, srcDirectory, srcPath });
-    // If we're running in buildbot and the feature flag is enabled, we set the
-    // Deno cache dir to a directory that is persisted between builds.
-    const cacheDirectory = !isRunningLocally && featureFlags.edge_functions_cache_cli ? resolve(buildDir, DENO_CLI_CACHE_DIRECTORY) : undefined;
+    const frameworksAPISrcPath = resolve(buildDir, packagePath || '', FRAMEWORKS_API_EDGE_FUNCTIONS_ENDPOINT);
+    const generatedFunctionPaths = [internalSrcPath];
+    if (featureFlags.netlify_build_frameworks_api) {
+        if (await pathExists(frameworksAPISrcPath)) {
+            generatedFunctionPaths.unshift(frameworksAPISrcPath);
+        }
+        const frameworkImportMap = resolve(buildDir, packagePath || '', FRAMEWORKS_API_EDGE_FUNCTIONS_ENDPOINT, FRAMEWORKS_API_EDGE_FUNCTIONS_IMPORT_MAP);
+        if (await pathExists(frameworkImportMap)) {
+            importMapPaths.push(frameworkImportMap);
+        }
+    }
+    const sourcePaths = [...generatedFunctionPaths, srcPath].filter(Boolean);
+    logFunctions({ frameworksAPISrcPath, internalSrcDirectory, internalSrcPath, logs, srcDirectory, srcPath });
+    // If we're running in buildbot, we set the Deno cache dir to a directory
+    // that is persisted between builds.
+    const cacheDirectory = !isRunningLocally ? resolve(buildDir, DENO_CLI_CACHE_DIRECTORY) : undefined;
     // Cleaning up the dist directory, in case it has any artifacts from previous
     // builds.
     try {
@@ -48,10 +61,10 @@ const coreStep = async function ({ buildDir, constants: { EDGE_FUNCTIONS_DIST: d
             debug,
             distImportMapPath,
             featureFlags,
-            importMapPaths: [userDefinedImportMap],
+            importMapPaths,
             userLogger: (...args) => log(logs, reduceLogLines(args)),
-            systemLogger: featureFlags.edge_functions_system_logger ? systemLog : undefined,
-            internalSrcFolder: internalSrcPath,
+            systemLogger: systemLog,
+            internalSrcFolder: generatedFunctionPaths,
             bootstrapURL: edgeFunctionsBootstrapURL,
             vendorDirectory,
         });
@@ -84,19 +97,27 @@ const getMetrics = (manifest) => {
 // one configured by the user or the internal one) exists. We use a dynamic
 // `condition` because the directories might be created by the build command
 // or plugins.
-const hasEdgeFunctionsDirectories = async function ({ buildDir, constants: { INTERNAL_EDGE_FUNCTIONS_SRC, EDGE_FUNCTIONS_SRC }, }) {
+const hasEdgeFunctionsDirectories = async function ({ buildDir, constants: { INTERNAL_EDGE_FUNCTIONS_SRC, EDGE_FUNCTIONS_SRC }, featureFlags, packagePath, }) {
     const hasFunctionsSrc = EDGE_FUNCTIONS_SRC !== undefined && EDGE_FUNCTIONS_SRC !== '';
     if (hasFunctionsSrc) {
         return true;
     }
     const internalFunctionsSrc = resolve(buildDir, INTERNAL_EDGE_FUNCTIONS_SRC);
-    return await pathExists(internalFunctionsSrc);
+    if (await pathExists(internalFunctionsSrc)) {
+        return true;
+    }
+    if (featureFlags.netlify_build_frameworks_api) {
+        const frameworkFunctionsSrc = resolve(buildDir, packagePath || '', FRAMEWORKS_API_EDGE_FUNCTIONS_ENDPOINT);
+        return await pathExists(frameworkFunctionsSrc);
+    }
+    return false;
 };
-const logFunctions = async ({ internalSrcDirectory, internalSrcPath, logs, srcDirectory: userFunctionsSrc, srcPath, }) => {
-    const [userFunctionsSrcExists, userFunctions, internalFunctions] = await Promise.all([
+const logFunctions = async ({ frameworksAPISrcPath, internalSrcDirectory, internalSrcPath, logs, srcDirectory: userFunctionsSrc, srcPath, }) => {
+    const [userFunctionsSrcExists, userFunctions, internalFunctions, frameworkFunctions] = await Promise.all([
         srcPath ? pathExists(srcPath) : Promise.resolve(false),
         srcPath ? find([srcPath]) : Promise.resolve([]),
         find([internalSrcPath]),
+        frameworksAPISrcPath ? find([frameworksAPISrcPath]) : Promise.resolve([]),
     ]);
     logFunctionsToBundle({
         logs,
@@ -105,6 +126,7 @@ const logFunctions = async ({ internalSrcDirectory, internalSrcPath, logs, srcDi
         userFunctionsSrcExists,
         internalFunctions: internalFunctions.map(({ name }) => name),
         internalFunctionsSrc: internalSrcDirectory,
+        frameworkFunctions: frameworkFunctions.map(({ name }) => name),
         type: 'Edge Functions',
     });
 };

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

@@ -1,6 +1,6 @@
 export declare const bundleFunctions: {
     event: string;
-    coreStep: ({ childEnv, constants: { INTERNAL_FUNCTIONS_SRC: relativeInternalFunctionsSrc, IS_LOCAL: isRunningLocally, FUNCTIONS_SRC: relativeFunctionsSrc, FUNCTIONS_DIST: relativeFunctionsDist, }, buildDir, logs, netlifyConfig, featureFlags, repositoryRoot, userNodeVersion, systemLog, }: {
+    coreStep: ({ childEnv, constants: { INTERNAL_FUNCTIONS_SRC: relativeInternalFunctionsSrc, IS_LOCAL: isRunningLocally, FUNCTIONS_SRC: relativeFunctionsSrc, FUNCTIONS_DIST: relativeFunctionsDist, }, buildDir, packagePath, logs, netlifyConfig, featureFlags, repositoryRoot, userNodeVersion, systemLog, }: {
         childEnv: any;
         constants: {
             INTERNAL_FUNCTIONS_SRC: any;
@@ -9,6 +9,7 @@ export declare const bundleFunctions: {
             FUNCTIONS_DIST: any;
         };
         buildDir: any;
+        packagePath: any;
         logs: any;
         netlifyConfig: any;
         featureFlags: any;
@@ -34,12 +35,14 @@ export declare const bundleFunctions: {
     coreStepId: string;
     coreStepName: string;
     coreStepDescription: () => string;
-    condition: ({ buildDir, constants: { INTERNAL_FUNCTIONS_SRC, FUNCTIONS_SRC } }: {
+    condition: ({ buildDir, constants: { INTERNAL_FUNCTIONS_SRC, FUNCTIONS_SRC }, featureFlags, packagePath, }: {
         buildDir: any;
         constants: {
             INTERNAL_FUNCTIONS_SRC: any;
             FUNCTIONS_SRC: any;
         };
+        featureFlags: any;
+        packagePath: any;
     }) => Promise<boolean>;
 };
 export declare const zipItAndShipIt: {

package/lib/plugins_core/functions/index.js

@@ -4,6 +4,7 @@ import { pathExists } from 'path-exists';
 import { addErrorInfo } from '../../error/info.js';
 import { log } from '../../log/logger.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';
 import { getUserAndInternalFunctions, validateFunctionsSrc } from './utils.js';
 import { getZisiParameters } from './zisi.js';
@@ -45,7 +46,7 @@ const validateCustomRoutes = function (functions) {
         }
     }
 };
-const zipFunctionsAndLogResults = async ({ buildDir, childEnv, featureFlags, functionsConfig, functionsDist, functionsSrc, internalFunctionsSrc, isRunningLocally, logs, repositoryRoot, userNodeVersion, systemLog, }) => {
+const zipFunctionsAndLogResults = async ({ buildDir, childEnv, featureFlags, functionsConfig, functionsDist, functionsSrc, frameworkFunctionsSrc, internalFunctionsSrc, isRunningLocally, logs, repositoryRoot, userNodeVersion, systemLog, }) => {
     const zisiParameters = getZisiParameters({
         buildDir,
         childEnv,
@@ -61,7 +62,7 @@ const zipFunctionsAndLogResults = async ({ buildDir, childEnv, featureFlags, fun
     try {
         // Printing an empty line before bundling output.
         log(logs, '');
-        const sourceDirectories = [internalFunctionsSrc, functionsSrc].filter(Boolean);
+        const sourceDirectories = [frameworkFunctionsSrc, internalFunctionsSrc, functionsSrc].filter(Boolean);
         const results = await zipItAndShipIt.zipFunctions(sourceDirectories, functionsDist, zisiParameters);
         validateCustomRoutes(results);
         const bundlers = Array.from(getBundlers(results));
@@ -73,18 +74,22 @@ const zipFunctionsAndLogResults = async ({ buildDir, childEnv, featureFlags, fun
     }
 };
 // Plugin to package Netlify functions with @netlify/zip-it-and-ship-it
-const coreStep = async function ({ childEnv, constants: { INTERNAL_FUNCTIONS_SRC: relativeInternalFunctionsSrc, IS_LOCAL: isRunningLocally, FUNCTIONS_SRC: relativeFunctionsSrc, FUNCTIONS_DIST: relativeFunctionsDist, }, buildDir, logs, netlifyConfig, featureFlags, repositoryRoot, userNodeVersion, systemLog, }) {
+const coreStep = async function ({ childEnv, constants: { INTERNAL_FUNCTIONS_SRC: relativeInternalFunctionsSrc, IS_LOCAL: isRunningLocally, FUNCTIONS_SRC: relativeFunctionsSrc, FUNCTIONS_DIST: relativeFunctionsDist, }, buildDir, packagePath, logs, netlifyConfig, featureFlags, repositoryRoot, userNodeVersion, systemLog, }) {
     const functionsSrc = relativeFunctionsSrc === undefined ? undefined : resolve(buildDir, relativeFunctionsSrc);
     const functionsDist = resolve(buildDir, relativeFunctionsDist);
     const internalFunctionsSrc = resolve(buildDir, relativeInternalFunctionsSrc);
     const internalFunctionsSrcExists = await pathExists(internalFunctionsSrc);
+    const frameworkFunctionsSrc = resolve(buildDir, packagePath || '', FRAMEWORKS_API_FUNCTIONS_ENDPOINT);
+    const frameworkFunctionsSrcExists = await pathExists(frameworkFunctionsSrc);
     const functionsSrcExists = await validateFunctionsSrc({ functionsSrc, relativeFunctionsSrc });
-    const [userFunctions = [], internalFunctions = []] = await getUserAndInternalFunctions({
+    const [userFunctions = [], internalFunctions = [], frameworkFunctions = []] = await getUserAndInternalFunctions({
         featureFlags,
         functionsSrc,
         functionsSrcExists,
         internalFunctionsSrc,
         internalFunctionsSrcExists,
+        frameworkFunctionsSrc,
+        frameworkFunctionsSrcExists,
     });
     if (functionsSrc && !functionsSrcExists) {
         logFunctionsNonExistingDir(logs, relativeFunctionsSrc);
@@ -99,8 +104,9 @@ const coreStep = async function ({ childEnv, constants: { INTERNAL_FUNCTIONS_SRC
         userFunctionsSrcExists: functionsSrcExists,
         internalFunctions,
         internalFunctionsSrc: relativeInternalFunctionsSrc,
+        frameworkFunctions,
     });
-    if (userFunctions.length === 0 && internalFunctions.length === 0) {
+    if (userFunctions.length === 0 && internalFunctions.length === 0 && frameworkFunctions.length === 0) {
         return {};
     }
     const { bundlers } = await zipFunctionsAndLogResults({
@@ -110,6 +116,7 @@ const coreStep = async function ({ childEnv, constants: { INTERNAL_FUNCTIONS_SRC
         functionsConfig: netlifyConfig.functions,
         functionsDist,
         functionsSrc,
+        frameworkFunctionsSrc,
         internalFunctionsSrc,
         isRunningLocally,
         logs,
@@ -129,13 +136,20 @@ const coreStep = async function ({ childEnv, constants: { INTERNAL_FUNCTIONS_SRC
 // one configured by the user or the internal one) exists. We use a dynamic
 // `condition` because the directories might be created by the build command
 // or plugins.
-const hasFunctionsDirectories = async function ({ buildDir, constants: { INTERNAL_FUNCTIONS_SRC, FUNCTIONS_SRC } }) {
+const hasFunctionsDirectories = async function ({ buildDir, constants: { INTERNAL_FUNCTIONS_SRC, FUNCTIONS_SRC }, featureFlags, packagePath, }) {
     const hasFunctionsSrc = FUNCTIONS_SRC !== undefined && FUNCTIONS_SRC !== '';
     if (hasFunctionsSrc) {
         return true;
     }
     const internalFunctionsSrc = resolve(buildDir, INTERNAL_FUNCTIONS_SRC);
-    return await pathExists(internalFunctionsSrc);
+    if (await pathExists(internalFunctionsSrc)) {
+        return true;
+    }
+    if (featureFlags.netlify_build_frameworks_api) {
+        const frameworkFunctionsSrc = resolve(buildDir, packagePath || '', FRAMEWORKS_API_FUNCTIONS_ENDPOINT);
+        return await pathExists(frameworkFunctionsSrc);
+    }
+    return false;
 };
 export const bundleFunctions = {
     event: 'onBuild',

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

@@ -1,9 +1,11 @@
-export function getUserAndInternalFunctions({ featureFlags, functionsSrc, functionsSrcExists, internalFunctionsSrc, internalFunctionsSrcExists, }: {
+export function getUserAndInternalFunctions({ featureFlags, functionsSrc, functionsSrcExists, internalFunctionsSrc, internalFunctionsSrcExists, frameworkFunctionsSrc, frameworkFunctionsSrcExists, }: {
     featureFlags: any;
     functionsSrc: any;
     functionsSrcExists: any;
     internalFunctionsSrc: any;
     internalFunctionsSrcExists: any;
+    frameworkFunctionsSrc: any;
+    frameworkFunctionsSrcExists: any;
 }): Promise<any[]>;
 export function validateFunctionsSrc({ functionsSrc, relativeFunctionsSrc }: {
     functionsSrc: any;

package/lib/plugins_core/functions/utils.js

@@ -13,11 +13,14 @@ const getRelativeFunctionMainFiles = async function ({ featureFlags, functionsSr
     const functions = await listFunctions(functionsSrc, { featureFlags: zisiFeatureFlags });
     return functions.map(({ mainFile }) => relative(functionsSrc, mainFile));
 };
-export const getUserAndInternalFunctions = ({ featureFlags, functionsSrc, functionsSrcExists, internalFunctionsSrc, internalFunctionsSrcExists, }) => {
+export const getUserAndInternalFunctions = ({ featureFlags, functionsSrc, functionsSrcExists, internalFunctionsSrc, internalFunctionsSrcExists, frameworkFunctionsSrc, frameworkFunctionsSrcExists, }) => {
     const paths = [
         functionsSrcExists ? functionsSrc : undefined,
         internalFunctionsSrcExists ? internalFunctionsSrc : undefined,
     ];
+    if (featureFlags.netlify_build_frameworks_api && frameworkFunctionsSrcExists) {
+        paths.push(frameworkFunctionsSrc);
+    }
     return Promise.all(paths.map((path) => path && getRelativeFunctionMainFiles({ featureFlags, functionsSrc: path })));
 };
 // Returns `true` if the functions directory exists and is valid. Returns

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

@@ -6,7 +6,7 @@ type GetZisiParametersType = {
     featureFlags: FeatureFlags;
     functionsConfig: Record<string, any>;
     functionsDist: string;
-    internalFunctionsSrc: string;
+    internalFunctionsSrc: string | undefined;
     isRunningLocally: boolean;
     repositoryRoot: string;
     userNodeVersion: string;

package/lib/plugins_core/functions/zisi.js

@@ -25,8 +25,9 @@ export const getZisiParameters = ({ buildDir, childEnv, featureFlags, functionsC
         normalizeFunctionConfig({ buildDir, functionConfig: object, isRunningLocally, nodeVersion }),
     ]);
     const zisiFeatureFlags = getZisiFeatureFlags(featureFlags);
-    // Only internal functions are allowed to have a json config file
-    const configFileDirectories = [resolve(internalFunctionsSrc)];
+    // Only the legacy internal functions directory is allowed to have a JSON
+    // config file.
+    const configFileDirectories = internalFunctionsSrc ? [resolve(internalFunctionsSrc)] : undefined;
     return {
         basePath: buildDir,
         config,
@@ -35,7 +36,7 @@ export const getZisiParameters = ({ buildDir, childEnv, featureFlags, functionsC
         repositoryRoot,
         configFileDirectories,
         internalSrcFolder: internalFunctionsSrc,
-        systemLog: featureFlags.buildbot_zisi_system_log ? systemLog : undefined,
+        systemLog,
     };
 };
 // The function configuration keys returned by @netlify/config are not an exact

package/lib/report/statsd.d.ts

@@ -4,7 +4,7 @@ export interface InputStatsDOptions {
     port?: number;
 }
 export type StatsDOptions = Required<InputStatsDOptions>;
-export declare const validateStatsDOptions: (statsdOpts: InputStatsDOptions) => statsdOpts is Required<InputStatsDOptions>;
+export declare const validateStatsDOptions: (statsdOpts: InputStatsDOptions) => statsdOpts is StatsDOptions;
 /**
  * Start a new StatsD Client and a new UDP socket
  */

package/lib/time/measure.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 /** Starts a timer */
 export declare const startTimer: NodeJS.HRTime;
 /** Stops a timer */

package/lib/utils/blobs.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 /** Retrieve the absolute path of the deploy scoped internal blob directories */
 export declare const getBlobsDirs: (buildDir: string, packagePath?: string) => string[];
 interface EnvironmentContext {
@@ -17,21 +16,28 @@ export declare const getBlobsEnvironmentContext: ({ api, deployId, siteId, token
 };
 /**
  * Detect if there are any blobs to upload, and if so, what directory they're
- * in and whether that directory is the legacy `.netlify/blobs` path or the
- * newer deploy config API endpoint.
+ * in and what version of the file-based API is being used.
  *
  * @param buildDir The build directory. (current working directory where the build is executed)
- * @param packagePath An optional package path for mono repositories
+ * @param packagePath An optional package path for monorepos
  * @returns
  */
 export declare const scanForBlobs: (buildDir: string, packagePath?: string) => Promise<{
+    apiVersion: number;
     directory: string;
-    isLegacyDirectory: boolean;
 } | null>;
-/** Given output directory, find all file paths to upload excluding metadata files */
-export declare const getKeysToUpload: (blobsDir: string) => Promise<string[]>;
+/**
+ * Returns the blobs that should be uploaded for a given directory tree. The
+ * result is an array with the blob key, the path to its data file, and the
+ * path to its metadata file.
+ */
+export declare const getKeysToUpload: (blobsDir: string) => Promise<{
+    key: string;
+    contentPath: string;
+    metadataPath: string;
+}[]>;
 /** Read a file and its metadata file from the blobs directory */
-export declare const getFileWithMetadata: (blobsDir: string, key: string) => Promise<{
+export declare const getFileWithMetadata: (key: string, contentPath: string, metadataPath?: string) => Promise<{
     data: Buffer;
     metadata: Record<string, string>;
 }>;

package/lib/utils/blobs.js

@@ -2,6 +2,7 @@ import { readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { fdir } from 'fdir';
 import { DEFAULT_API_HOST } from '../core/normalize_flags.js';
+import { FRAMEWORKS_API_BLOBS_ENDPOINT } from './frameworks_api.js';
 const LEGACY_BLOBS_PATH = '.netlify/blobs/deploy';
 const DEPLOY_CONFIG_BLOBS_PATH = '.netlify/deploy/v1/blobs/deploy';
 /** Retrieve the absolute path of the deploy scoped internal blob directories */
@@ -27,51 +28,78 @@ export const getBlobsEnvironmentContext = ({ api = { host: DEFAULT_API_HOST, sch
 };
 /**
  * Detect if there are any blobs to upload, and if so, what directory they're
- * in and whether that directory is the legacy `.netlify/blobs` path or the
- * newer deploy config API endpoint.
+ * in and what version of the file-based API is being used.
  *
  * @param buildDir The build directory. (current working directory where the build is executed)
- * @param packagePath An optional package path for mono repositories
+ * @param packagePath An optional package path for monorepos
  * @returns
  */
 export const scanForBlobs = async function (buildDir, packagePath) {
-    const blobsDir = path.resolve(buildDir, packagePath || '', DEPLOY_CONFIG_BLOBS_PATH);
-    const blobsDirScan = await new fdir().onlyCounts().crawl(blobsDir).withPromise();
-    if (blobsDirScan.files > 0) {
+    // We start by looking for files using the Frameworks API.
+    const frameworkBlobsDir = path.resolve(buildDir, packagePath || '', FRAMEWORKS_API_BLOBS_ENDPOINT, 'deploy');
+    const frameworkBlobsDirScan = await new fdir().onlyCounts().crawl(frameworkBlobsDir).withPromise();
+    if (frameworkBlobsDirScan.files > 0) {
         return {
-            directory: blobsDir,
-            isLegacyDirectory: false,
+            apiVersion: 3,
+            directory: frameworkBlobsDir,
         };
     }
+    // Next, we look for files using the legacy Deploy Configuration API. It was
+    // short-lived and not really documented, but we do have sites relying on
+    // it, so we must support it for backwards-compatibility.
+    const deployConfigBlobsDir = path.resolve(buildDir, packagePath || '', DEPLOY_CONFIG_BLOBS_PATH);
+    const deployConfigBlobsDirScan = await new fdir().onlyCounts().crawl(deployConfigBlobsDir).withPromise();
+    if (deployConfigBlobsDirScan.files > 0) {
+        return {
+            apiVersion: 2,
+            directory: deployConfigBlobsDir,
+        };
+    }
+    // Finally, we look for files using the initial spec for file-based Blobs
+    // uploads.
     const legacyBlobsDir = path.resolve(buildDir, packagePath || '', LEGACY_BLOBS_PATH);
     const legacyBlobsDirScan = await new fdir().onlyCounts().crawl(legacyBlobsDir).withPromise();
     if (legacyBlobsDirScan.files > 0) {
         return {
+            apiVersion: 1,
             directory: legacyBlobsDir,
-            isLegacyDirectory: true,
         };
     }
     return null;
 };
 const METADATA_PREFIX = '$';
 const METADATA_SUFFIX = '.json';
-/** Given output directory, find all file paths to upload excluding metadata files */
+/**
+ * Returns the blobs that should be uploaded for a given directory tree. The
+ * result is an array with the blob key, the path to its data file, and the
+ * path to its metadata file.
+ */
 export const getKeysToUpload = async (blobsDir) => {
+    const blobsToUpload = [];
     const files = await new fdir()
         .withRelativePaths() // we want the relative path from the blobsDir
         .filter((fpath) => !path.basename(fpath).startsWith(METADATA_PREFIX))
         .crawl(blobsDir)
         .withPromise();
-    // normalize the path separators to all use the forward slash
-    return files.map((f) => f.split(path.sep).join('/'));
+    files.forEach((filePath) => {
+        const key = filePath.split(path.sep).join('/');
+        const contentPath = path.resolve(blobsDir, filePath);
+        const basename = path.basename(filePath);
+        const metadataPath = path.resolve(blobsDir, path.dirname(filePath), `${METADATA_PREFIX}${basename}${METADATA_SUFFIX}`);
+        blobsToUpload.push({
+            key,
+            contentPath,
+            metadataPath,
+        });
+    });
+    return blobsToUpload;
 };
 /** Read a file and its metadata file from the blobs directory */
-export const getFileWithMetadata = async (blobsDir, key) => {
-    const contentPath = path.join(blobsDir, key);
-    const dirname = path.dirname(key);
-    const basename = path.basename(key);
-    const metadataPath = path.join(blobsDir, dirname, `${METADATA_PREFIX}${basename}${METADATA_SUFFIX}`);
-    const [data, metadata] = await Promise.all([readFile(contentPath), readMetadata(metadataPath)]).catch((err) => {
+export const getFileWithMetadata = async (key, contentPath, metadataPath) => {
+    const [data, metadata] = await Promise.all([
+        readFile(contentPath),
+        metadataPath ? readMetadata(metadataPath) : {},
+    ]).catch((err) => {
         throw new Error(`Failed while reading '${key}' and its metadata: ${err.message}`);
     });
     return { data, metadata };

package/lib/utils/frameworks_api.d.ts

@@ -0,0 +1,45 @@
+export declare const FRAMEWORKS_API_BLOBS_ENDPOINT = ".netlify/v1/blobs";
+export declare const FRAMEWORKS_API_CONFIG_ENDPOINT = ".netlify/v1/config.json";
+export declare const FRAMEWORKS_API_EDGE_FUNCTIONS_ENDPOINT = ".netlify/v1/edge-functions";
+export declare const FRAMEWORKS_API_EDGE_FUNCTIONS_IMPORT_MAP = "import_map.json";
+export declare const FRAMEWORKS_API_FUNCTIONS_ENDPOINT = ".netlify/v1/functions";
+type DirectoryTreeFiles = Map<string, string[]>;
+/**
+ * Traverses a directory tree in search of leaf files. The key of each leaf
+ * file is determined by its path relative to the base directory.
+ *
+ * For example, given the following directory tree:
+ *
+ * .netlify/
+ * └── v1/
+ *     └── blobs/
+ *         └── deploy/
+ *             ├── example.com/
+ *             │   └── blob
+ *             └── netlify.com/
+ *                 ├── blob
+ *                 └── blob.meta.json
+ *
+ * If this method is called on `.netlify/v1/blobs/deploy` with `blob` and
+ * `blob.meta.json` as leaf names, it will return the following Map:
+ *
+ * {
+ *   "example.com" => [
+ *      "/full/path/to/.netlify/v1/blobs/deploy/example.com/blob"
+ *   ],
+ *   "netlify.com" => [
+ *      "/full/path/to/.netlify/v1/blobs/deploy/netlify.com/blob",
+ *      "/full/path/to/.netlify/v1/blobs/deploy/netlify.com/blob.meta.json"
+ *   ]
+ * }
+ */
+export declare const findFiles: (directory: string, leafNames: Set<string>) => Promise<DirectoryTreeFiles>;
+/**
+ * Finds blobs and their corresponding metadata files in a given directory.
+ */
+export declare const getBlobs: (blobsDirectory: string) => Promise<{
+    key: string;
+    contentPath: string;
+    metadataPath?: string;
+}[]>;
+export {};

package/lib/utils/frameworks_api.js

@@ -0,0 +1,75 @@
+import { basename, dirname, resolve, sep } from 'node:path';
+import { fdir } from 'fdir';
+export const FRAMEWORKS_API_BLOBS_ENDPOINT = '.netlify/v1/blobs';
+export const FRAMEWORKS_API_CONFIG_ENDPOINT = '.netlify/v1/config.json';
+export const FRAMEWORKS_API_EDGE_FUNCTIONS_ENDPOINT = '.netlify/v1/edge-functions';
+export const FRAMEWORKS_API_EDGE_FUNCTIONS_IMPORT_MAP = 'import_map.json';
+export const FRAMEWORKS_API_FUNCTIONS_ENDPOINT = '.netlify/v1/functions';
+/**
+ * Traverses a directory tree in search of leaf files. The key of each leaf
+ * file is determined by its path relative to the base directory.
+ *
+ * For example, given the following directory tree:
+ *
+ * .netlify/
+ * └── v1/
+ *     └── blobs/
+ *         └── deploy/
+ *             ├── example.com/
+ *             │   └── blob
+ *             └── netlify.com/
+ *                 ├── blob
+ *                 └── blob.meta.json
+ *
+ * If this method is called on `.netlify/v1/blobs/deploy` with `blob` and
+ * `blob.meta.json` as leaf names, it will return the following Map:
+ *
+ * {
+ *   "example.com" => [
+ *      "/full/path/to/.netlify/v1/blobs/deploy/example.com/blob"
+ *   ],
+ *   "netlify.com" => [
+ *      "/full/path/to/.netlify/v1/blobs/deploy/netlify.com/blob",
+ *      "/full/path/to/.netlify/v1/blobs/deploy/netlify.com/blob.meta.json"
+ *   ]
+ * }
+ */
+export const findFiles = async (directory, leafNames) => {
+    const results = new Map();
+    const groups = await new fdir()
+        .withRelativePaths()
+        .filter((path) => leafNames.has(basename(path)))
+        .group()
+        .crawl(directory)
+        .withPromise();
+    groups.forEach(({ files }) => {
+        if (files.length === 0) {
+            return;
+        }
+        const key = dirname(files[0]).split(sep).join('/');
+        results.set(key, files.map((relativePath) => resolve(directory, relativePath)));
+    });
+    return results;
+};
+const BLOBS_CONTENT_FILE = 'blob';
+const BLOBS_META_FILE = 'blob.meta.json';
+/**
+ * Finds blobs and their corresponding metadata files in a given directory.
+ */
+export const getBlobs = async (blobsDirectory) => {
+    const files = await findFiles(blobsDirectory, new Set([BLOBS_CONTENT_FILE, BLOBS_META_FILE]));
+    const blobs = [];
+    files.forEach((filePaths, key) => {
+        const contentPath = filePaths.find((path) => basename(path) === 'blob');
+        if (!contentPath) {
+            return;
+        }
+        const metadataPath = filePaths.find((path) => basename(path) === BLOBS_META_FILE);
+        blobs.push({
+            key,
+            contentPath,
+            metadataPath,
+        });
+    });
+    return blobs;
+};

package/lib/utils/package.d.ts

@@ -6,5 +6,5 @@ type PackageResult = {
 /**
  * Retrieve `package.json` from a specific directory
  */
-export declare const getPackageJson: (cwd: string, options?: Omit<Options, 'cwd'>) => Promise<PackageResult>;
+export declare const getPackageJson: (cwd: string, options?: Omit<Options, "cwd">) => Promise<PackageResult>;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/build",
-  "version": "29.48.2",
+  "version": "29.49.1",
   "description": "Netlify build module",
   "type": "module",
   "exports": "./lib/index.js",
@@ -70,8 +70,8 @@
     "@bugsnag/js": "^7.0.0",
     "@netlify/blobs": "^7.3.0",
     "@netlify/cache-utils": "^5.1.5",
-    "@netlify/config": "^20.15.3",
-    "@netlify/edge-bundler": "12.0.1",
+    "@netlify/config": "^20.15.4",
+    "@netlify/edge-bundler": "12.1.1",
     "@netlify/framework-info": "^9.8.13",
     "@netlify/functions-utils": "^5.2.69",
     "@netlify/git-utils": "^5.1.1",
@@ -165,5 +165,5 @@
   "engines": {
     "node": "^14.16.0 || >=16.0.0"
   },
-  "gitHead": "bcf99673bb311e1e86fe44e8902875328e90cf88"
+  "gitHead": "b993b18469d4355e164f605e742e69dcb5612905"
 }