@netlify/edge-bundler 8.13.0 → 8.13.2

package/deno/lib/common.ts

@@ -1,6 +1,6 @@
-import { load } from "https://deno.land/x/eszip@v0.37.0/loader.ts";
-import { LoadResponse } from "https://deno.land/x/eszip@v0.37.0/mod.ts";
-import * as path from "https://deno.land/std@0.178.0/path/mod.ts";
+import { load } from "https://deno.land/x/eszip@v0.40.0/loader.ts";
+import { LoadResponse } from "https://deno.land/x/eszip@v0.40.0/mod.ts";
+import * as path from "https://deno.land/std@0.177.0/path/mod.ts";
 import { retryAsync } from "https://deno.land/x/retry@v2.0.0/mod.ts";
 import { isTooManyTries } from "https://deno.land/x/retry@v2.0.0/retry/tooManyTries.ts";
 

package/deno/lib/stage2.ts

@@ -1,6 +1,6 @@
-import { build, LoadResponse } from 'https://deno.land/x/eszip@v0.37.0/mod.ts'
+import { build, LoadResponse } from 'https://deno.land/x/eszip@v0.40.0/mod.ts'
 
-import * as path from 'https://deno.land/std@0.178.0/path/mod.ts'
+import * as path from 'https://deno.land/std@0.177.0/path/mod.ts'
 
 import type { InputFunction, WriteStage2Options } from '../../shared/stage2.ts'
 import { importMapSpecifier, virtualRoot } from '../../shared/consts.ts'

package/deno/vendor/deno.land/x/{eszip@v0.37.0 → eszip@v0.40.0}/eszip_wasm.generated.js

@@ -1,10 +1,10 @@
 // @generated file from wasmbuild -- do not edit
 // deno-lint-ignore-file
 // deno-fmt-ignore-file
-// source-hash: 89edd81d716c7387c15968a0de6fbb8736997e92
+// source-hash: bd411f63844f927a64e51f4af9e1e9b07bb6f88b
 let wasm;
 
-const heap = new Array(32).fill(undefined);
+const heap = new Array(128).fill(undefined);
 
 heap.push(undefined, null, true, false);
 
@@ -16,19 +16,19 @@ function isLikeNone(x) {
   return x === undefined || x === null;
 }
 
