@netlify/edge-bundler 8.14.1 → 8.15.0

package/dist/node/bridge.test.js

@@ -53,7 +53,7 @@ test('Does not inherit environment variables if `extendEnv` is false', async ()
     });
     output = output.trim().replace(/\n+/g, '\n');
     expect(output).toBe('LULU=LALA');
-    await rm(tmpDir.path, { force: true, recursive: true });
+    await rm(tmpDir.path, { force: true, recursive: true, maxRetries: 10 });
 });
 test('Does inherit environment variables if `extendEnv` is true', async () => {
     var _a;
@@ -78,7 +78,7 @@ test('Does inherit environment variables if `extendEnv` is true', async () => {
     // lets remove holes, split lines and sort lines by name, as different OSes might order them different
     const environmentVariables = output.trim().replace(/\n+/g, '\n').split('\n').sort();
     expect(environmentVariables).toEqual(['LULU=LALA', 'TADA=TUDU']);
-    await rm(tmpDir.path, { force: true, recursive: true });
+    await rm(tmpDir.path, { force: true, recursive: true, maxRetries: 10 });
 });
 test('Does inherit environment variables if `extendEnv` is not set', async () => {
     var _a;
@@ -103,5 +103,5 @@ test('Does inherit environment variables if `extendEnv` is not set', async () =>
     // lets remove holes, split lines and sort lines by name, as different OSes might order them different
     const environmentVariables = output.trim().replace(/\n+/g, '\n').split('\n').sort();
     expect(environmentVariables).toEqual(['LULU=LALA', 'TADA=TUDU']);
-    await rm(tmpDir.path, { force: true, recursive: true });
+    await rm(tmpDir.path, { force: true, recursive: true, maxRetries: 10 });
 });

package/dist/node/bundler.test.js

@@ -1,8 +1,7 @@
-import { promises as fs } from 'fs';
+import { access, readdir, readFile, rm, writeFile } from 'fs/promises';
 import { join, resolve } from 'path';
 import process from 'process';
 import { pathToFileURL } from 'url';
-import { deleteAsync } from 'del';
 import tmp from 'tmp-promise';
 import { test, expect, vi } from 'vitest';
 import { importMapSpecifier } from '../shared/consts.js';
@@ -26,10 +25,10 @@ test('Produces an ESZIP bundle', async () => {
         configPath: join(internalDirectory, 'config.json'),
         importMapPaths: [join(userDirectory, 'import_map.json')],
     });
-    const generatedFiles = await fs.readdir(distPath);
+    const generatedFiles = await readdir(distPath);
     expect(result.functions.length).toBe(3);
     expect(generatedFiles.length).toBe(2);
-    const manifestFile = await fs.readFile(resolve(distPath, 'manifest.json'), 'utf8');
+    const manifestFile = await readFile(resolve(distPath, 'manifest.json'), 'utf8');
     const manifest = JSON.parse(manifestFile);
     expect(() => validateManifest(manifest)).not.toThrowError();
     const { bundles, import_map: importMapURL } = manifest;
@@ -57,10 +56,10 @@ test('Uses the vendored eszip module instead of fetching it from deno.land', asy
         basePath,
         configPath: join(sourceDirectory, 'config.json'),
     });
-    const generatedFiles = await fs.readdir(distPath);
+    const generatedFiles = await readdir(distPath);
     expect(result.functions.length).toBe(1);
     expect(generatedFiles.length).toBe(2);
-    const manifestFile = await fs.readFile(resolve(distPath, 'manifest.json'), 'utf8');
+    const manifestFile = await readFile(resolve(distPath, 'manifest.json'), 'utf8');
     const manifest = JSON.parse(manifestFile);
     const { bundles } = manifest;
     expect(bundles.length).toBe(1);
@@ -164,10 +163,10 @@ test('Uses the cache directory as the `DENO_DIR` value', async () => {
         configPath: join(sourceDirectory, 'config.json'),
     };
     const result = await bundle([sourceDirectory], distPath, declarations, options);
-    const outFiles = await fs.readdir(distPath);
+    const outFiles = await readdir(distPath);
     expect(result.functions.length).toBe(1);
     expect(outFiles.length).toBe(2);
-    const denoDir = await fs.readdir(join(cacheDir.path, 'deno_dir'));
+    const denoDir = await readdir(join(cacheDir.path, 'deno_dir'));
     expect(denoDir.includes('gen')).toBe(true);
     await cleanup();
 });
@@ -184,10 +183,10 @@ test('Supports import maps with relative paths', async () => {
         basePath,
         configPath: join(sourceDirectory, 'config.json'),
     });
-    const generatedFiles = await fs.readdir(distPath);
+    const generatedFiles = await readdir(distPath);
     expect(result.functions.length).toBe(1);
     expect(generatedFiles.length).toBe(2);
-    const manifestFile = await fs.readFile(resolve(distPath, 'manifest.json'), 'utf8');
+    const manifestFile = await readFile(resolve(distPath, 'manifest.json'), 'utf8');
     const manifest = JSON.parse(manifestFile);
     const { bundles } = manifest;
     expect(bundles.length).toBe(1);
@@ -212,7 +211,7 @@ test('Ignores any user-defined `deno.json` files', async () => {
             'https://deno.land/': 'https://black.hole/',
         },
     };
-    await fs.writeFile(importMapFile.path, JSON.stringify(importMap));
+    await writeFile(importMapFile.path, JSON.stringify(importMap));
     // Deno configuration files need to be in the current working directory.
     // There's not a great way for us to set the working directory of the `deno`
     // process that we'll run, so our best bet is to write the file to whatever
@@ -222,7 +221,7 @@ test('Ignores any user-defined `deno.json` files', async () => {
         importMap: importMapFile.path,
     };
     try {
-        await fs.access(denoConfigPath);
+        await access(denoConfigPath);
         throw new Error(`The file at '${denoConfigPath} would be overwritten by this test. Please move the file to a different location and try again.'`);
     }
     catch (error) {
@@ -230,13 +229,14 @@ test('Ignores any user-defined `deno.json` files', async () => {
             throw error;
         }
     }
-    await fs.writeFile(denoConfigPath, JSON.stringify(denoConfig));
+    await writeFile(denoConfigPath, JSON.stringify(denoConfig));
     expect(() => bundle([sourceDirectory], distPath, declarations, {
         basePath,
         configPath: join(sourceDirectory, 'config.json'),
     })).not.toThrow();
     await cleanup();
-    await deleteAsync([denoConfigPath, importMapFile.path], { force: true });
+    await rm(denoConfigPath, { force: true, recursive: true, maxRetries: 10 });
+    await rm(importMapFile.path, { force: true, recursive: true, maxRetries: 10 });
 });
 test('Processes a function that imports a custom layer', async () => {
     const { basePath, cleanup, distPath } = await useFixture('with_layers');
@@ -252,10 +252,10 @@ test('Processes a function that imports a custom layer', async () => {
         basePath,
         configPath: join(sourceDirectory, 'config.json'),
     });
-    const generatedFiles = await fs.readdir(distPath);
+    const generatedFiles = await readdir(distPath);
     expect(result.functions.length).toBe(1);
     expect(generatedFiles.length).toBe(2);
-    const manifestFile = await fs.readFile(resolve(distPath, 'manifest.json'), 'utf8');
+    const manifestFile = await readFile(resolve(distPath, 'manifest.json'), 'utf8');
     const manifest = JSON.parse(manifestFile);
     const { bundles, layers } = manifest;
     expect(bundles.length).toBe(1);
@@ -278,18 +278,18 @@ test('Loads declarations and import maps from the deploy configuration and in-so
         configPath: join(basePath, '.netlify', 'edge-functions', 'manifest.json'),
         internalSrcFolder: directories[1],
     });
-    const generatedFiles = await fs.readdir(distPath);
+    const generatedFiles = await readdir(distPath);
     expect(result.functions.length).toBe(3);
     expect(generatedFiles.length).toBe(2);
-    const manifestFile = await fs.readFile(resolve(distPath, 'manifest.json'), 'utf8');
+    const manifestFile = await readFile(resolve(distPath, 'manifest.json'), 'utf8');
     const manifest = JSON.parse(manifestFile);
-    const { bundles, function_config: functionConfig } = manifest;
+    const { bundles, function_config: functionConfig, routes } = manifest;
     expect(bundles.length).toBe(1);
     expect(bundles[0].format).toBe('eszip2');
     expect(generatedFiles.includes(bundles[0].asset)).toBe(true);
     // respects excludedPath from deploy config
+    expect(routes[0].excluded_patterns).toEqual(['^/func2/skip/?$']);
     expect(functionConfig.func2).toEqual({
-        excluded_patterns: ['^/func2/skip/?$'],
         name: 'Function two',
         generator: '@netlify/fake-plugin@1.0.0',
     });
@@ -317,7 +317,7 @@ test("Ignores entries in `importMapPaths` that don't point to an existing import
             },
         },
     };
