@netlify/build 26.6.0-rc → 27.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/build",
-  "version": "26.6.0-rc",
+  "version": "27.0.2",
   "description": "Netlify build module",
   "type": "module",
   "exports": "./src/core/main.js",
@@ -56,54 +56,54 @@
   "license": "MIT",
   "dependencies": {
     "@bugsnag/js": "^7.0.0",
+    "@netlify/edge-bundler": "^0.12.0",
     "@netlify/cache-utils": "^4.0.0",
-    "@netlify/config": "^17.0.0",
+    "@netlify/config": "^18.0.0",
     "@netlify/functions-utils": "^4.0.0",
     "@netlify/git-utils": "^4.0.0",
-    "@netlify/plugin-edge-handlers": "^3.0.4",
-    "@netlify/plugins-list": "^6.3.0",
+    "@netlify/plugins-list": "^6.22.0",
     "@netlify/run-utils": "^4.0.0",
-    "@netlify/zip-it-and-ship-it": "5.5.1",
-    "@sindresorhus/slugify": "^1.1.0",
+    "@netlify/zip-it-and-ship-it": "5.9.1",
+    "@sindresorhus/slugify": "^2.0.0",
     "@types/node": "^16.0.0",
-    "ansi-escapes": "^4.3.2",
-    "chalk": "^4.1.2",
-    "clean-stack": "^3.0.1",
-    "execa": "^5.1.1",
-    "figures": "^3.2.0",
-    "filter-obj": "^2.0.1",
+    "ansi-escapes": "^5.0.0",
+    "chalk": "^5.0.0",
+    "clean-stack": "^4.0.0",
+    "execa": "^6.0.0",
+    "figures": "^4.0.0",
+    "filter-obj": "^3.0.0",
     "got": "^10.0.0",
-    "indent-string": "^4.0.0",
-    "is-plain-obj": "^3.0.0",
+    "indent-string": "^5.0.0",
+    "is-plain-obj": "^4.0.0",
     "js-yaml": "^4.0.0",
-    "keep-func-props": "^3.0.0",
-    "locate-path": "^6.0.0",
-    "log-process-errors": "^6.0.0",
-    "map-obj": "^4.0.0",
+    "keep-func-props": "^4.0.0",
+    "locate-path": "^7.0.0",
+    "log-process-errors": "^8.0.0",
+    "map-obj": "^5.0.0",
     "memoize-one": "^6.0.0",
-    "os-name": "^4.0.1",
-    "p-event": "^4.1.0",
+    "os-name": "^5.0.0",
+    "p-event": "^5.0.0",
     "p-every": "^2.0.0",
-    "p-filter": "^2.1.0",
-    "p-locate": "^5.0.0",
-    "p-reduce": "^2.1.0",
-    "path-exists": "^4.0.0",
-    "path-type": "^4.0.0",
-    "pkg-dir": "^5.0.0",
+    "p-filter": "^3.0.0",
+    "p-locate": "^6.0.0",
+    "p-reduce": "^3.0.0",
+    "path-exists": "^5.0.0",
+    "path-type": "^5.0.0",
+    "pkg-dir": "^6.0.0",
     "pretty-ms": "^7.0.0",
-    "ps-list": "^7.0.0",
-    "read-pkg-up": "^7.0.1",
+    "ps-list": "^8.0.0",
+    "read-pkg-up": "^9.0.0",
     "readdirp": "^3.4.0",
     "resolve": "^2.0.0-next.1",
     "rfdc": "^1.3.0",
     "safe-json-stringify": "^1.2.0",
     "semver": "^7.0.0",
     "statsd-client": "0.4.7",
-    "string-width": "^4.2.0",
-    "strip-ansi": "^6.0.0",
-    "supports-color": "^8.0.0",
+    "string-width": "^5.0.0",
+    "strip-ansi": "^7.0.0",
+    "supports-color": "^9.0.0",
     "tmp-promise": "^3.0.2",
-    "ts-node": "^10.4.0",
+    "ts-node": "10.4.0",
     "typescript": "^4.5.4",
     "update-notifier": "^5.0.0",
     "uuid": "^8.0.0",
@@ -112,20 +112,20 @@
   "devDependencies": {
     "@netlify/nock-udp": "^1.0.0",
     "atob": "^2.1.2",
-    "ava": "^3.15.0",
+    "ava": "^4.0.0",
     "cpy": "^8.1.0",
     "del": "^6.0.0",
     "fast-safe-stringify": "^2.0.7",
-    "get-bin-path": "^5.1.0",
-    "get-node": "^11.0.2",
-    "get-port": "^5.1.1",
+    "get-bin-path": "^6.0.0",
+    "get-node": "^12.0.0",
+    "get-port": "^6.0.0",
     "get-stream": "^6.0.0",
-    "has-ansi": "^4.0.0",
+    "has-ansi": "^5.0.0",
     "is-ci": "^3.0.0",
     "moize": "^6.0.0",
-    "path-key": "^3.1.1",
-    "process-exists": "^4.0.0",
-    "sinon": "^12.0.0",
+    "path-key": "^4.0.0",
+    "process-exists": "^5.0.0",
+    "sinon": "^13.0.0",
     "yarn": "^1.22.4"
   },
   "engines": {

package/src/core/config.js

@@ -143,6 +143,7 @@ export const saveUpdatedConfig = async function ({
   headersPath,
   redirectsPath,
   logs,
+  featureFlags,
   context,
   branch,
   debug,
@@ -160,6 +161,7 @@ export const saveUpdatedConfig = async function ({
     context,
     branch,
     logs,
+    featureFlags,
   })
 
   await logConfigOnUpload({ logs, configPath, debug })

package/src/core/constants.js

@@ -2,7 +2,7 @@ import { relative, normalize } from 'path'
 
 import { getCacheDir } from '@netlify/cache-utils'
 import mapObj from 'map-obj'
-import pathExists from 'path-exists'
+import { pathExists } from 'path-exists'
 
 import { ROOT_PACKAGE_JSON } from '../utils/json.js'
 
@@ -11,6 +11,7 @@ export const getConstants = async function ({
   configPath,
   buildDir,
   functionsDistDir,
+  edgeFunctionsDistDir,
   cacheDir,
   netlifyConfig,
   siteInfo: { id: siteId },
@@ -26,6 +27,8 @@ export const getConstants = async function ({
     CONFIG_PATH: configPath,
     // The directory where built serverless functions are placed before deployment
     FUNCTIONS_DIST: functionsDistDir,
+    // The directory where built Edge Functions are placed before deployment
+    EDGE_FUNCTIONS_DIST: edgeFunctionsDistDir,
     // Path to the Netlify build cache folder
     CACHE_DIR: normalizedCacheDir,
     // Boolean indicating whether the build was run locally (Netlify CLI) or in the production CI
@@ -41,11 +44,15 @@ export const getConstants = async function ({
     // The directory where internal functions (i.e. generated programmatically
     // via plugins or others) live
     INTERNAL_FUNCTIONS_SRC: `${buildDir}/${INTERNAL_FUNCTIONS_SRC}`,
+    // The directory where internal Edge Functions (i.e. generated programmatically
+    // via plugins or others) live
+    INTERNAL_EDGE_FUNCTIONS_SRC: `${buildDir}/${INTERNAL_EDGE_FUNCTIONS_SRC}`,
   }
   const constantsA = await addMutableConstants({ constants, buildDir, netlifyConfig })
   return constantsA
 }
 
+const INTERNAL_EDGE_FUNCTIONS_SRC = '.netlify/edge-functions'
 const INTERNAL_FUNCTIONS_SRC = '.netlify/functions-internal'
 
 // Retrieve constants which might change during the build if a plugin modifies
@@ -55,7 +62,7 @@ export const addMutableConstants = async function ({
   constants,
   buildDir,
   netlifyConfig: {
-    build: { publish, edge_handlers: edgeHandlers },
+    build: { publish, edge_functions: edgeFunctions },
     functionsDirectory,
   },
 }) {
@@ -65,8 +72,8 @@ export const addMutableConstants = async function ({
     PUBLISH_DIR: publish,
     // The directory where function source code lives
     FUNCTIONS_SRC: functionsDirectory,
-    // The directory where edge handlers source code lives
-    EDGE_HANDLERS_SRC: edgeHandlers,
+    // The directory where Edge Functions source code lives
+    EDGE_FUNCTIONS_SRC: edgeFunctions,
   }
   const constantsB = await addDefaultConstants(constantsA, buildDir)
   const constantsC = normalizeConstantsPaths(constantsB, buildDir)
@@ -93,7 +100,7 @@ const DEFAULT_PATHS = [
   // @todo Remove once we drop support for the legacy default functions directory.
   { constantName: 'FUNCTIONS_SRC', defaultPath: 'netlify-automatic-functions' },
   { constantName: 'FUNCTIONS_SRC', defaultPath: 'netlify/functions' },
-  { constantName: 'EDGE_HANDLERS_SRC', defaultPath: 'netlify/edge-handlers' },
+  { constantName: 'EDGE_FUNCTIONS_SRC', defaultPath: 'netlify/edge-functions' },
 ]
 
 const addDefaultConstant = async function ({ constants, constantName, defaultPath, buildDir }) {
@@ -141,7 +148,9 @@ const CONSTANT_PATHS = new Set([
   'PUBLISH_DIR',
   'FUNCTIONS_SRC',
   'FUNCTIONS_DIST',
+  'INTERNAL_EDGE_FUNCTIONS_SRC',
   'INTERNAL_FUNCTIONS_SRC',
-  'EDGE_HANDLERS_SRC',
+  'EDGE_FUNCTIONS_DIST',
+  'EDGE_FUNCTIONS_SRC',
   'CACHE_DIR',
 ])

package/src/core/feature_flags.js

@@ -14,9 +14,10 @@ const getFeatureFlag = function (name) {
 // Default values for feature flags
 export const DEFAULT_FEATURE_FLAGS = {
   buildbot_build_go_functions: false,
-  buildbot_create_functions_manifest: false,
   buildbot_es_modules_esbuild: false,
   buildbot_zisi_trace_nft: false,
   buildbot_zisi_esbuild_parser: false,
+  edge_functions_cache_cli: false,
+  edge_functions_produce_eszip: false,
   zisi_parse_isc: false,
 }

package/src/core/flags.js

@@ -107,6 +107,12 @@ Default: Current Node.js binary`,
   functionsDistDir: {
     string: true,
     describe: `Path to the directory where packaged functions are kept.
+Default: automatically guessed`,
+    hidden: true,
+  },
+  edgeFunctionsDistDir: {
+    string: true,
+    describe: `Path to the directory where packaged Edge Functions are kept.
 Default: automatically guessed`,
     hidden: true,
   },

package/src/core/main.js

@@ -164,6 +164,7 @@ const tExecBuild = async function ({
   verbose,
   nodePath,
   functionsDistDir,
+  edgeFunctionsDistDir,
   cacheDir,
   dry,
   mode,
@@ -229,6 +230,7 @@ const tExecBuild = async function ({
     configPath,
     buildDir,
     functionsDistDir,
+    edgeFunctionsDistDir,
     cacheDir,
     netlifyConfig,
     siteInfo,

package/src/core/missing_side_file.js

@@ -1,6 +1,6 @@
 import { relative } from 'path'
 
-import pathExists from 'path-exists'
+import { pathExists } from 'path-exists'
 
 import { logMissingSideFile } from '../log/messages/core.js'
 

package/src/core/normalize_flags.js

@@ -41,6 +41,7 @@ const getDefaultFlags = function ({ env: envOpt = {} }, combinedEnv) {
     telemetry: false,
     verbose: Boolean(combinedEnv.NETLIFY_BUILD_DEBUG),
     functionsDistDir: DEFAULT_FUNCTIONS_DIST,
+    edgeFunctionsDistDir: DEFAULT_EDGE_FUNCTIONS_DIST,
     cacheDir: DEFAULT_CACHE_DIR,
     deployId: combinedEnv.DEPLOY_ID,
     buildId: combinedEnv.BUILD_ID,
@@ -62,6 +63,7 @@ const computeTelemetry = function (flags, envOpts) {
 }
 
 const REQUIRE_MODE = 'require'
+const DEFAULT_EDGE_FUNCTIONS_DIST = '.netlify/edge-functions-dist/'
 const DEFAULT_FUNCTIONS_DIST = '.netlify/functions/'
 const DEFAULT_CACHE_DIR = '.netlify/cache/'
 const DEFAULT_STATSD_PORT = 8125

package/src/core/user_node_version.js

@@ -1,6 +1,6 @@
 import { version as currentVersion, execPath } from 'process'
 
-import execa from 'execa'
+import { execa } from 'execa'
 import semver from 'semver'
 
 import { addErrorInfo } from '../error/info.js'

package/src/error/handle.js

@@ -1,6 +1,6 @@
 import { cwd as getCwd } from 'process'
 
-import pathExists from 'path-exists'
+import { pathExists } from 'path-exists'
 
 import { logBuildError } from '../log/messages/core.js'
 import { logOldCliVersionError } from '../log/old_version.js'

package/src/error/monitor/report.js

@@ -89,7 +89,10 @@ const getApp = function () {
 // But we change it back after Bugsnag is done reporting.
 const updateErrorName = function (error, type) {
   const { name } = error
-  error.name = type
+  // This might fail if `name` is a getter or is non-writable.
+  try {
+    error.name = type
+  } catch {}
   return name
 }
 

package/src/install/local.js

@@ -1,4 +1,4 @@
-import pkgDir from 'pkg-dir'
+import { packageDirectory } from 'pkg-dir'
 
 import { logInstallLocalPluginsDeps } from '../log/messages/install.js'
 
@@ -57,6 +57,6 @@ const hasPackageDir = function ({ packageDir }) {
 
 // We only install dependencies of local plugins that have their own `package.json`
 const removeMainRoot = async function (localPluginsOptions, buildDir) {
-  const mainPackageDir = await pkgDir(buildDir)
+  const mainPackageDir = await packageDirectory({ cwd: buildDir })
   return localPluginsOptions.filter(({ packageDir }) => packageDir !== mainPackageDir)
 }

package/src/install/main.js

@@ -1,7 +1,7 @@
 import { homedir } from 'os'
 
-import execa from 'execa'
-import pathExists from 'path-exists'
+import { execa } from 'execa'
+import { pathExists } from 'path-exists'
 
 import { addErrorInfo } from '../error/info.js'
 

package/src/install/missing.js

@@ -1,7 +1,7 @@
 import { promises as fs } from 'fs'
 import { normalize } from 'path'
 
-import pathExists from 'path-exists'
+import { pathExists } from 'path-exists'
 import { isFile } from 'path-type'
 
 import { logInstallMissingPlugins } from '../log/messages/install.js'

package/src/log/messages/config.js

@@ -34,6 +34,7 @@ const TEST_FLAGS = ['buffer', 'telemetry']
 const INTERNAL_FLAGS = [
   'nodePath',
   'functionsDistDir',
+  'edgeFunctionsDistDir',
   'defaultConfig',
   'cachedConfigPath',
   'sendStatus',

package/src/log/messages/core_steps.js

@@ -59,9 +59,10 @@ export const logFunctionsToBundle = function ({
   userFunctionsSrcExists,
   internalFunctions,
   internalFunctionsSrc,
+  type = 'Functions',
 }) {
   if (internalFunctions.length !== 0) {
-    log(logs, `Packaging Functions from ${THEME.highlightWords(internalFunctionsSrc)} directory:`)
+    log(logs, `Packaging ${type} from ${THEME.highlightWords(internalFunctionsSrc)} directory:`)
     logArray(logs, internalFunctions, { indent: false })
   }
 
@@ -70,7 +71,7 @@ export const logFunctionsToBundle = function ({
   }
 
   if (userFunctions.length === 0) {
-    log(logs, `No Functions were found in ${THEME.highlightWords(userFunctionsSrc)} directory`)
+    log(logs, `No ${type} were found in ${THEME.highlightWords(userFunctionsSrc)} directory`)
 
     return
   }
@@ -79,7 +80,7 @@ export const logFunctionsToBundle = function ({
     log(logs, '')
   }
 
-  log(logs, `Packaging Functions from ${THEME.highlightWords(userFunctionsSrc)} directory:`)
+  log(logs, `Packaging ${type} from ${THEME.highlightWords(userFunctionsSrc)} directory:`)
   logArray(logs, userFunctions, { indent: false })
 }
 

package/src/log/messages/mutations.js

@@ -1,7 +1,7 @@
 import { promises as fs } from 'fs'
 import { inspect } from 'util'
 
-import pathExists from 'path-exists'
+import { pathExists } from 'path-exists'
 
 import { log, logMessage, logSubHeader } from '../logger.js'
 

package/src/plugins/child/error.js

@@ -16,7 +16,7 @@ export const handleError = async function (error, verbose) {
 // On uncaught exceptions and unhandled rejections, print the stack trace.
 // Also, prevent child processes from crashing on uncaught exceptions.
 export const handleProcessErrors = function () {
-  logProcessErrors({ log: handleProcessError, exitOn: [], level: { multipleResolves: 'silent' } })
+  logProcessErrors({ log: handleProcessError, exitOn: [] })
 }
 
 const handleProcessError = async function (error, level, originalError) {

package/src/plugins/error.js

@@ -36,7 +36,10 @@ const normalizeError = function (type, func, message, { error } = {}) {
 
 const getError = function (error, message, func) {
   if (error instanceof Error) {
-    error.message = `${message}\n${error.message}`
+    // This might fail if `name` is a getter or is non-writable.
+    try {
+      error.message = `${message}\n${error.message}`
+    } catch {}
     return error
   }
 

package/src/plugins/ipc.js

@@ -1,7 +1,7 @@
 import process from 'process'
 import { promisify } from 'util'
 
-import pEvent from 'p-event'
+import { pEvent } from 'p-event'
 import { v4 as uuidv4 } from 'uuid'
 
 import { jsonToError, errorToJson } from '../error/build.js'

package/src/plugins/manifest/path.js

@@ -1,4 +1,4 @@
-import locatePath from 'locate-path'
+import { locatePath } from 'locate-path'
 
 import { addErrorInfo } from '../../error/info.js'
 

package/src/plugins/spawn.js

@@ -1,6 +1,6 @@
 import { fileURLToPath } from 'url'
 
-import execa from 'execa'
+import { execaNode } from 'execa'
 
 import { addErrorInfo } from '../error/info.js'
 import { logLoadingPlugins, logOutdatedPlugins, logIncompatiblePlugins } from '../log/messages/compatibility.js'
@@ -31,7 +31,7 @@ const tStartPlugins = async function ({ pluginsOptions, buildDir, childEnv, logs
 export const startPlugins = measureDuration(tStartPlugins, 'start_plugins')
 
 const startPlugin = async function ({ pluginDir, nodePath, buildDir, childEnv }) {
-  const childProcess = execa.node(CHILD_MAIN_FILE, {
+  const childProcess = execaNode(CHILD_MAIN_FILE, {
     cwd: buildDir,
     preferLocal: true,
     localDir: pluginDir,

package/src/plugins_core/build_command.js

@@ -1,6 +1,6 @@
 import { platform } from 'process'
 
-import execa from 'execa'
+import { execa } from 'execa'
 
 import { addErrorInfo } from '../error/info.js'
 import { getBuildCommandDescription } from '../log/description.js'

package/src/plugins_core/deploy/buildbot_client.js

@@ -2,7 +2,7 @@ import net from 'net'
 import { normalize, resolve, relative } from 'path'
 import { promisify } from 'util'
 
-import pEvent from 'p-event'
+import { pEvent } from 'p-event'
 
 import { addErrorInfo } from '../../error/info.js'
 import { runsAfterDeploy } from '../../plugins/events.js'

package/src/plugins_core/deploy/index.js

@@ -16,6 +16,7 @@ const coreStep = async function ({
   buildbotServerSocket,
   events,
   logs,
+  featureFlags,
   context,
   branch,
   configMutations,
@@ -35,6 +36,7 @@ const coreStep = async function ({
       headersPath,
       redirectsPath,
       logs,
+      featureFlags,
       context,
       branch,
       debug,

package/src/plugins_core/edge_functions/index.js

@@ -0,0 +1,103 @@
+import { dirname, join, resolve } from 'path'
+
+import { bundle, find } from '@netlify/edge-bundler'
+import { pathExists } from 'path-exists'
+
+import { logFunctionsToBundle } from '../../log/messages/core_steps.js'
+
+import { parseManifest } from './lib/internal_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,
+  featureFlags,
+  logs,
+  netlifyConfig,
+}) {
+  const { edge_functions: configDeclarations = [] } = netlifyConfig
+  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 })
+
+  const { declarations: internalDeclarations, importMap } = await parseManifest(internalSrcPath)
+  const declarations = [...configDeclarations, ...internalDeclarations]
+
+  // 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
+
+  await bundle(sourcePaths, distPath, declarations, {
+    cacheDirectory,
+    debug,
+    distImportMapPath,
+    featureFlags,
+    importMaps: [importMap].filter(Boolean),
+  })
+
+  return {}
+}
+
+// We run this core step if at least one of the functions directories (the
+// 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 hasFunctionsSrc = EDGE_FUNCTIONS_SRC !== undefined && EDGE_FUNCTIONS_SRC !== ''
+
+  if (hasFunctionsSrc) {
+    return true
+  }
+
+  const internalFunctionsSrc = resolve(buildDir, INTERNAL_EDGE_FUNCTIONS_SRC)
+
+  return await pathExists(internalFunctionsSrc)
+}
+
+const logFunctions = async ({
+  internalSrcDirectory,
+  internalSrcPath,
+  logs,
+  srcDirectory: userFunctionsSrc,
+  srcPath,
+}) => {
+  const [userFunctions, internalFunctions] = await Promise.all([find([srcPath]), find([internalSrcPath])])
+  const userFunctionsSrcExists = await pathExists(srcPath)
+  const internalFunctionsSrc = internalSrcDirectory
+
+  logFunctionsToBundle({
+    logs,
+    userFunctions: userFunctions.map(({ name }) => name),
+    userFunctionsSrc,
+    userFunctionsSrcExists,
+    internalFunctions: internalFunctions.map(({ name }) => name),
+    internalFunctionsSrc,
+    type: 'Edge Functions',
+  })
+}
+
+export const bundleEdgeFunctions = {
+  event: 'onBuild',
+  coreStep,
+  coreStepId: 'edge_functions_bundling',
+  coreStepName: 'Edge Functions bundling',
+  coreStepDescription: () => 'Edge Functions bundling',
+  condition: hasEdgeFunctionsDirectories,
+}

package/src/plugins_core/edge_functions/lib/internal_manifest.js

@@ -0,0 +1,54 @@
+import { promises as fs } from 'fs'
+import { dirname, join, resolve } from 'path'
+
+const parseManifest = async (internalSourceDirectory) => {
+  const manifestPath = join(internalSourceDirectory, 'manifest.json')
+
+  try {
+    const data = await fs.readFile(manifestPath)
+    const manifest = JSON.parse(data)
+
+    if (manifest.version !== 1) {
+      throw new Error('Unsupported manifest version')
+    }
+
+    const result = {
+      declarations: manifest.functions,
+    }
+
+    if (manifest.import_map) {
+      const importMapPath = resolve(dirname(manifestPath), manifest.import_map)
+      const importMap = await readImportMap(importMapPath)
+
+      return {
+        ...result,
+        importMap,
+      }
+    }
+
+    return result
+  } catch {
+    // no-op
+  }
+
+  return {
+    declarations: [],
+  }
+}
+
+const readImportMap = async (path) => {
+  try {
+    const data = await fs.readFile(path)
+    const importMap = JSON.parse(data)
+
+    return importMap
+  } catch {
+    // no-op
+  }
+
+  return {
+    imports: {},
+  }
+}
+
+export { parseManifest }

package/src/plugins_core/functions/index.js

@@ -1,69 +1,23 @@
-import { join, resolve } from 'path'
+import { resolve } from 'path'
 
 import { zipFunctions } from '@netlify/zip-it-and-ship-it'
-import mapObject from 'map-obj'
-import pathExists from 'path-exists'
+import { pathExists } from 'path-exists'
 
 import { log } from '../../log/logger.js'
 import { logBundleResults, logFunctionsNonExistingDir, logFunctionsToBundle } from '../../log/messages/core_steps.js'
 
 import { getZipError } from './error.js'
-import { getZisiFeatureFlags } from './feature_flags.js'
 import { getUserAndInternalFunctions, validateFunctionsSrc } from './utils.js'
+import { getZisiParameters } from './zisi.js'
 
 // Returns `true` if at least one of the functions has been configured to use
 // esbuild.
 const isUsingEsbuild = (functionsConfig = {}) =>
   Object.values(functionsConfig).some((configObject) => configObject.node_bundler === 'esbuild')
 
-// The function configuration keys returned by @netlify/config are not an exact
-// match to the properties that @netlify/zip-it-and-ship-it expects. We do that
-// translation here.
-const normalizeFunctionConfig = ({ buildDir, functionConfig = {}, isRunningLocally }) => ({
-  externalNodeModules: functionConfig.external_node_modules,
-  includedFiles: functionConfig.included_files,
-  includedFilesBasePath: buildDir,
-  ignoredNodeModules: functionConfig.ignored_node_modules,
-  schedule: functionConfig.schedule,
-
-  // When the user selects esbuild as the Node bundler, we still want to use
-  // the legacy ZISI bundler as a fallback. Rather than asking the user to
-  // make this decision, we abstract that complexity away by injecting the
-  // fallback behavior ourselves. We do this by transforming the value
-  // `esbuild` into `esbuild_zisi`, which zip-it-and-ship-it understands.
-  nodeBundler: functionConfig.node_bundler === 'esbuild' ? 'esbuild_zisi' : functionConfig.node_bundler,
-
-  // If the build is running in buildbot, we set the Rust target directory to a
-  // path that will get cached in between builds, allowing us to speed up the
-  // build process.
-  rustTargetDirectory: isRunningLocally ? undefined : resolve(buildDir, '.netlify', 'rust-functions-cache', '[name]'),
-
-  // Go functions should be zipped only when building locally. When running in
-  // buildbot, the Go API client will handle the zipping.
-  zipGo: isRunningLocally ? true : undefined,
-})
-
-const getZisiParameters = ({
-  buildDir,
-  featureFlags,
-  functionsConfig,
-  functionsDist,
-  isRunningLocally,
-  repositoryRoot,
-}) => {
-  const isManifestEnabled = isRunningLocally || featureFlags.buildbot_create_functions_manifest === true
-  const manifest = isManifestEnabled ? join(functionsDist, 'manifest.json') : undefined
-  const config = mapObject(functionsConfig, (expression, object) => [
-    expression,
-    normalizeFunctionConfig({ buildDir, featureFlags, functionConfig: object, isRunningLocally }),
-  ])
-  const zisiFeatureFlags = getZisiFeatureFlags(featureFlags)
-
-  return { basePath: buildDir, config, manifest, featureFlags: zisiFeatureFlags, repositoryRoot }
-}
-
 const zipFunctionsAndLogResults = async ({
   buildDir,
+  childEnv,
   featureFlags,
   functionsConfig,
   functionsDist,
@@ -75,6 +29,7 @@ const zipFunctionsAndLogResults = async ({
 }) => {
   const zisiParameters = getZisiParameters({
     buildDir,
+    childEnv,
     featureFlags,
     functionsConfig,
     functionsDist,
@@ -101,6 +56,7 @@ const zipFunctionsAndLogResults = async ({
 // Plugin to package Netlify functions with @netlify/zip-it-and-ship-it
 // eslint-disable-next-line complexity
 const coreStep = async function ({
+  childEnv,
   constants: {
     INTERNAL_FUNCTIONS_SRC: relativeInternalFunctionsSrc,
     IS_LOCAL: isRunningLocally,
@@ -149,6 +105,7 @@ const coreStep = async function ({
 
   const { bundler } = await zipFunctionsAndLogResults({
     buildDir,
+    childEnv,
     featureFlags,
     functionsConfig: netlifyConfig.functions,
     functionsDist,

package/src/plugins_core/functions/zisi.js

@@ -0,0 +1,53 @@
+import { join, resolve } from 'path'
+
+import mapObject from 'map-obj'
+
+import { getZisiFeatureFlags } from './feature_flags.js'
+
+export const getZisiParameters = ({
+  buildDir,
+  childEnv,
+  featureFlags,
+  functionsConfig,
+  functionsDist,
+  isRunningLocally,
+  repositoryRoot,
+}) => {
+  const nodeVersion = childEnv.AWS_LAMBDA_JS_RUNTIME
+  const manifest = join(functionsDist, 'manifest.json')
+  const config = mapObject(functionsConfig, (expression, object) => [
+    expression,
+    normalizeFunctionConfig({ buildDir, featureFlags, functionConfig: object, isRunningLocally, nodeVersion }),
+  ])
+  const zisiFeatureFlags = getZisiFeatureFlags(featureFlags)
+
+  return { basePath: buildDir, config, manifest, featureFlags: zisiFeatureFlags, repositoryRoot }
+}
+
+// The function configuration keys returned by @netlify/config are not an exact
+// match to the properties that @netlify/zip-it-and-ship-it expects. We do that
+// translation here.
+export const normalizeFunctionConfig = ({ buildDir, functionConfig = {}, isRunningLocally, nodeVersion }) => ({
+  externalNodeModules: functionConfig.external_node_modules,
+  includedFiles: functionConfig.included_files,
+  includedFilesBasePath: buildDir,
+  ignoredNodeModules: functionConfig.ignored_node_modules,
+  nodeVersion,
+  schedule: functionConfig.schedule,
+
+  // When the user selects esbuild as the Node bundler, we still want to use
+  // the legacy ZISI bundler as a fallback. Rather than asking the user to
+  // make this decision, we abstract that complexity away by injecting the
+  // fallback behavior ourselves. We do this by transforming the value
+  // `esbuild` into `esbuild_zisi`, which zip-it-and-ship-it understands.
+  nodeBundler: functionConfig.node_bundler === 'esbuild' ? 'esbuild_zisi' : functionConfig.node_bundler,
+
+  // If the build is running in buildbot, we set the Rust target directory to a
+  // path that will get cached in between builds, allowing us to speed up the
+  // build process.
+  rustTargetDirectory: isRunningLocally ? undefined : resolve(buildDir, '.netlify', 'rust-functions-cache', '[name]'),
+
+  // Go functions should be zipped only when building locally. When running in
+  // buildbot, the Go API client will handle the zipping.
+  zipGo: isRunningLocally ? true : undefined,
+})

package/src/plugins_core/functions_install/index.js

@@ -1,4 +1,4 @@
-import pathExists from 'path-exists'
+import { pathExists } from 'path-exists'
 
 import { installFunctionDependencies } from '../../install/functions.js'
 

package/src/plugins_core/list.js

@@ -1,26 +1,17 @@
-import { createRequire } from 'module'
 import { fileURLToPath } from 'url'
 
 import { LOCAL_INSTALL_PLUGIN_NAME } from '../install/local.js'
 
-// TODO: use `import.resolve()` once it is available without any experimental
-// flags
-const require = createRequire(import.meta.url)
-
 const FUNCTIONS_INSTALL_PLUGIN = fileURLToPath(new URL('functions_install/index.js', import.meta.url))
 
 // List of core plugin names
 const FUNCTIONS_INSTALL_PLUGIN_NAME = '@netlify/plugin-functions-install-core'
-const EDGE_HANDLERS_PLUGIN_NAME = '@netlify/plugin-edge-handlers'
-const CORE_PLUGINS = new Set([FUNCTIONS_INSTALL_PLUGIN_NAME, LOCAL_INSTALL_PLUGIN_NAME, EDGE_HANDLERS_PLUGIN_NAME])
-
-const EDGE_HANDLERS_PLUGIN_PATH = require.resolve(EDGE_HANDLERS_PLUGIN_NAME)
+const CORE_PLUGINS = new Set([FUNCTIONS_INSTALL_PLUGIN_NAME, LOCAL_INSTALL_PLUGIN_NAME])
 
 // Plugins that are installed and enabled by default
-export const listCorePlugins = function ({ FUNCTIONS_SRC, EDGE_HANDLERS_SRC }) {
+export const listCorePlugins = function ({ FUNCTIONS_SRC }) {
   const functionsInstallPlugin = getFunctionsInstallPlugin(FUNCTIONS_SRC)
-  const edgeHandlersPlugin = getEdgeHandlersPlugin(EDGE_HANDLERS_SRC)
-  return [functionsInstallPlugin, edgeHandlersPlugin].filter(Boolean)
+  return [functionsInstallPlugin].filter(Boolean)
 }
 
 const getFunctionsInstallPlugin = function (FUNCTIONS_SRC) {
@@ -31,18 +22,6 @@ const getFunctionsInstallPlugin = function (FUNCTIONS_SRC) {
   return { package: FUNCTIONS_INSTALL_PLUGIN_NAME, pluginPath: FUNCTIONS_INSTALL_PLUGIN, optional: true }
 }
 
-// To enable Edge handlers, create a `netlify/edge-handlers` directory in the build
-// directory.
-// The location can be overridden using the `build.edge_handlers` property in
-// `netlify.toml`.
-const getEdgeHandlersPlugin = function (EDGE_HANDLERS_SRC) {
-  if (EDGE_HANDLERS_SRC === undefined) {
-    return
-  }
-
-  return { package: EDGE_HANDLERS_PLUGIN_NAME, pluginPath: EDGE_HANDLERS_PLUGIN_PATH }
-}
-
 export const isCorePlugin = function (packageName) {
   return CORE_PLUGINS.has(packageName)
 }

package/src/steps/get.js

@@ -1,6 +1,7 @@
 import { EVENTS } from '../plugins/events.js'
 import { buildCommandCore } from '../plugins_core/build_command.js'
 import { deploySite } from '../plugins_core/deploy/index.js'
+import { bundleEdgeFunctions } from '../plugins_core/edge_functions/index.js'
 import { bundleFunctions } from '../plugins_core/functions/index.js'
 
 // Get all build steps
@@ -12,7 +13,7 @@ export const getSteps = function (steps) {
 }
 
 const addCoreSteps = function (steps) {
-  return [buildCommandCore, ...steps, bundleFunctions, deploySite]
+  return [buildCommandCore, ...steps, bundleFunctions, bundleEdgeFunctions, deploySite]
 }
 
 // Sort plugin steps by event order.

package/src/steps/run_step.js

@@ -159,7 +159,7 @@ export const runStep = async function ({
 //
 // Otherwise, most failures will make the build fail. This includes:
 //   - the build command failed
-//   - Functions or Edge handlers bundling failed
+//   - Functions or Edge Functions bundling failed
 //   - the deploy failed (deploying files to our CDN)
 //   - a plugin `onPreBuild`, `onBuild` or `onPostBuild` event handler failed.
 //     This includes uncaught exceptions and using `utils.build.failBuild()`
@@ -173,8 +173,8 @@ export const runStep = async function ({
 //
 // Finally, some plugins (only core plugins for the moment) might be enabled or
 // not depending on whether a specific action is happening during the build,
-// such as creating a file. For example, the Functions and Edge handlers core
-// plugins are disabled if no Functions or Edge handlers directory is specified
+// such as creating a file. For example, the Functions and Edge Functions core
+// plugins are disabled if no Functions or Edge Functions directory is specified
 // or available. However, one might be created by a build plugin, in which case,
 // those core plugins should be triggered. We use a dynamic `condition()` to
 // model this behavior.

package/src/steps/update_config.js

@@ -1,7 +1,7 @@
 import { isDeepStrictEqual } from 'util'
 
 import pFilter from 'p-filter'
-import pathExists from 'path-exists'
+import { pathExists } from 'path-exists'
 
 import { resolveUpdatedConfig } from '../core/config.js'
 import { addErrorInfo } from '../error/info.js'

package/src/utils/package.js

@@ -1,6 +1,6 @@
 import { dirname } from 'path'
 
-import readPkgUp from 'read-pkg-up'
+import { readPackageUp } from 'read-pkg-up'
 
 // Retrieve `package.json` from a specific directory
 export const getPackageJson = async function (cwd, { normalize } = {}) {
@@ -16,7 +16,7 @@ export const getPackageJson = async function (cwd, { normalize } = {}) {
 
 const getPackageObj = async function ({ cwd, normalize = true }) {
   try {
-    return await readPkgUp({ cwd, normalize })
+    return await readPackageUp({ cwd, normalize })
     // If the `package.json` is invalid and `normalize` is `true`, an error is
     // thrown. We return `undefined` then.
   } catch {}

package/types/netlify_plugin_constants.d.ts

@@ -13,6 +13,11 @@ export interface NetlifyPluginConstants {
    * `undefined` if no `netlify/functions` directory exists in the base directory and if not specified by the user.
    */
   FUNCTIONS_SRC?: string
+  /**
+   * the directory where internal Edge Handlers source code lives. This is where build plugins should place auto-generated handlers.
+   * `undefined` if the version of @netlify/build does not support internal Edge Handlers
+   */
+  INTERNAL_EDGE_HANDLERS_SRC?: string
   /**
    * the directory where internal function source code lives. This is where build plugins should place auto-generated functions.
    * `undefined` if the version of @netlify/build does not support internal functions
@@ -22,6 +27,10 @@ export interface NetlifyPluginConstants {
    * the directory where built serverless functions are placed before deployment. Its value is always defined, but the target might not have been created yet.
    */
   FUNCTIONS_DIST: string
+  /**
+   * the directory where built Edge Handlers are placed before deployment. Its value is always defined, but the target might not have been created yet.
+   */
+  EDGE_HANDLERS_DIST: string
   /**
    * the directory where Edge Handlers source code lives.
    * `undefined` if no `netlify/edge-handlers` directory exists in the base directory and if not specified in `netlify.toml`.