-let cachedFloat64Memory0 = new Float64Array();
+let cachedFloat64Memory0 = null;
 
 function getFloat64Memory0() {
-  if (cachedFloat64Memory0.byteLength === 0) {
+  if (cachedFloat64Memory0 === null || cachedFloat64Memory0.byteLength === 0) {
     cachedFloat64Memory0 = new Float64Array(wasm.memory.buffer);
   }
   return cachedFloat64Memory0;
 }
 
-let cachedInt32Memory0 = new Int32Array();
+let cachedInt32Memory0 = null;
 
 function getInt32Memory0() {
-  if (cachedInt32Memory0.byteLength === 0) {
+  if (cachedInt32Memory0 === null || cachedInt32Memory0.byteLength === 0) {
     cachedInt32Memory0 = new Int32Array(wasm.memory.buffer);
   }
   return cachedInt32Memory0;
@@ -36,10 +36,10 @@ function getInt32Memory0() {
 
 let WASM_VECTOR_LEN = 0;
 
-let cachedUint8Memory0 = new Uint8Array();
+let cachedUint8Memory0 = null;
 
 function getUint8Memory0() {
-  if (cachedUint8Memory0.byteLength === 0) {
+  if (cachedUint8Memory0 === null || cachedUint8Memory0.byteLength === 0) {
     cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer);
   }
   return cachedUint8Memory0;
@@ -111,7 +111,7 @@ function getStringFromWasm0(ptr, len) {
 }
 
 function dropObject(idx) {
-  if (idx < 36) return;
+  if (idx < 132) return;
   heap[idx] = heap_next;
   heap_next = idx;
 }
@@ -122,10 +122,12 @@ function takeObject(idx) {
   return ret;
 }
 
-let cachedBigInt64Memory0 = new BigInt64Array();
+let cachedBigInt64Memory0 = null;
 
 function getBigInt64Memory0() {
-  if (cachedBigInt64Memory0.byteLength === 0) {
+  if (
+    cachedBigInt64Memory0 === null || cachedBigInt64Memory0.byteLength === 0
+  ) {
     cachedBigInt64Memory0 = new BigInt64Array(wasm.memory.buffer);
   }
   return cachedBigInt64Memory0;
@@ -226,7 +228,7 @@ function makeMutClosure(arg0, arg1, dtor, f) {
 }
 function __wbg_adapter_40(arg0, arg1, arg2) {
   wasm
-    ._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hdb89611f6af59487(
+    ._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h9728315a111a4c15(
       arg0,
       arg1,
       addHeapObject(arg2),
@@ -263,7 +265,7 @@ function handleError(f, args) {
   }
 }
 function __wbg_adapter_98(arg0, arg1, arg2, arg3) {
-  wasm.wasm_bindgen__convert__closures__invoke2_mut__h73ff6ec860ceda5d(
+  wasm.wasm_bindgen__convert__closures__invoke2_mut__h8467648828c8f7b6(
     arg0,
     arg1,
     addHeapObject(arg2),
@@ -407,23 +409,11 @@ const imports = {
       const ret = BigInt.asUintN(64, arg0);
       return addHeapObject(ret);
     },
-    __wbg_new_1d9a920c6bfc44a8: function () {
-      const ret = new Array();
-      return addHeapObject(ret);
-    },
-    __wbindgen_string_new: function (arg0, arg1) {
-      const ret = getStringFromWasm0(arg0, arg1);
-      return addHeapObject(ret);
-    },
-    __wbg_push_740e4b286702d964: function (arg0, arg1) {
-      const ret = getObject(arg0).push(getObject(arg1));
-      return ret;
-    },
-    __wbg_length_6e3bbe7c8bd4dbd8: function (arg0) {
+    __wbg_length_e498fbc24f9c1d4f: function (arg0) {
       const ret = getObject(arg0).length;
       return ret;
     },
-    __wbg_new_8d2af00bc1e329ee: function (arg0, arg1) {
+    __wbg_new_15d3966e9981a196: function (arg0, arg1) {
       const ret = new Error(getStringFromWasm0(arg0, arg1));
       return addHeapObject(ret);
     },
@@ -431,11 +421,11 @@ const imports = {
       const ret = wasm.memory;
       return addHeapObject(ret);
     },
-    __wbg_buffer_3f3d764d4747d564: function (arg0) {
+    __wbg_buffer_cf65c07de34b9a08: function (arg0) {
       const ret = getObject(arg0).buffer;
       return addHeapObject(ret);
     },
-    __wbg_newwithbyteoffsetandlength_d9aa266703cb98be: function (
+    __wbg_newwithbyteoffsetandlength_9fb2f11355ecadf5: function (
       arg0,
       arg1,
       arg2,
@@ -443,11 +433,23 @@ const imports = {
       const ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
       return addHeapObject(ret);
     },
-    __wbg_new_8c3f0052272a457a: function (arg0) {
+    __wbg_new_537b7341ce90bb31: function (arg0) {
       const ret = new Uint8Array(getObject(arg0));
       return addHeapObject(ret);
     },
-    __wbg_String_91fba7ded13ba54c: function (arg0, arg1) {
+    __wbg_new_b525de17f44a8943: function () {
+      const ret = new Array();
+      return addHeapObject(ret);
+    },
+    __wbindgen_string_new: function (arg0, arg1) {
+      const ret = getStringFromWasm0(arg0, arg1);
+      return addHeapObject(ret);
+    },
+    __wbg_push_49c286f04dd3bf59: function (arg0, arg1) {
+      const ret = getObject(arg0).push(getObject(arg1));
+      return ret;
+    },
+    __wbg_String_88810dfeb4021902: function (arg0, arg1) {
       const ret = String(getObject(arg1));
       const ptr0 = passStringToWasm0(
         ret,
@@ -466,15 +468,15 @@ const imports = {
       const ret = new Error(getStringFromWasm0(arg0, arg1));
       return addHeapObject(ret);
     },
-    __wbg_iterator_6f9d4f28845f426c: function () {
+    __wbg_iterator_55f114446221aa5a: function () {
       const ret = Symbol.iterator;
       return addHeapObject(ret);
     },
-    __wbg_newwithlength_f5933855e4f48a19: function (arg0) {
+    __wbg_newwithlength_b56c882b57805732: function (arg0) {
       const ret = new Uint8Array(arg0 >>> 0);
       return addHeapObject(ret);
     },
-    __wbg_read_1bddf8e8af59d1d6: function (arg0, arg1) {
+    __wbg_read_43a845bca3122d77: function (arg0, arg1) {
       const ret = getObject(arg0).read(getObject(arg1));
       return addHeapObject(ret);
     },
@@ -482,7 +484,7 @@ const imports = {
       const ret = getObject(arg0).done;
       return ret;
     },
-    __wbg_toString_7be108a12ef03bc2: function (arg0) {
+    __wbg_toString_8c529acfe543ce16: function (arg0) {
       const ret = getObject(arg0).toString();
       return addHeapObject(ret);
     },
@@ -490,15 +492,15 @@ const imports = {
       const ret = getObject(arg0).value;
       return isLikeNone(ret) ? 0 : addHeapObject(ret);
     },
-    __wbg_byteLength_87a0436a74adc26c: function (arg0) {
+    __wbg_byteLength_29d6f6f493852fd4: function (arg0) {
       const ret = getObject(arg0).byteLength;
       return ret;
     },
-    __wbg_length_9e1ae1900cb0fbd5: function (arg0) {
+    __wbg_length_27a2afe8ab42b09f: function (arg0) {
       const ret = getObject(arg0).length;
       return ret;
     },
-    __wbg_call_3999bee59e9f7719: function () {
+    __wbg_call_96878afb7a8201ca: function () {
       return handleError(function (arg0, arg1, arg2, arg3) {
         const ret = getObject(arg0).call(
           getObject(arg1),
@@ -508,11 +510,11 @@ const imports = {
         return addHeapObject(ret);
       }, arguments);
     },
-    __wbg_resolve_99fe17964f31ffc0: function (arg0) {
+    __wbg_resolve_fd40f858d9db1a04: function (arg0) {
       const ret = Promise.resolve(getObject(arg0));
       return addHeapObject(ret);
     },
-    __wbg_new_9962f939219f1820: function (arg0, arg1) {
+    __wbg_new_9d3a9ce4282a18a8: function (arg0, arg1) {
       try {
         var state0 = { a: arg0, b: arg1 };
         var cb0 = (arg0, arg1) => {
@@ -559,62 +561,62 @@ const imports = {
       const ret = typeof (getObject(arg0)) === "function";
       return ret;
     },
-    __wbg_get_57245cc7d7c7619d: function (arg0, arg1) {
+    __wbg_get_27fe3dac1c4d0224: function (arg0, arg1) {
       const ret = getObject(arg0)[arg1 >>> 0];
       return addHeapObject(ret);
     },
-    __wbg_next_aaef7c8aa5e212ac: function () {
+    __wbg_next_88560ec06a094dea: function () {
       return handleError(function (arg0) {
         const ret = getObject(arg0).next();
         return addHeapObject(ret);
       }, arguments);
     },
-    __wbg_done_1b73b0672e15f234: function (arg0) {
+    __wbg_done_1ebec03bbd919843: function (arg0) {
       const ret = getObject(arg0).done;
       return ret;
     },
-    __wbg_value_1ccc36bc03462d71: function (arg0) {
+    __wbg_value_6ac8da5cc5b3efda: function (arg0) {
       const ret = getObject(arg0).value;
       return addHeapObject(ret);
     },
-    __wbg_get_765201544a2b6869: function () {
+    __wbg_get_baf4855f9a986186: function () {
       return handleError(function (arg0, arg1) {
         const ret = Reflect.get(getObject(arg0), getObject(arg1));
         return addHeapObject(ret);
       }, arguments);
     },
-    __wbg_call_97ae9d8645dc388b: function () {
+    __wbg_call_95d1ea488d03e4e8: function () {
       return handleError(function (arg0, arg1) {
         const ret = getObject(arg0).call(getObject(arg1));
         return addHeapObject(ret);
       }, arguments);
     },
-    __wbg_next_579e583d33566a86: function (arg0) {
+    __wbg_next_b7d530c04fd8b217: function (arg0) {
       const ret = getObject(arg0).next;
       return addHeapObject(ret);
     },
-    __wbg_isArray_27c46c67f498e15d: function (arg0) {
+    __wbg_isArray_39d28997bf6b96b4: function (arg0) {
       const ret = Array.isArray(getObject(arg0));
       return ret;
     },
-    __wbg_call_168da88779e35f61: function () {
+    __wbg_call_9495de66fdbe016b: function () {
       return handleError(function (arg0, arg1, arg2) {
         const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
         return addHeapObject(ret);
       }, arguments);
     },
-    __wbg_isSafeInteger_dfa0593e8d7ac35a: function (arg0) {
+    __wbg_isSafeInteger_8c4789029e885159: function (arg0) {
       const ret = Number.isSafeInteger(getObject(arg0));
       return ret;
     },
-    __wbg_set_83db9690f9353e79: function (arg0, arg1, arg2) {
+    __wbg_set_17499e8aa4003ebd: function (arg0, arg1, arg2) {
       getObject(arg0).set(getObject(arg1), arg2 >>> 0);
     },
     __wbindgen_jsval_loose_eq: function (arg0, arg1) {
       const ret = getObject(arg0) == getObject(arg1);
       return ret;
     },
-    __wbg_instanceof_Uint8Array_971eeda69eb75003: function (arg0) {
+    __wbg_instanceof_Uint8Array_01cebe79ca606cca: function (arg0) {
       let result;
       try {
         result = getObject(arg0) instanceof Uint8Array;
@@ -624,7 +626,7 @@ const imports = {
       const ret = result;
       return ret;
     },
-    __wbg_instanceof_ArrayBuffer_e5e48f4762c5610b: function (arg0) {
+    __wbg_instanceof_ArrayBuffer_a69f02ee4c4f5065: function (arg0) {
       let result;
       try {
         result = getObject(arg0) instanceof ArrayBuffer;
@@ -634,14 +636,14 @@ const imports = {
       const ret = result;
       return ret;
     },
-    __wbg_entries_65a76a413fc91037: function (arg0) {
+    __wbg_entries_4e1315b774245952: function (arg0) {
       const ret = Object.entries(getObject(arg0));
       return addHeapObject(ret);
     },
     __wbindgen_bigint_get_as_i64: function (arg0, arg1) {
       const v = getObject(arg1);
       const ret = typeof (v) === "bigint" ? v : undefined;
-      getBigInt64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? 0n : ret;
+      getBigInt64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? BigInt(0) : ret;
       getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
     },
     __wbindgen_debug_string: function (arg0, arg1) {
@@ -667,16 +669,16 @@ const imports = {
       const ret = false;
       return ret;
     },
-    __wbg_then_11f7a54d67b4bfad: function (arg0, arg1) {
+    __wbg_then_ec5db6d509eb475f: function (arg0, arg1) {
       const ret = getObject(arg0).then(getObject(arg1));
       return addHeapObject(ret);
     },
-    __wbg_then_cedad20fbbd9418a: function (arg0, arg1, arg2) {
+    __wbg_then_f753623316e2873a: function (arg0, arg1, arg2) {
       const ret = getObject(arg0).then(getObject(arg1), getObject(arg2));
       return addHeapObject(ret);
     },
-    __wbindgen_closure_wrapper7365: function (arg0, arg1, arg2) {
-      const ret = makeMutClosure(arg0, arg1, 272, __wbg_adapter_40);
+    __wbindgen_closure_wrapper7456: function (arg0, arg1, arg2) {
+      const ret = makeMutClosure(arg0, arg1, 275, __wbg_adapter_40);
       return addHeapObject(ret);
     },
   },

package/dist/node/bundler.js

@@ -70,7 +70,7 @@ const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], {
     const userFunctionsWithConfig = Object.fromEntries(await Promise.all(userConfigPromises));
     // Creating a final declarations array by combining the TOML file with the
     // deploy configuration API and the in-source configuration.
-    const declarations = mergeDeclarations(tomlDeclarations, userFunctionsWithConfig, internalFunctionsWithConfig, deployConfig.declarations);
+    const declarations = mergeDeclarations(tomlDeclarations, userFunctionsWithConfig, internalFunctionsWithConfig, deployConfig.declarations, featureFlags);
     const internalFunctionConfig = createFunctionConfig({
         internalFunctionsWithConfig,
         declarations,

package/dist/node/declaration.d.ts

@@ -1,4 +1,5 @@
 import { FunctionConfig, Path } from './config.js';
+import { FeatureFlags } from './feature_flags.js';
 interface BaseDeclaration {
     cache?: string;
     function: string;
@@ -14,6 +15,6 @@ type DeclarationWithPattern = BaseDeclaration & {
     excludedPattern?: string;
 };
 export type Declaration = DeclarationWithPath | DeclarationWithPattern;
-export declare const mergeDeclarations: (tomlDeclarations: Declaration[], userFunctionsConfig: Record<string, FunctionConfig>, internalFunctionsConfig: Record<string, FunctionConfig>, deployConfigDeclarations: Declaration[]) => Declaration[];
+export declare const mergeDeclarations: (tomlDeclarations: Declaration[], userFunctionsConfig: Record<string, FunctionConfig>, internalFunctionsConfig: Record<string, FunctionConfig>, deployConfigDeclarations: Declaration[], featureFlags?: FeatureFlags) => Declaration[];
 export declare const parsePattern: (pattern: string) => string;
 export {};

package/dist/node/declaration.js

@@ -1,14 +1,39 @@
 import regexpAST from 'regexp-tree';
-export const mergeDeclarations = (tomlDeclarations, userFunctionsConfig, internalFunctionsConfig, deployConfigDeclarations) => {
+export const mergeDeclarations = (tomlDeclarations, userFunctionsConfig, internalFunctionsConfig, deployConfigDeclarations, featureFlags = {}) => {
+    const functionsVisited = new Set();
+    let declarations = getDeclarationsFromInput(deployConfigDeclarations, internalFunctionsConfig, functionsVisited);
+    // eslint-disable-next-line unicorn/prefer-ternary
+    if (featureFlags.edge_functions_correct_order) {
+        declarations = [
+            // INTEGRATIONS
+            // 1. Declarations from the integrations deploy config
+            ...getDeclarationsFromInput(deployConfigDeclarations, internalFunctionsConfig, functionsVisited),
+            // 2. Declarations from the integrations ISC
+            ...createDeclarationsFromFunctionConfigs(internalFunctionsConfig, functionsVisited),
+            // USER
+            // 3. Declarations from the users toml config
+            ...getDeclarationsFromInput(tomlDeclarations, userFunctionsConfig, functionsVisited),
+            // 4. Declarations from the users ISC
+            ...createDeclarationsFromFunctionConfigs(userFunctionsConfig, functionsVisited),
+        ];
+    }
+    else {
+        declarations = [
+            ...getDeclarationsFromInput(tomlDeclarations, userFunctionsConfig, functionsVisited),
+            ...getDeclarationsFromInput(deployConfigDeclarations, internalFunctionsConfig, functionsVisited),
+            ...createDeclarationsFromFunctionConfigs(internalFunctionsConfig, functionsVisited),
+            ...createDeclarationsFromFunctionConfigs(userFunctionsConfig, functionsVisited),
+        ];
+    }
+    return declarations;
+};
+const getDeclarationsFromInput = (inputDeclarations, functionConfigs, functionsVisited) => {
     var _a;
     const declarations = [];
-    const functionsVisited = new Set();
-    // We start by iterating over all the declarations in the TOML file and in
-    // the deploy configuration file. For any declaration for which we also have
-    // a function configuration object, we replace the path because that object
-    // takes precedence.
-    for (const declaration of [...tomlDeclarations, ...deployConfigDeclarations]) {
-        const config = userFunctionsConfig[declaration.function] || internalFunctionsConfig[declaration.function];
+    // For any declaration for which we also have a function configuration object,
+    // we replace the path because that object takes precedence.
+    for (const declaration of inputDeclarations) {
+        const config = functionConfigs[declaration.function];
         if (!config) {
             // If no config is found, add the declaration as is.
             declarations.push(declaration);
@@ -28,10 +53,12 @@ export const mergeDeclarations = (tomlDeclarations, userFunctionsConfig, interna
         }
         functionsVisited.add(declaration.function);
     }
-    // Finally, we must create declarations for functions that are not declared
-    // in the TOML at all.
-    for (const name in { ...internalFunctionsConfig, ...userFunctionsConfig }) {
-        const { cache, path } = internalFunctionsConfig[name] || userFunctionsConfig[name];
+    return declarations;
+};
+const createDeclarationsFromFunctionConfigs = (functionConfigs, functionsVisited) => {
+    const declarations = [];
+    for (const name in functionConfigs) {
+        const { cache, path } = functionConfigs[name];
         // If we have a path specified, create a declaration for each path.
         if (!functionsVisited.has(name) && path) {
             const paths = Array.isArray(path) ? path : [path];

package/dist/node/declaration.test.js

@@ -1,22 +1,47 @@
 import { test, expect } from 'vitest';
 import { mergeDeclarations } from './declaration.js';
 const deployConfigDeclarations = [];
-test('Deploy config takes precedence over user config', () => {
+test('Ensure the order of edge functions with FF', () => {
     const deployConfigDeclarations = [
-        { function: 'framework-a', path: '/path1' },
-        { function: 'framework-b', path: '/path2' },
+        { function: 'framework-manifest-a', path: '/path1' },
+        { function: 'framework-manifest-c', path: '/path3' },
+        { function: 'framework-manifest-b', path: '/path2' },
     ];
     const tomlConfig = [
-        { function: 'user-a', path: '/path1' },
-        { function: 'user-b', path: '/path2' },
+        { function: 'user-toml-a', path: '/path1' },
+        { function: 'user-toml-c', path: '/path3' },
+        { function: 'user-toml-b', path: '/path2' },
     ];
     const userFuncConfig = {
-        'user-c': { path: ['/path1', '/path2'] },
+        'user-isc-c': { path: ['/path1', '/path2'] },
     };
     const internalFuncConfig = {
-        'framework-c': { path: ['/path1', '/path2'] },
+        'framework-isc-c': { path: ['/path1', '/path2'] },
     };
-    expect(mergeDeclarations(tomlConfig, userFuncConfig, internalFuncConfig, deployConfigDeclarations)).toMatchSnapshot();
+    expect(mergeDeclarations(tomlConfig, userFuncConfig, internalFuncConfig, deployConfigDeclarations, {
+        edge_functions_correct_order: true,
+    })).toMatchSnapshot();
+});
+test('Ensure the order of edge functions without FF', () => {
+    const deployConfigDeclarations = [
+        { function: 'framework-manifest-a', path: '/path1' },
+        { function: 'framework-manifest-c', path: '/path3' },
+        { function: 'framework-manifest-b', path: '/path2' },
+    ];
+    const tomlConfig = [
+        { function: 'user-toml-a', path: '/path1' },
+        { function: 'user-toml-c', path: '/path3' },
+        { function: 'user-toml-b', path: '/path2' },
+    ];
+    const userFuncConfig = {
+        'user-isc-c': { path: ['/path1', '/path2'] },
+    };
+    const internalFuncConfig = {
+        'framework-isc-c': { path: ['/path1', '/path2'] },
+    };
+    expect(mergeDeclarations(tomlConfig, userFuncConfig, internalFuncConfig, deployConfigDeclarations, {
+        edge_functions_correct_order: false,
+    })).toMatchSnapshot();
 });
 test('In-source config takes precedence over netlify.toml config', () => {
     const tomlConfig = [

package/dist/node/feature_flags.d.ts

@@ -1,14 +1,14 @@
 declare const defaultFlags: {
+    edge_functions_correct_order: boolean;
     edge_functions_fail_unsupported_regex: boolean;
     edge_functions_invalid_config_throw: boolean;
-    edge_functions_manifest_validate_slash: boolean;
 };
 type FeatureFlag = keyof typeof defaultFlags;
 type FeatureFlags = Partial<Record<FeatureFlag, boolean>>;
 declare const getFlags: (input?: Record<string, boolean>, flags?: {
+    edge_functions_correct_order: boolean;
     edge_functions_fail_unsupported_regex: boolean;
     edge_functions_invalid_config_throw: boolean;
-    edge_functions_manifest_validate_slash: boolean;
 }) => FeatureFlags;
 export { defaultFlags, getFlags };
 export type { FeatureFlag, FeatureFlags };

package/dist/node/feature_flags.js

@@ -1,7 +1,7 @@
 const defaultFlags = {
+    edge_functions_correct_order: false,
     edge_functions_fail_unsupported_regex: false,
     edge_functions_invalid_config_throw: false,
-    edge_functions_manifest_validate_slash: false,
 };
 const getFlags = (input = {}, flags = defaultFlags) => Object.entries(flags).reduce((result, [key, defaultValue]) => ({
     ...result,

package/dist/node/finder.d.ts

@@ -1,3 +1,4 @@
 import { EdgeFunction } from './edge_function.js';
+export declare const removeDuplicatesByExtension: (functions: string[]) => string[];
 declare const findFunctions: (directories: string[]) => Promise<EdgeFunction[]>;
 export { findFunctions };

package/dist/node/finder.js

@@ -1,12 +1,24 @@
 import { promises as fs } from 'fs';
-import { basename, extname, join } from 'path';
+import { basename, extname, join, parse } from 'path';
 import { nonNullable } from './utils/non_nullable.js';
-const ALLOWED_EXTENSIONS = new Set(['.js', '.jsx', '.ts', '.tsx']);
+// the order of the allowed extensions is also the order we remove duplicates
+// with a lower index meaning a higher precedence over the others
+const ALLOWED_EXTENSIONS = ['.js', '.jsx', '.ts', '.tsx'];
+export const removeDuplicatesByExtension = (functions) => {
+    const seen = new Map();
+    return Object.values(functions.reduce((acc, path) => {
+        const { ext, name } = parse(path);
+        const extIndex = ALLOWED_EXTENSIONS.indexOf(ext);
+        if (!seen.has(name) || seen.get(name) > extIndex) {
+            seen.set(name, extIndex);
+            return { ...acc, [name]: path };
+        }
+        return acc;
+    }, {}));
+};
 const findFunctionInDirectory = async (directory) => {
     const name = basename(directory);
-    const candidatePaths = [...ALLOWED_EXTENSIONS]
-        .flatMap((extension) => [`${name}${extension}`, `index${extension}`])
-        .map((filename) => join(directory, filename));
+    const candidatePaths = ALLOWED_EXTENSIONS.flatMap((extension) => [`${name}${extension}`, `index${extension}`]).map((filename) => join(directory, filename));
     let functionPath;
     for (const candidatePath of candidatePaths) {
         try {
@@ -35,14 +47,14 @@ const findFunctionInPath = async (path) => {
         return findFunctionInDirectory(path);
     }
     const extension = extname(path);
-    if (ALLOWED_EXTENSIONS.has(extension)) {
+    if (ALLOWED_EXTENSIONS.includes(extension)) {
         return { name: basename(path, extension), path };
     }
 };
 const findFunctionsInDirectory = async (baseDirectory) => {
     let items = [];
     try {
-        items = await fs.readdir(baseDirectory);
+        items = await fs.readdir(baseDirectory).then(removeDuplicatesByExtension);
     }
     catch {
         // no-op

package/dist/node/finder.test.d.ts

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

package/dist/node/finder.test.js

@@ -0,0 +1,17 @@
+import { test, expect } from 'vitest';
+import { removeDuplicatesByExtension } from './finder.js';
+test('filters out any duplicate files based on the extension', () => {
+    const functions = [
+        'file1.js',
+        'file1.ts',
+        'file2.tsx',
+        'file2.jsx',
+        'file3.tsx',
+        'file3.js',
+        'file4.ts',
+        'file5.ts',
+        'file5.tsx',
+    ];
+    const expected = ['file1.js', 'file2.jsx', 'file3.js', 'file4.ts', 'file5.ts'];
+    expect(removeDuplicatesByExtension(functions)).toStrictEqual(expected);
+});

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

@@ -1,4 +1,4 @@
 import { FeatureFlags } from '../../feature_flags.js';
 import ManifestValidationError from './error.js';
-export declare const validateManifest: (manifestData: unknown, featureFlags?: FeatureFlags) => void;
+export declare const validateManifest: (manifestData: unknown, _featureFlags?: FeatureFlags) => void;
 export { ManifestValidationError };

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

@@ -4,13 +4,13 @@ import betterAjvErrors from 'better-ajv-errors';
 import ManifestValidationError from './error.js';
 import edgeManifestSchema from './schema.js';
 let manifestValidator;
-const initializeValidator = (featureFlags) => {
+const initializeValidator = () => {
     if (manifestValidator === undefined) {
         const ajv = new Ajv({ allErrors: true });
         ajvErrors(ajv);
         // regex pattern for manifest route pattern
         // checks if the pattern string starts with ^ and ends with $
-        const normalizedPatternRegex = featureFlags.edge_functions_manifest_validate_slash ? /^\^\/.*\$$/ : /^\^.*\$$/;
+        const normalizedPatternRegex = /^\^.*\$$/;
         ajv.addFormat('regexPattern', {
             validate: (data) => normalizedPatternRegex.test(data),
         });
@@ -19,8 +19,9 @@ const initializeValidator = (featureFlags) => {
     return manifestValidator;
 };
 // throws on validation error
-export const validateManifest = (manifestData, featureFlags = {}) => {
-    const validate = initializeValidator(featureFlags);
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export const validateManifest = (manifestData, _featureFlags = {}) => {
+    const validate = initializeValidator();
     const valid = validate(manifestData);
     if (!valid) {
         let errorOutput;

package/dist/node/validation/manifest/index.test.js

@@ -1,5 +1,5 @@
 import chalk from 'chalk';
-import { test, expect, describe, beforeEach, vi } from 'vitest';
+import { test, expect, describe } from 'vitest';
 import { validateManifest, ManifestValidationError } from './index.js';
 // We need to disable all color outputs for the tests as they are different on different platforms, CI, etc.
 // This only works if this is the same instance of chalk that better-ajv-errors uses
@@ -92,42 +92,25 @@ describe('bundle', () => {
     });
 });
 describe('route', () => {
-    let freshValidateManifest;
-    beforeEach(async () => {
-        // reset all modules, to get a fresh AJV validator for FF changes
-        vi.resetModules();
-        const indexImport = await import('./index.js');
-        freshValidateManifest = indexImport.validateManifest;
-    });
     test('should throw on additional property', () => {
         const manifest = getBaseManifest();
         manifest.routes[0].foo = 'bar';
-        expect(() => freshValidateManifest(manifest)).toThrowErrorMatchingSnapshot();
+        expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
     });
     test('should throw on invalid pattern', () => {
         const manifest = getBaseManifest();
         manifest.routes[0].pattern = '/^/hello/?$/';
-        expect(() => freshValidateManifest(manifest)).toThrowErrorMatchingSnapshot();
-    });
-    test('should not throw on missing beginning slash without FF', () => {
-        const manifest = getBaseManifest();
-        manifest.routes[0].pattern = '^hello/?$';
-        expect(() => freshValidateManifest(manifest, { edge_functions_manifest_validate_slash: false })).not.toThrowError();
-    });
-    test('should throw on missing beginning slash with FF', () => {
-        const manifest = getBaseManifest();
-        manifest.routes[0].pattern = '^hello/?$';
-        expect(() => freshValidateManifest(manifest, { edge_functions_manifest_validate_slash: true })).toThrowErrorMatchingSnapshot();
+        expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
     });
     test('should throw on missing function', () => {
         const manifest = getBaseManifest();
         delete manifest.routes[0].function;
-        expect(() => freshValidateManifest(manifest)).toThrowErrorMatchingSnapshot();
+        expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
     });
     test('should throw on missing pattern', () => {
         const manifest = getBaseManifest();
         delete manifest.routes[0].pattern;
-        expect(() => freshValidateManifest(manifest)).toThrowErrorMatchingSnapshot();
+        expect(() => validateManifest(manifest)).toThrowErrorMatchingSnapshot();
     });
 });
 // No tests for post_cache_routes as schema shared with routes

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

@@ -16,7 +16,7 @@ const routesSchema = {
         pattern: {
             type: 'string',
             format: 'regexPattern',
-            errorMessage: 'pattern needs to be a regex that starts with ^ followed by / and ends with $ without any additional slashes before and afterwards',
+            errorMessage: 'pattern must be a regex that starts with ^ and ends with $ (e.g. ^/blog/[d]{4}$)',
         },
         generator: { type: 'string' },
     },
@@ -31,7 +31,7 @@ const functionConfigSchema = {
             items: {
                 type: 'string',
                 format: 'regexPattern',
-                errorMessage: 'excluded_patterns needs to be an array of regex that starts with ^ followed by / and ends with $ without any additional slashes before and afterwards',
+                errorMessage: 'excluded_patterns must be an array of regex that starts with ^ and ends with $ (e.g. ^/blog/[d]{4}$)',
             },
         },
         on_error: { type: 'string' },

package/dist/test/util.js

@@ -42,7 +42,7 @@ const runESZIP = async (eszipPath) => {
     const extractCommand = execa('deno', [
         'run',
         '--allow-all',
-        'https://deno.land/x/eszip@v0.37.0/eszip.ts',
+        'https://deno.land/x/eszip@v0.40.0/eszip.ts',
         'x',
         eszipPath,
         tmpDir.path,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "8.13.0",
+  "version": "8.13.2",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",
@@ -58,7 +58,7 @@
     "@types/node": "^14.18.32",
     "@types/semver": "^7.3.9",
     "@types/uuid": "^9.0.0",
-    "@vitest/coverage-c8": "^0.29.7",
+    "@vitest/coverage-c8": "^0.30.0",
     "archiver": "^5.3.1",
     "chalk": "^4.1.2",
     "cpy": "^9.0.1",
@@ -66,8 +66,8 @@
     "husky": "^8.0.0",
     "nock": "^13.2.4",
     "tar": "^6.1.11",
-    "typescript": "^4.5.4",
-    "vitest": "^0.29.7"
+    "typescript": "^5.0.0",
+    "vitest": "^0.30.0"
   },
   "engines": {
     "node": "^14.16.0 || >=16.0.0"