-    await fs.writeFile(importMap.path, JSON.stringify(importMapContents));
+    await writeFile(importMap.path, JSON.stringify(importMapContents));
     const nonExistingImportMapPath = join(distPath, 'some-file-that-does-not-exist.json');
     const result = await bundle([sourceDirectory], distPath, [
         {
@@ -329,7 +329,7 @@ test("Ignores entries in `importMapPaths` that don't point to an existing import
         importMapPaths: [nonExistingImportMapPath, importMap.path],
         systemLogger,
     });
-    const generatedFiles = await fs.readdir(distPath);
+    const generatedFiles = await readdir(distPath);
     expect(result.functions.length).toBe(2);
     expect(generatedFiles.length).toBe(2);
     expect(systemLogger).toHaveBeenCalledWith(`Did not find an import map file at '${nonExistingImportMapPath}'.`);

package/dist/node/config.test.js

@@ -1,7 +1,7 @@
 import { promises as fs } from 'fs';
+import { rm } from 'fs/promises';
 import { join, resolve } from 'path';
 import { pathToFileURL } from 'url';
-import { deleteAsync } from 'del';
 import tmp from 'tmp-promise';
 import { test, expect, vi, describe } from 'vitest';
 import { fixturesDir, useFixture } from '../test/util.js';
@@ -129,7 +129,7 @@ describe('`getFunctionConfig` extracts configuration properties from function fi
             expect(config).toEqual(func.expectedConfig);
             expect(logger.user).not.toHaveBeenCalled();
         }
-        await deleteAsync(tmpDir, { force: true });
+        await rm(tmpDir, { force: true, recursive: true, maxRetries: 10 });
     });
 });
 test('Loads function paths from the in-source `config` function', async () => {
@@ -160,14 +160,14 @@ test('Loads function paths from the in-source `config` function', async () => {
     expect(bundles[0].format).toBe('eszip2');
     expect(generatedFiles.includes(bundles[0].asset)).toBe(true);
     expect(routes.length).toBe(6);
-    expect(routes[0]).toEqual({ function: 'framework-func2', pattern: '^/framework-func2/?$' });
-    expect(routes[1]).toEqual({ function: 'user-func2', pattern: '^/user-func2/?$' });
-    expect(routes[2]).toEqual({ function: 'framework-func1', pattern: '^/framework-func1/?$' });
-    expect(routes[3]).toEqual({ function: 'user-func1', pattern: '^/user-func1/?$' });
-    expect(routes[4]).toEqual({ function: 'user-func3', pattern: '^/user-func3/?$' });
-    expect(routes[5]).toEqual({ function: 'user-func5', pattern: '^/user-func5/.*/?$' });
+    expect(routes[0]).toEqual({ function: 'framework-func2', pattern: '^/framework-func2/?$', excluded_patterns: [] });
+    expect(routes[1]).toEqual({ function: 'user-func2', pattern: '^/user-func2/?$', excluded_patterns: [] });
+    expect(routes[2]).toEqual({ function: 'framework-func1', pattern: '^/framework-func1/?$', excluded_patterns: [] });
+    expect(routes[3]).toEqual({ function: 'user-func1', pattern: '^/user-func1/?$', excluded_patterns: [] });
+    expect(routes[4]).toEqual({ function: 'user-func3', pattern: '^/user-func3/?$', excluded_patterns: [] });
+    expect(routes[5]).toEqual({ function: 'user-func5', pattern: '^/user-func5/.*/?$', excluded_patterns: [] });
     expect(postCacheRoutes.length).toBe(1);
-    expect(postCacheRoutes[0]).toEqual({ function: 'user-func4', pattern: '^/user-func4/?$' });
+    expect(postCacheRoutes[0]).toEqual({ function: 'user-func4', pattern: '^/user-func4/?$', excluded_patterns: [] });
     expect(Object.keys(functionConfig)).toHaveLength(1);
     expect(functionConfig['user-func5']).toEqual({
         excluded_patterns: ['^/user-func5/excluded/?$'],
@@ -196,7 +196,7 @@ test('Passes validation if default export exists and is a function', async () =>
         name: func.name,
         path,
     }, new ImportMap([importMapFile]), deno, logger)).resolves.not.toThrow();
-    await deleteAsync(tmpDir, { force: true });
+    await rm(tmpDir, { force: true, recursive: true, maxRetries: 10 });
 });
 test('Fails validation if default export is not function', async () => {
     const { path: tmpDir } = await tmp.dir();
@@ -221,7 +221,7 @@ test('Fails validation if default export is not function', async () => {
         path,
     }, new ImportMap([importMapFile]), deno, logger);
     await expect(config).rejects.toThrowError(invalidDefaultExportErr(path));
-    await deleteAsync(tmpDir, { force: true });
+    await rm(tmpDir, { force: true, recursive: true, maxRetries: 10 });
 });
 test('Fails validation if default export is not present', async () => {
     const { path: tmpDir } = await tmp.dir();
@@ -245,5 +245,5 @@ test('Fails validation if default export is not present', async () => {
         path,
     }, new ImportMap([importMapFile]), deno, logger);
     await expect(config).rejects.toThrowError(invalidDefaultExportErr(path));
-    await deleteAsync(tmpDir, { force: true });
+    await rm(tmpDir, { force: true, recursive: true, maxRetries: 10 });
 });

package/dist/node/declaration.d.ts

@@ -8,11 +8,11 @@ interface BaseDeclaration {
 }
 type DeclarationWithPath = BaseDeclaration & {
     path: Path;
-    excludedPath?: Path;
+    excludedPath?: Path | Path[];
 };
 type DeclarationWithPattern = BaseDeclaration & {
     pattern: string;
-    excludedPattern?: string;
+    excludedPattern?: string | string[];
 };
 export type Declaration = DeclarationWithPath | DeclarationWithPattern;
 export declare const mergeDeclarations: (tomlDeclarations: Declaration[], userFunctionsConfig: Record<string, FunctionConfig>, internalFunctionsConfig: Record<string, FunctionConfig>, deployConfigDeclarations: Declaration[], _featureFlags?: FeatureFlags) => Declaration[];

package/dist/node/downloader.js

@@ -42,7 +42,6 @@ const downloadVersion = async (versionRange) => {
     const version = await getLatestVersionForRange(versionRange);
     const url = getReleaseURL(version);
     const res = await fetch(url);
-    // eslint-disable-next-line no-magic-numbers
     if (res.body === null || res.status < 200 || res.status > 299) {
         throw new Error(`Download failed with status code ${res.status}`);
     }

package/dist/node/downloader.test.js

@@ -30,7 +30,7 @@ beforeEach(async (ctx) => {
     ctx.tmpDir = tmpDir.path;
 });
 afterEach(async (ctx) => {
-    await rm(ctx.tmpDir, { force: true, recursive: true });
+    await rm(ctx.tmpDir, { force: true, recursive: true, maxRetries: 10 });
 });
 test('tries downloading binary up to 4 times', async (ctx) => {
     nock.disableNetConnect();

package/dist/node/formats/javascript.js

@@ -1,15 +1,14 @@
-import { promises as fs } from 'fs';
+import { mkdir, rm, writeFile } from 'fs/promises';
 import { join } from 'path';
 import { pathToFileURL } from 'url';
-import { deleteAsync } from 'del';
 const defaultFormatExportTypeError = (name) => `The Edge Function "${name}" has failed to load. Does it have a function as the default export?`;
 const defaultFormatImportError = (name) => `There was an error with Edge Function "${name}".`;
 const generateStage2 = async ({ bootstrapURL, distDirectory, fileName, formatExportTypeError, formatImportError, functions, }) => {
-    await deleteAsync(distDirectory, { force: true });
-    await fs.mkdir(distDirectory, { recursive: true });
+    await rm(distDirectory, { force: true, recursive: true, maxRetries: 3 });
+    await mkdir(distDirectory, { recursive: true });
     const entryPoint = getLocalEntryPoint(functions, { bootstrapURL, formatExportTypeError, formatImportError });
     const stage2Path = join(distDirectory, fileName);
-    await fs.writeFile(stage2Path, entryPoint);
+    await writeFile(stage2Path, entryPoint);
     return stage2Path;
 };
 // For the local development environment, we import the user functions with

package/dist/node/main.test.js

@@ -43,5 +43,5 @@ test('Downloads the Deno CLI on demand and caches it for subsequent calls', asyn
     expect((_d = output2 === null || output2 === void 0 ? void 0 : output2.stdout) !== null && _d !== void 0 ? _d : '').toMatch(expectedOutput);
     expect(beforeDownload).toHaveBeenCalledTimes(1);
     expect(afterDownload).toHaveBeenCalledTimes(1);
-    await rm(tmpDir.path, { force: true, recursive: true });
+    await rm(tmpDir.path, { force: true, recursive: true, maxRetries: 10 });
 });

package/dist/node/manifest.d.ts

@@ -7,6 +7,7 @@ import { Layer } from './layer.js';
 interface Route {
     function: string;
     pattern: string;
+    excluded_patterns: string[];
 }
 interface EdgeFunctionConfig {
     excluded_patterns: string[];

package/dist/node/manifest.js

@@ -58,14 +58,12 @@ const generateManifest = ({ bundles = [], declarations = [], featureFlags, funct
             return;
         }
         const pattern = getRegularExpression(declaration, featureFlags === null || featureFlags === void 0 ? void 0 : featureFlags.edge_functions_fail_unsupported_regex);
+        const excludedPattern = getExcludedRegularExpressions(declaration, featureFlags === null || featureFlags === void 0 ? void 0 : featureFlags.edge_functions_fail_unsupported_regex);
         const route = {
             function: func.name,
             pattern: serializePattern(pattern),
+            excluded_patterns: excludedPattern.map(serializePattern),
         };
-        const excludedPattern = getExcludedRegularExpression(declaration, featureFlags === null || featureFlags === void 0 ? void 0 : featureFlags.edge_functions_fail_unsupported_regex);
-        if (excludedPattern) {
-            manifestFunctionConfig[func.name].excluded_patterns.push(serializePattern(excludedPattern));
-        }
         if (declaration.cache === "manual" /* Cache.Manual */) {
             postCacheRoutes.push(route);
         }
@@ -114,23 +112,29 @@ const getRegularExpression = (declaration, failUnsupportedRegex = false) => {
     }
     return pathToRegularExpression(declaration.path);
 };
-const getExcludedRegularExpression = (declaration, failUnsupportedRegex = false) => {
+const getExcludedRegularExpressions = (declaration, failUnsupportedRegex = false) => {
     if ('excludedPattern' in declaration && declaration.excludedPattern) {
-        try {
-            return parsePattern(declaration.excludedPattern);
-        }
-        catch (error) {
-            // eslint-disable-next-line max-depth
-            if (failUnsupportedRegex) {
-                throw new Error(`Could not parse path declaration of function '${declaration.function}': ${error.message}`);
+        const excludedPatterns = Array.isArray(declaration.excludedPattern)
+            ? declaration.excludedPattern
+            : [declaration.excludedPattern];
+        return excludedPatterns.map((excludedPattern) => {
+            try {
+                return parsePattern(excludedPattern);
             }
-            console.warn(`Function '${declaration.function}' uses an unsupported regular expression and will therefore not be invoked: ${error.message}`);
-            return declaration.excludedPattern;
-        }
+            catch (error) {
+                if (failUnsupportedRegex) {
+                    throw new Error(`Could not parse path declaration of function '${declaration.function}': ${error.message}`);
+                }
+                console.warn(`Function '${declaration.function}' uses an unsupported regular expression and will therefore not be invoked: ${error.message}`);
+                return excludedPattern;
+            }
+        });
     }
     if ('path' in declaration && declaration.excludedPath) {
-        return pathToRegularExpression(declaration.excludedPath);
+        const paths = Array.isArray(declaration.excludedPath) ? declaration.excludedPath : [declaration.excludedPath];
+        return paths.map(pathToRegularExpression);
     }
+    return [];
 };
 const writeManifest = async ({ distDirectory, ...rest }) => {
     const manifest = generateManifest(rest);

package/dist/node/manifest.test.js

@@ -21,7 +21,7 @@ test('Generates a manifest with different bundles', () => {
         { asset: bundle1.hash + bundle1.extension, format: bundle1.format },
         { asset: bundle2.hash + bundle2.extension, format: bundle2.format },
     ];
-    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1/?$' }];
+    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1/?$', excluded_patterns: [] }];
     expect(manifest.bundles).toEqual(expectedBundles);
     expect(manifest.routes).toEqual(expectedRoutes);
     expect(manifest.bundler_version).toBe(env.npm_package_version);
@@ -35,7 +35,7 @@ test('Generates a manifest with display names', () => {
         },
     };
     const manifest = generateManifest({ bundles: [], declarations, functions, internalFunctionConfig });
-    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1/.*/?$' }];
+    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1/.*/?$', excluded_patterns: [] }];
     expect(manifest.function_config).toEqual({
         'func-1': { name: 'Display Name' },
     });
@@ -51,7 +51,7 @@ test('Generates a manifest with a generator field', () => {
         },
     };
     const manifest = generateManifest({ bundles: [], declarations, functions, internalFunctionConfig });
-    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1/.*/?$' }];
+    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1/.*/?$', excluded_patterns: [] }];
     const expectedFunctionConfig = { 'func-1': { generator: '@netlify/fake-plugin@1.0.0' } };
     expect(manifest.routes).toEqual(expectedRoutes);
     expect(manifest.function_config).toEqual(expectedFunctionConfig);
@@ -65,21 +65,17 @@ test('Generates a manifest with excluded paths and patterns', () => {
     ];
     const declarations = [
         { function: 'func-1', path: '/f1/*', excludedPath: '/f1/exclude' },
-        { function: 'func-2', pattern: '^/f2/.*/?$', excludedPattern: '^/f2/exclude$' },
+        { function: 'func-2', pattern: '^/f2/.*/?$', excludedPattern: ['^/f2/exclude$', '^/f2/exclude-as-well$'] },
         { function: 'func-3', path: '/*', excludedPath: '/**/*.html' },
     ];
     const manifest = generateManifest({ bundles: [], declarations, functions });
     const expectedRoutes = [
-        { function: 'func-1', pattern: '^/f1/.*/?$' },
-        { function: 'func-2', pattern: '^/f2/.*/?$' },
-        { function: 'func-3', pattern: '^/.*/?$' },
+        { function: 'func-1', pattern: '^/f1/.*/?$', excluded_patterns: ['^/f1/exclude/?$'] },
+        { function: 'func-2', pattern: '^/f2/.*/?$', excluded_patterns: ['^/f2/exclude$', '^/f2/exclude-as-well$'] },
+        { function: 'func-3', pattern: '^/.*/?$', excluded_patterns: ['^/.*/.*\\.html/?$'] },
     ];
     expect(manifest.routes).toEqual(expectedRoutes);
-    expect(manifest.function_config).toEqual({
-        'func-1': { excluded_patterns: ['^/f1/exclude/?$'] },
-        'func-2': { excluded_patterns: ['^/f2/exclude$'] },
-        'func-3': { excluded_patterns: ['^/.*/.*\\.html/?$'] },
-    });
+    expect(manifest.function_config).toEqual({});
     expect(manifest.bundler_version).toBe(env.npm_package_version);
     const matcher = getRouteMatcher(manifest);
     expect((_a = matcher('/f1/hello')) === null || _a === void 0 ? void 0 : _a.function).toBe('func-1');
@@ -92,7 +88,7 @@ test('TOML-defined paths can be combined with ISC-defined excluded paths', () =>
         'func-1': { excludedPath: '/f1/exclude' },
     };
     const manifest = generateManifest({ bundles: [], declarations, functions, userFunctionConfig });
-    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1/.*/?$' }];
+    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1/.*/?$', excluded_patterns: [] }];
     expect(manifest.routes).toEqual(expectedRoutes);
     expect(manifest.function_config).toEqual({
         'func-1': { excluded_patterns: ['^/f1/exclude/?$'] },
@@ -149,6 +145,49 @@ test('Filters out internal in-source configurations in user created functions',
         },
     });
 });
+test('excludedPath from ISC goes into function_config, TOML goes into routes', () => {
+    const functions = [{ name: 'customisation', path: '/path/to/customisation.ts' }];
+    const declarations = [
+        { function: 'customisation', path: '/showcases/*' },
+        { function: 'customisation', path: '/checkout/*', excludedPath: ['/*/terms-and-conditions'] },
+    ];
+    const userFunctionConfig = {
+        customisation: {
+            excludedPath: ['/*.css', '/*.jpg'],
+        },
+    };
+    const internalFunctionConfig = {};
+    const manifest = generateManifest({
+        bundles: [],
+        declarations,
+        functions,
+        userFunctionConfig,
+        internalFunctionConfig,
+    });
+    expect(manifest.routes).toEqual([
+        {
+            function: 'customisation',
+            pattern: '^/showcases/.*/?$',
+            excluded_patterns: [],
+        },
+        {
+            function: 'customisation',
+            pattern: '^/checkout/.*/?$',
+            excluded_patterns: ['^/.*/terms-and-conditions/?$'],
+        },
+    ]);
+    expect(manifest.function_config).toEqual({
+        customisation: {
+            excluded_patterns: ['^/.*\\.css/?$', '^/.*\\.jpg/?$'],
+        },
+    });
+    const matcher = getRouteMatcher(manifest);
+    expect(matcher('/showcases/boho-style')).toBeDefined();
+    expect(matcher('/checkout/address')).toBeDefined();
+    expect(matcher('/checkout/terms-and-conditions')).toBeUndefined();
+    expect(matcher('/checkout/scrooge-mc-duck-animation.css')).toBeUndefined();
+    expect(matcher('/showcases/boho-style/expensive-chair.jpg')).toBeUndefined();
+});
 test('Includes failure modes in manifest', () => {
     const functions = [
         { name: 'func-1', path: '/path/to/func-1.ts' },
@@ -180,7 +219,7 @@ test('Excludes functions for which there are function files but no matching conf
     ];
     const declarations = [{ function: 'func-1', path: '/f1' }];
     const manifest = generateManifest({ bundles: [bundle1], declarations, functions });
-    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1/?$' }];
+    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1/?$', excluded_patterns: [] }];
     expect(manifest.routes).toEqual(expectedRoutes);
 });
 test('Excludes functions for which there are config declarations but no matching function files', () => {
@@ -195,14 +234,14 @@ test('Excludes functions for which there are config declarations but no matching
         { function: 'func-2', path: '/f2' },
     ];
     const manifest = generateManifest({ bundles: [bundle1], declarations, functions });
-    const expectedRoutes = [{ function: 'func-2', pattern: '^/f2/?$' }];
+    const expectedRoutes = [{ function: 'func-2', pattern: '^/f2/?$', excluded_patterns: [] }];
     expect(manifest.routes).toEqual(expectedRoutes);
 });
 test('Generates a manifest without bundles', () => {
     const functions = [{ name: 'func-1', path: '/path/to/func-1.ts' }];
     const declarations = [{ function: 'func-1', path: '/f1' }];
     const manifest = generateManifest({ bundles: [], declarations, functions });
-    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1/?$' }];
+    const expectedRoutes = [{ function: 'func-1', pattern: '^/f1/?$', excluded_patterns: [] }];
     expect(manifest.bundles).toEqual([]);
     expect(manifest.routes).toEqual(expectedRoutes);
     expect(manifest.bundler_version).toBe(env.npm_package_version);
@@ -234,10 +273,10 @@ test('Generates a manifest with pre and post-cache routes', () => {
         { asset: bundle2.hash + bundle2.extension, format: bundle2.format },
     ];
     const expectedPreCacheRoutes = [
-        { function: 'func-1', name: undefined, pattern: '^/f1/?$' },
-        { function: 'func-2', name: undefined, pattern: '^/f2/?$' },
+        { function: 'func-1', name: undefined, pattern: '^/f1/?$', excluded_patterns: [] },
+        { function: 'func-2', name: undefined, pattern: '^/f2/?$', excluded_patterns: [] },
     ];
-    const expectedPostCacheRoutes = [{ function: 'func-3', name: undefined, pattern: '^/f3/?$' }];
+    const expectedPostCacheRoutes = [{ function: 'func-3', name: undefined, pattern: '^/f3/?$', excluded_patterns: [] }];
     expect(manifest.bundles).toEqual(expectedBundles);
     expect(manifest.routes).toEqual(expectedPreCacheRoutes);
     expect(manifest.post_cache_routes).toEqual(expectedPostCacheRoutes);
@@ -253,8 +292,8 @@ test('Generates a manifest with layers', () => {
         { function: 'func-2', path: '/f2/*' },
     ];
     const expectedRoutes = [
-        { function: 'func-1', pattern: '^/f1/.*/?$' },
-        { function: 'func-2', pattern: '^/f2/.*/?$' },
+        { function: 'func-1', pattern: '^/f1/.*/?$', excluded_patterns: [] },
+        { function: 'func-2', pattern: '^/f2/.*/?$', excluded_patterns: [] },
     ];
     const layers = [
         {
@@ -281,7 +320,7 @@ test('Shows a warning if the regular expression contains a negative lookahead',
         functions,
     });
     console.warn = consoleWarn;
-    expect(manifest.routes).toEqual([{ function: 'func-1', pattern: '^/\\w+(?=\\d)$' }]);
+    expect(manifest.routes).toEqual([{ function: 'func-1', pattern: '^/\\w+(?=\\d)$', excluded_patterns: [] }]);
     expect(mockConsoleWarn).toHaveBeenCalledOnce();
     expect(mockConsoleWarn).toHaveBeenCalledWith("Function 'func-1' uses an unsupported regular expression and will not be invoked: Regular expressions with lookaheads are not supported");
 });
@@ -299,5 +338,5 @@ test('Converts named capture groups to unnamed capture groups in regular express
     const functions = [{ name: 'func-1', path: '/path/to/func-1.ts' }];
     const declarations = [{ function: 'func-1', pattern: '^/(?<name>\\w+)$' }];
     const manifest = generateManifest({ bundles: [], declarations, functions });
-    expect(manifest.routes).toEqual([{ function: 'func-1', pattern: '^/(\\w+)$' }]);
+    expect(manifest.routes).toEqual([{ function: 'func-1', pattern: '^/(\\w+)$', excluded_patterns: [] }]);
 });

package/dist/node/stage_2.test.js

@@ -1,7 +1,6 @@
-import { promises as fs } from 'fs';
+import { rm, writeFile } from 'fs/promises';
 import { join } from 'path';
 import { pathToFileURL } from 'url';
-import { deleteAsync } from 'del';
 import { execa } from 'execa';
 import tmp from 'tmp-promise';
 import { test, expect } from 'vitest';
@@ -23,18 +22,18 @@ test('`getLocalEntryPoint` returns a valid stage 2 file for local development',
   `;
     const printerPath = join(tmpDir, 'printer.mjs');
     const bootstrapURL = pathToFileURL(printerPath).toString();
-    await fs.writeFile(printerPath, printer);
+    await writeFile(printerPath, printer);
     const functions = [
         { name: 'func1', path: join(tmpDir, 'func1.mjs'), response: 'Hello from function 1' },
         { name: 'func2', path: join(tmpDir, 'func2.mjs'), response: 'Hello from function 2' },
     ];
     for (const func of functions) {
         const contents = `export default () => ${JSON.stringify(func.response)}`;
-        await fs.writeFile(func.path, contents);
+        await writeFile(func.path, contents);
     }
     const stage2 = getLocalEntryPoint(functions.map(({ name, path }) => ({ name, path })), { bootstrapURL });
     const stage2Path = join(tmpDir, 'stage2.mjs');
-    await fs.writeFile(stage2Path, stage2);
+    await writeFile(stage2Path, stage2);
     const { stdout, stderr } = await execa('deno', ['run', '--allow-all', stage2Path]);
     expect(stderr).toBe('');
     const { metadata, responses } = JSON.parse(stdout);
@@ -42,5 +41,5 @@ test('`getLocalEntryPoint` returns a valid stage 2 file for local development',
         expect(responses[func.name]).toBe(func.response);
         expect(metadata.functions[func.name].url).toBe(pathToFileURL(func.path).toString());
     }
-    await deleteAsync(tmpDir, { force: true });
+    await rm(tmpDir, { force: true, recursive: true });
 });

package/dist/node/types.test.js

@@ -24,7 +24,7 @@ test('`ensureLatestTypes` updates the Deno CLI cache if the local version of typ
     expect(mock).toHaveBeenCalledWith(['cache', '-r', mockURL]);
     expect(versionFile).toBe(mockVersion);
     mock.mockRestore();
-    await rm(tmpDir.path, { force: true, recursive: true });
+    await rm(tmpDir.path, { force: true, recursive: true, maxRetries: 10 });
 });
 test('`ensureLatestTypes` does not update the Deno CLI cache if the local version of types is up-to-date', async () => {
     const mockURL = 'https://edge.netlify';
@@ -43,7 +43,7 @@ test('`ensureLatestTypes` does not update the Deno CLI cache if the local versio
     expect(latestVersionMock.isDone()).toBe(true);
     expect(mock).not.toHaveBeenCalled();
     mock.mockRestore();
-    await rm(tmpDir.path, { force: true, recursive: true });
+    await rm(tmpDir.path, { force: true, recursive: true, maxRetries: 10 });
 });
 test('`ensureLatestTypes` does not throw if the types URL is not available', async () => {
     const mockURL = 'https://edge.netlify';
@@ -59,5 +59,5 @@ test('`ensureLatestTypes` does not throw if the types URL is not available', asy
     expect(latestVersionMock.isDone()).toBe(true);
     expect(mock).not.toHaveBeenCalled();
     mock.mockRestore();
-    await rm(tmpDir.path, { force: true, recursive: true });
+    await rm(tmpDir.path, { force: true, recursive: true, maxRetries: 10 });
 });

package/dist/node/validation/manifest/schema.d.ts

@@ -36,6 +36,14 @@ declare const edgeManifestSchema: {
                         format: string;
                         errorMessage: string;
                     };
+                    excluded_patterns: {
+                        type: string;
+                        items: {
+                            type: string;
+                            format: string;
+                            errorMessage: string;
+                        };
+                    };
                     generator: {
                         type: string;
                     };
@@ -60,6 +68,14 @@ declare const edgeManifestSchema: {
                         format: string;
                         errorMessage: string;
                     };
+                    excluded_patterns: {
+                        type: string;
+                        items: {
+                            type: string;
+                            format: string;
+                            errorMessage: string;
+                        };
+                    };
                     generator: {
                         type: string;
                     };

package/dist/node/validation/manifest/schema.js

@@ -7,6 +7,14 @@ const bundlesSchema = {
     },
     additionalProperties: false,
 };
+const excludedPatternsSchema = {
+    type: 'array',
+    items: {
+        type: 'string',
+        format: 'regexPattern',
+        errorMessage: 'excluded_patterns must be an array of regex that starts with ^ and ends with $ (e.g. ^/blog/[d]{4}$)',
+    },
+};
 const routesSchema = {
     type: 'object',
     required: ['function', 'pattern'],
@@ -18,6 +26,7 @@ const routesSchema = {
             format: 'regexPattern',
             errorMessage: 'pattern must be a regex that starts with ^ and ends with $ (e.g. ^/blog/[d]{4}$)',
         },
+        excluded_patterns: excludedPatternsSchema,
         generator: { type: 'string' },
     },
     additionalProperties: false,
@@ -26,14 +35,7 @@ const functionConfigSchema = {
     type: 'object',
     required: [],
     properties: {
-        excluded_patterns: {
-            type: 'array',
-            items: {
-                type: 'string',
-                format: 'regexPattern',
-                errorMessage: 'excluded_patterns must be an array of regex that starts with ^ and ends with $ (e.g. ^/blog/[d]{4}$)',
-            },
-        },
+        excluded_patterns: excludedPatternsSchema,
         on_error: { type: 'string' },
     },
 };

package/dist/test/util.js

@@ -36,12 +36,16 @@ const inspectFunction = (path) => `
   console.log(JSON.stringify(responses));
 `;
 const getRouteMatcher = (manifest) => (candidate) => manifest.routes.find((route) => {
+    var _a, _b;
     const regex = new RegExp(route.pattern);
     if (!regex.test(candidate)) {
         return false;
     }
-    const excludedPattern = manifest.function_config[route.function].excluded_patterns;
-    const isExcluded = excludedPattern.some((pattern) => new RegExp(pattern).test(candidate));
+    if (route.excluded_patterns.some((pattern) => new RegExp(pattern).test(candidate))) {
+        return false;
+    }
+    const excludedPatterns = (_b = (_a = manifest.function_config[route.function]) === null || _a === void 0 ? void 0 : _a.excluded_patterns) !== null && _b !== void 0 ? _b : [];
+    const isExcluded = excludedPatterns.some((pattern) => new RegExp(pattern).test(candidate));
     return !isExcluded;
 });
 const runESZIP = async (eszipPath) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "8.14.1",
+  "version": "8.15.0",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",
@@ -78,7 +78,6 @@
     "ajv-errors": "^3.0.0",
     "better-ajv-errors": "^1.2.0",
     "common-path-prefix": "^3.0.0",
-    "del": "^7.0.0",
     "env-paths": "^3.0.0",
     "execa": "^6.0.0",
     "find-up": "^6.3.0",