@netlify/edge-bundler 8.19.1 → 9.0.0

package/deno/bundle.ts

@@ -1,10 +1,10 @@
 import { writeStage2 } from './lib/stage2.ts'
 
 const [payload] = Deno.args
-const { basePath, destPath, externals, functions, importMapData } = JSON.parse(payload)
+const { basePath, destPath, externals, functions, importMapData, vendorDirectory } = JSON.parse(payload)
 
 try {
-  await writeStage2({ basePath, destPath, externals, functions, importMapData })
+  await writeStage2({ basePath, destPath, externals, functions, importMapData, vendorDirectory })
 } catch (error) {
   if (error instanceof Error && error.message.includes("The module's source code could not be parsed")) {
     delete error.stack

package/deno/lib/stage2.ts

@@ -3,7 +3,7 @@ import { build, 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 type { InputFunction, WriteStage2Options } from '../../shared/stage2.ts'
-import { importMapSpecifier, virtualRoot } from '../../shared/consts.ts'
+import { importMapSpecifier, virtualRoot, virtualVendorRoot } from '../../shared/consts.ts'
 import { LEGACY_PUBLIC_SPECIFIER, PUBLIC_SPECIFIER, STAGE2_SPECIFIER } from './consts.ts'
 import { inlineModule, loadFromVirtualRoot, loadWithRetry } from './common.ts'
 
@@ -63,7 +63,13 @@ const getVirtualPath = (basePath: string, filePath: string) => {
   return url
 }
 
-const stage2Loader = (basePath: string, functions: InputFunction[], externals: Set<string>, importMapData?: string) => {
+const stage2Loader = (
+  basePath: string,
+  functions: InputFunction[],
+  externals: Set<string>,
+  importMapData: string | undefined,
+  vendorDirectory?: string,
+) => {
   return async (specifier: string): Promise<LoadResponse | undefined> => {
     if (specifier === STAGE2_SPECIFIER) {
       const stage2Entry = getStage2Entry(basePath, functions)
@@ -91,13 +97,24 @@ const stage2Loader = (basePath: string, functions: InputFunction[], externals: S
       return loadFromVirtualRoot(specifier, virtualRoot, basePath)
     }
 
+    if (vendorDirectory !== undefined && specifier.startsWith(virtualVendorRoot)) {
+      return loadFromVirtualRoot(specifier, virtualVendorRoot, vendorDirectory)
+    }
+
     return await loadWithRetry(specifier)
   }
 }
 
-const writeStage2 = async ({ basePath, destPath, externals, functions, importMapData }: WriteStage2Options) => {
+const writeStage2 = async ({
+  basePath,
+  destPath,
+  externals,
+  functions,
+  importMapData,
+  vendorDirectory,
+}: WriteStage2Options) => {
   const importMapURL = importMapData ? importMapSpecifier : undefined
-  const loader = stage2Loader(basePath, functions, new Set(externals), importMapData)
+  const loader = stage2Loader(basePath, functions, new Set(externals), importMapData, vendorDirectory)
   const bytes = await build([STAGE2_SPECIFIER], loader, importMapURL)
   const directory = path.dirname(destPath)
 

package/dist/node/bundler.d.ts

@@ -1,24 +1,24 @@
 import { OnAfterDownloadHook, OnBeforeDownloadHook } from './bridge.js';
 import { Declaration } from './declaration.js';
+import { EdgeFunction } from './edge_function.js';
 import { FeatureFlags } from './feature_flags.js';
 import { LogFunction } from './logger.js';
-interface BundleOptions {
+export interface BundleOptions {
     basePath?: string;
+    bootstrapURL?: string;
     cacheDirectory?: string;
     configPath?: string;
     debug?: boolean;
     distImportMapPath?: string;
     featureFlags?: FeatureFlags;
     importMapPaths?: (string | undefined)[];
+    internalSrcFolder?: string;
     onAfterDownload?: OnAfterDownloadHook;
     onBeforeDownload?: OnBeforeDownloadHook;
     systemLogger?: LogFunction;
-    internalSrcFolder?: string;
-    bootstrapURL?: string;
+    vendorDirectory?: string;
 }
-declare const bundle: (sourceDirectories: string[], distDirectory: string, tomlDeclarations?: Declaration[], { basePath: inputBasePath, cacheDirectory, configPath, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMapPaths, onAfterDownload, onBeforeDownload, systemLogger, internalSrcFolder, }?: BundleOptions) => Promise<{
-    functions: import("./edge_function.js").EdgeFunction[];
+export declare const bundle: (sourceDirectories: string[], distDirectory: string, tomlDeclarations?: Declaration[], { basePath: inputBasePath, cacheDirectory, configPath, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMapPaths, internalSrcFolder, onAfterDownload, onBeforeDownload, systemLogger, vendorDirectory, }?: BundleOptions) => Promise<{
+    functions: EdgeFunction[];
     manifest: import("./manifest.js").Manifest;
 }>;
-export { bundle };
-export type { BundleOptions };

package/dist/node/bundler.js

@@ -13,8 +13,9 @@ import { bundle as bundleESZIP } from './formats/eszip.js';
 import { ImportMap } from './import_map.js';
 import { getLogger } from './logger.js';
 import { writeManifest } from './manifest.js';
+import { vendorNPMSpecifiers } from './npm_dependencies.js';
 import { ensureLatestTypes } from './types.js';
-const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], { basePath: inputBasePath, cacheDirectory, configPath, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMapPaths = [], onAfterDownload, onBeforeDownload, systemLogger, internalSrcFolder, } = {}) => {
+export const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], { basePath: inputBasePath, cacheDirectory, configPath, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMapPaths = [], internalSrcFolder, onAfterDownload, onBeforeDownload, systemLogger, vendorDirectory, } = {}) => {
     const logger = getLogger(systemLogger, debug);
     const featureFlags = getFlags(inputFeatureFlags);
     const options = {
@@ -46,6 +47,17 @@ const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], {
     const userFunctions = userSourceDirectories.length === 0 ? [] : await findFunctions(userSourceDirectories);
     const internalFunctions = internalSrcFolder ? await findFunctions([internalSrcFolder]) : [];
     const functions = [...internalFunctions, ...userFunctions];
+    const vendor = await safelyVendorNPMSpecifiers({
+        basePath,
+        featureFlags,
+        functions,
+        importMap,
+        logger,
+        vendorDirectory,
+    });
+    if (vendor) {
+        importMap.add(vendor.importMap);
+    }
     const functionBundle = await bundleESZIP({
         basePath,
         buildID,
@@ -56,6 +68,7 @@ const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], {
         functions,
         featureFlags,
         importMap,
+        vendorDirectory: vendor === null || vendor === void 0 ? void 0 : vendor.directory,
     });
     // The final file name of the bundles contains a SHA256 hash of the contents,
     // which we can only compute now that the files have been generated. So let's
@@ -86,6 +99,7 @@ const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], {
         importMap: importMapSpecifier,
         layers: deployConfig.layers,
     });
+    await (vendor === null || vendor === void 0 ? void 0 : vendor.cleanup());
     if (distImportMapPath) {
         await importMap.writeToFile(distImportMapPath);
     }
@@ -133,4 +147,20 @@ const createFunctionConfig = ({ internalFunctionsWithConfig, declarations }) =>
         [functionName]: addGeneratorFallback(mergedConfigFields),
     };
 }, {});
-export { bundle };
+const safelyVendorNPMSpecifiers = async ({ basePath, featureFlags, functions, importMap, logger, vendorDirectory, }) => {
+    if (!featureFlags.edge_functions_npm_modules) {
+        return;
+    }
+    try {
+        return await vendorNPMSpecifiers({
+            basePath,
+            directory: vendorDirectory,
+            functions: functions.map(({ path }) => path),
+            importMap,
+            logger,
+        });
+    }
+    catch (error) {
+        logger.system(error);
+    }
+};

package/dist/node/bundler.test.js

@@ -105,7 +105,7 @@ test('Adds a custom error property to user errors during bundling', async () =>
         await cleanup();
     }
 });
-test('Prints a nice error message when user tries importing NPM module', async () => {
+test('Prints a nice error message when user tries importing an npm module and npm support is disabled', async () => {
     expect.assertions(2);
     const { basePath, cleanup, distPath } = await useFixture('imports_npm_module');
     const sourceDirectory = join(basePath, 'functions');
@@ -120,7 +120,31 @@ test('Prints a nice error message when user tries importing NPM module', async (
     }
     catch (error) {
         expect(error).toBeInstanceOf(BundleError);
-        expect(error.message).toEqual(`It seems like you're trying to import an npm module. This is only supported via CDNs like esm.sh. Have you tried 'import mod from "https://esm.sh/p-retry"'?`);
+        expect(error.message).toEqual(`It seems like you're trying to import an npm module. This is only supported via CDNs like esm.sh. Have you tried 'import mod from "https://esm.sh/parent-2"'?`);
+    }
+    finally {
+        await cleanup();
+    }
+});
+test('Prints a nice error message when user tries importing an npm module and npm support is enabled', async () => {
+    expect.assertions(2);
+    const { basePath, cleanup, distPath } = await useFixture('imports_npm_module_scheme');
+    const sourceDirectory = join(basePath, 'functions');
+    const declarations = [
+        {
+            function: 'func1',
+            path: '/func1',
+        },
+    ];
+    try {
+        await bundle([sourceDirectory], distPath, declarations, {
+            basePath,
+            featureFlags: { edge_functions_npm_modules: true },
+        });
+    }
+    catch (error) {
+        expect(error).toBeInstanceOf(BundleError);
+        expect(error.message).toEqual(`There was an error when loading the 'p-retry' npm module. Support for npm modules in edge functions is an experimental feature. Refer to https://ntl.fyi/edge-functions-npm for more information.`);
     }
     finally {
         await cleanup();
@@ -373,3 +397,27 @@ test('Handles imports with the `node:` prefix', async () => {
     expect(func1).toBe('ok');
     await cleanup();
 });
+test('Loads npm modules from bare specifiers', async () => {
+    const { basePath, cleanup, distPath } = await useFixture('imports_npm_module');
+    const sourceDirectory = join(basePath, 'functions');
+    const declarations = [
+        {
+            function: 'func1',
+            path: '/func1',
+        },
+    ];
+    const vendorDirectory = await tmp.dir();
+    await bundle([sourceDirectory], distPath, declarations, {
+        basePath,
+        featureFlags: { edge_functions_npm_modules: true },
+        importMapPaths: [join(basePath, 'import_map.json')],
+        vendorDirectory: vendorDirectory.path,
+    });
+    const manifestFile = await readFile(resolve(distPath, 'manifest.json'), 'utf8');
+    const manifest = JSON.parse(manifestFile);
+    const bundlePath = join(distPath, manifest.bundles[0].asset);
+    const { func1 } = await runESZIP(bundlePath, vendorDirectory.path);
+    expect(func1).toBe(`<parent-1><child-1>JavaScript</child-1></parent-1>, <parent-2><child-2><grandchild-1>APIs<cwd>${process.cwd()}</cwd></grandchild-1></child-2></parent-2>, <parent-3><child-2><grandchild-1>Markup<cwd>${process.cwd()}</cwd></grandchild-1></child-2></parent-3>`);
+    await cleanup();
+    await rm(vendorDirectory.path, { force: true, recursive: true });
+});

package/dist/node/feature_flags.d.ts

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

package/dist/node/feature_flags.js

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

package/dist/node/formats/eszip.d.ts

@@ -13,6 +13,7 @@ interface BundleESZIPOptions {
     featureFlags: FeatureFlags;
     functions: EdgeFunction[];
     importMap: ImportMap;
+    vendorDirectory?: string;
 }
-declare const bundleESZIP: ({ basePath, buildID, debug, deno, distDirectory, externals, functions, importMap, }: BundleESZIPOptions) => Promise<Bundle>;
+declare const bundleESZIP: ({ basePath, buildID, debug, deno, distDirectory, externals, featureFlags, functions, importMap, vendorDirectory, }: BundleESZIPOptions) => Promise<Bundle>;
 export { bundleESZIP as bundle };

package/dist/node/formats/eszip.js

@@ -1,26 +1,29 @@
 import { join } from 'path';
 import { pathToFileURL } from 'url';
-import { virtualRoot } from '../../shared/consts.js';
+import { virtualRoot, virtualVendorRoot } from '../../shared/consts.js';
 import { BundleFormat } from '../bundle.js';
 import { wrapBundleError } from '../bundle_error.js';
 import { wrapNpmImportError } from '../npm_import_error.js';
 import { getPackagePath } from '../package_json.js';
 import { getFileHash } from '../utils/sha256.js';
-const bundleESZIP = async ({ basePath, buildID, debug, deno, distDirectory, externals, functions, importMap, }) => {
+const bundleESZIP = async ({ basePath, buildID, debug, deno, distDirectory, externals, featureFlags, functions, importMap, vendorDirectory, }) => {
     const extension = '.eszip';
     const destPath = join(distDirectory, `${buildID}${extension}`);
-    const { bundler, importMap: bundlerImportMap } = getESZIPPaths();
-    // Transforming all paths under `basePath` to use the virtual root prefix.
     const importMapPrefixes = {
         [`${pathToFileURL(basePath)}/`]: virtualRoot,
     };
-    const importMapData = importMap.getContents(importMapPrefixes);
+    if (vendorDirectory !== undefined) {
+        importMapPrefixes[`${pathToFileURL(vendorDirectory)}/`] = virtualVendorRoot;
+    }
+    const { bundler, importMap: bundlerImportMap } = getESZIPPaths();
+    const importMapData = JSON.stringify(importMap.getContents(importMapPrefixes));
     const payload = {
         basePath,
         destPath,
         externals,
         functions,
-        importMapData: JSON.stringify(importMapData),
+        importMapData,
+        vendorDirectory,
     };
     const flags = ['--allow-all', '--no-config', `--import-map=${bundlerImportMap}`];
     if (!debug) {
@@ -30,7 +33,9 @@ const bundleESZIP = async ({ basePath, buildID, debug, deno, distDirectory, exte
         await deno.run(['run', ...flags, bundler, JSON.stringify(payload)], { pipeOutput: true });
     }
     catch (error) {
-        throw wrapBundleError(wrapNpmImportError(error), { format: 'eszip' });
+        throw wrapBundleError(wrapNpmImportError(error, Boolean(featureFlags.edge_functions_npm_modules)), {
+            format: 'eszip',
+        });
     }
     const hash = await getFileHash(destPath);
     return { extension, format: BundleFormat.ESZIP2, hash };

package/dist/node/import_map.d.ts

@@ -9,11 +9,14 @@ export interface ImportMapFile {
 export declare class ImportMap {
     rootPath: string | null;
     sources: ImportMapFile[];
-    constructor(sources?: ImportMapFile[], rootURL?: string | null);
+    constructor(sources?: ImportMapFile[], rootPath?: string | null);
     add(source: ImportMapFile): void;
     addFile(path: string, logger: Logger): Promise<void>;
     addFiles(paths: (string | undefined)[], logger: Logger): Promise<void>;
     static applyPrefixesToImports(imports: Imports, prefixes: Record<string, string>): Imports;
+    clone(): ImportMap;
+    static convertImportsToURLObjects(imports: Imports): Record<string, URL>;
+    static convertScopesToURLObjects(scopes: Record<string, Imports>): Record<string, Record<string, URL>>;
     static applyPrefixesToPath(path: string, prefixes: Record<string, string>): string;
     filterImports(imports?: Record<string, URL | null>): Record<string, string>;
     filterScopes(scopes?: ParsedImportMap['scopes']): Record<string, Imports>;
@@ -21,6 +24,10 @@ export declare class ImportMap {
         imports: Imports;
         scopes: {};
     };
+    getContentsWithURLObjects(prefixes?: Record<string, string>): {
+        imports: Record<string, URL>;
+        scopes: Record<string, Record<string, URL>>;
+    };
     static readFile(path: string, logger: Logger): Promise<ImportMapFile>;
     resolve(source: ImportMapFile): {
         imports: Record<string, string>;

package/dist/node/import_map.js

@@ -11,8 +11,8 @@ const INTERNAL_IMPORTS = {
 // ImportMap can take several import map files and merge them into a final
 // import map object, also adding the internal imports in the right order.
 export class ImportMap {
-    constructor(sources = [], rootURL = null) {
-        this.rootPath = rootURL ? fileURLToPath(rootURL) : null;
+    constructor(sources = [], rootPath = null) {
+        this.rootPath = rootPath;
         this.sources = [];
         sources.forEach((file) => {
             this.add(file);
@@ -44,6 +44,21 @@ export class ImportMap {
             [key]: ImportMap.applyPrefixesToPath(value, prefixes),
         }), {});
     }
+    clone() {
+        return new ImportMap(this.sources, this.rootPath);
+    }
+    static convertImportsToURLObjects(imports) {
+        return Object.entries(imports).reduce((acc, [key, value]) => ({
+            ...acc,
+            [key]: new URL(value),
+        }), {});
+    }
+    static convertScopesToURLObjects(scopes) {
+        return Object.entries(scopes).reduce((acc, [key, value]) => ({
+            ...acc,
+            [key]: ImportMap.convertImportsToURLObjects(value),
+        }), {});
+    }
     // Applies a list of prefixes to a given path, returning the replaced path.
     // For example, given a `path` of `file:///foo/bar/baz.js` and a `prefixes`
     // object with `{"file:///foo/": "file:///hello/"}`, this method will return
@@ -122,6 +137,16 @@ export class ImportMap {
             scopes: transformedScopes,
         };
     }
+    // The same as `getContents`, but the URLs are represented as URL objects
+    // instead of strings. This is compatible with the `ParsedImportMap` type
+    // from the `@import-maps/resolve` library.
+    getContentsWithURLObjects(prefixes = {}) {
+        const { imports, scopes } = this.getContents(prefixes);
+        return {
+            imports: ImportMap.convertImportsToURLObjects(imports),
+            scopes: ImportMap.convertScopesToURLObjects(scopes),
+        };
+    }
     static async readFile(path, logger) {
         const baseURL = pathToFileURL(path);
         try {

package/dist/node/import_map.test.js

@@ -20,11 +20,16 @@ test('Handles import maps with full URLs without specifying a base URL', () => {
         },
     };
     const map = new ImportMap([inputFile1, inputFile2]);
-    const { imports } = map.getContents();
-    expect(imports['netlify:edge']).toBe('https://edge.netlify.com/v1/index.ts?v=legacy');
-    expect(imports['@netlify/edge-functions']).toBe('https://edge.netlify.com/v1/index.ts');
-    expect(imports['alias:jamstack']).toBe('https://jamstack.org/');
-    expect(imports['alias:pets']).toBe('https://petsofnetlify.com/');
+    const m1 = map.getContents();
+    expect(m1.imports['netlify:edge']).toBe('https://edge.netlify.com/v1/index.ts?v=legacy');
+    expect(m1.imports['@netlify/edge-functions']).toBe('https://edge.netlify.com/v1/index.ts');
+    expect(m1.imports['alias:jamstack']).toBe('https://jamstack.org/');
+    expect(m1.imports['alias:pets']).toBe('https://petsofnetlify.com/');
+    const m2 = map.getContentsWithURLObjects();
+    expect(m2.imports['netlify:edge']).toStrictEqual(new URL('https://edge.netlify.com/v1/index.ts?v=legacy'));
+    expect(m2.imports['@netlify/edge-functions']).toStrictEqual(new URL('https://edge.netlify.com/v1/index.ts'));
+    expect(m2.imports['alias:jamstack']).toStrictEqual(new URL('https://jamstack.org/'));
+    expect(m2.imports['alias:pets']).toStrictEqual(new URL('https://petsofnetlify.com/'));
 });
 test('Resolves relative paths to absolute paths if a base path is not provided', () => {
     const basePath = join(cwd(), 'my-cool-site', 'import-map.json');
@@ -35,11 +40,15 @@ test('Resolves relative paths to absolute paths if a base path is not provided',
         },
     };
     const map = new ImportMap([inputFile1]);
-    const { imports } = map.getContents();
     const expectedPath = join(cwd(), 'my-cool-site', 'heart', 'pets');
-    expect(imports['netlify:edge']).toBe('https://edge.netlify.com/v1/index.ts?v=legacy');
-    expect(imports['@netlify/edge-functions']).toBe('https://edge.netlify.com/v1/index.ts');
-    expect(imports['alias:pets']).toBe(`${pathToFileURL(expectedPath).toString()}/`);
+    const m1 = map.getContents();
+    expect(m1.imports['netlify:edge']).toBe('https://edge.netlify.com/v1/index.ts?v=legacy');
+    expect(m1.imports['@netlify/edge-functions']).toBe('https://edge.netlify.com/v1/index.ts');
+    expect(m1.imports['alias:pets']).toBe(`${pathToFileURL(expectedPath).toString()}/`);
+    const m2 = map.getContentsWithURLObjects();
+    expect(m2.imports['netlify:edge']).toStrictEqual(new URL('https://edge.netlify.com/v1/index.ts?v=legacy'));
+    expect(m2.imports['@netlify/edge-functions']).toStrictEqual(new URL('https://edge.netlify.com/v1/index.ts'));
+    expect(m2.imports['alias:pets']).toStrictEqual(new URL(`${pathToFileURL(expectedPath).toString()}/`));
 });
 describe('Returns the fully resolved import map', () => {
     const inputFile1 = {
@@ -112,7 +121,7 @@ test('Throws when an import map uses a relative path to reference a file outside
             'alias:file': '../file.js',
         },
     };
-    const map = new ImportMap([inputFile1], pathToFileURL(cwd()).toString());
+    const map = new ImportMap([inputFile1], cwd());
     expect(() => map.getContents()).toThrowError(`Import map cannot reference '${join(cwd(), '..', 'file.js')}' as it's outside of the base directory '${cwd()}'`);
 });
 test('Writes import map file to disk', async () => {
@@ -134,3 +143,45 @@ test('Writes import map file to disk', async () => {
     expect(imports['@netlify/edge-functions']).toBe('https://edge.netlify.com/v1/index.ts');
     expect(imports['alias:pets']).toBe(pathToFileURL(expectedPath).toString());
 });
+test('Clones an import map', () => {
+    const basePath = join(cwd(), 'my-cool-site', 'import-map.json');
+    const inputFile1 = {
+        baseURL: pathToFileURL(basePath),
+        imports: {
+            'alias:jamstack': 'https://jamstack.org',
+        },
+    };
+    const inputFile2 = {
+        baseURL: pathToFileURL(basePath),
+        imports: {
+            'alias:pets': 'https://petsofnetlify.com/',
+        },
+    };
+    const map1 = new ImportMap([inputFile1, inputFile2]);
+    const map2 = map1.clone();
+    map2.add({
+        baseURL: pathToFileURL(basePath),
+        imports: {
+            netlify: 'https://netlify.com',
+        },
+    });
+    expect(map1.getContents()).toStrictEqual({
+        imports: {
+            'netlify:edge': 'https://edge.netlify.com/v1/index.ts?v=legacy',
+            '@netlify/edge-functions': 'https://edge.netlify.com/v1/index.ts',
+            'alias:jamstack': 'https://jamstack.org/',
+            'alias:pets': 'https://petsofnetlify.com/',
+        },
+        scopes: {},
+    });
+    expect(map2.getContents()).toStrictEqual({
+        imports: {
+            'netlify:edge': 'https://edge.netlify.com/v1/index.ts?v=legacy',
+            '@netlify/edge-functions': 'https://edge.netlify.com/v1/index.ts',
+            'alias:jamstack': 'https://jamstack.org/',
+            'alias:pets': 'https://petsofnetlify.com/',
+            netlify: 'https://netlify.com/',
+        },
+        scopes: {},
+    });
+});

package/dist/node/npm_dependencies.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+import { ParsedImportMap } from '@import-maps/resolve';
+import { Plugin } from 'esbuild';
+import { ImportMap } from './import_map.js';
+import { Logger } from './logger.js';
+export declare const getDependencyTrackerPlugin: (specifiers: Set<string>, importMap: ParsedImportMap, baseURL: URL) => Plugin;
+interface VendorNPMSpecifiersOptions {
+    basePath: string;
+    directory?: string;
+    functions: string[];
+    importMap: ImportMap;
+    logger: Logger;
+}
+export declare const vendorNPMSpecifiers: ({ basePath, directory, functions, importMap, logger, }: VendorNPMSpecifiersOptions) => Promise<{
+    cleanup: () => Promise<void>;
+    directory: string;
+    importMap: {
+        baseURL: import("node:url").URL;
+        imports: Record<string, string>;
+    };
+} | undefined>;
+export {};

package/dist/node/npm_dependencies.js

@@ -0,0 +1,184 @@
+import { promises as fs } from 'fs';
+import { builtinModules, createRequire } from 'module';
+import path from 'path';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { resolve } from '@import-maps/resolve';
+import { build } from 'esbuild';
+import tmp from 'tmp-promise';
+import { nodePrefix, npmPrefix } from '../shared/consts.js';
+const builtinModulesSet = new Set(builtinModules);
+const require = createRequire(import.meta.url);
+// Workaround for https://github.com/evanw/esbuild/issues/1921.
+const banner = {
+    js: `
+  import {createRequire as ___nfyCreateRequire} from "node:module";
+  import {fileURLToPath as ___nfyFileURLToPath} from "node:url";
+  import {dirname as ___nfyPathDirname} from "node:path";
+  let __filename=___nfyFileURLToPath(import.meta.url);
+  let __dirname=___nfyPathDirname(___nfyFileURLToPath(import.meta.url));
+  let require=___nfyCreateRequire(import.meta.url);
+  `,
+};
+// esbuild plugin that will traverse the code and look for imports of external
+// dependencies (i.e. Node modules). It stores the specifiers found in the Set
+// provided.
+export const getDependencyTrackerPlugin = (specifiers, importMap, baseURL) => ({
+    name: 'dependency-tracker',
+    setup(build) {
+        build.onResolve({ filter: /^(.*)$/ }, (args) => {
+            if (args.kind !== 'import-statement') {
+                return;
+            }
+            const result = {};
+            let specifier = args.path;
+            // Start by checking whether the specifier matches any import map defined
+            // by the user.
+            const { matched, resolvedImport } = resolve(specifier, importMap, baseURL);
+            // If it does, the resolved import is the specifier we'll evaluate going
+            // forward.
+            if (matched) {
+                specifier = fileURLToPath(resolvedImport).replace(/\\/g, '/');
+                result.path = specifier;
+            }
+            // If the specifier is a Node.js built-in, we don't want to bundle it.
+            if (specifier.startsWith(nodePrefix) || builtinModulesSet.has(specifier)) {
+                return { external: true };
+            }
+            // We don't support the `npm:` prefix yet. Mark the specifier as external
+            // and the ESZIP bundler will handle the failure.
+            if (specifier.startsWith(npmPrefix)) {
+                return { external: true };
+            }
+            const isLocalImport = specifier.startsWith(path.sep) || specifier.startsWith('.');
+            // If this is a local import, return so that esbuild visits that path.
+            if (isLocalImport) {
+                return result;
+            }
+            const isRemoteURLImport = specifier.startsWith('https://') || specifier.startsWith('http://');
+            if (isRemoteURLImport) {
+                return { external: true };
+            }
+            // At this point we know we're dealing with a bare specifier that should
+            // be treated as an external module. We first try to resolve it, because
+            // in the event that it doesn't exist (e.g. user is referencing a module
+            // that they haven't installed) we won't even attempt to bundle it. This
+            // lets the ESZIP bundler handle and report the missing import instead of
+            // esbuild, which is a better experience for the user.
+            try {
+                require.resolve(specifier, { paths: [args.resolveDir] });
+                specifiers.add(specifier);
+            }
+            catch {
+                // no-op
+            }
+            // Mark the specifier as external, because we don't want to traverse the
+            // entire module tree — i.e. if user code imports module `foo` and that
+            // imports `bar`, we only want to add `foo` to the list of specifiers,
+            // since the whole module — including its dependencies like `bar` —
+            // will be bundled.
+            return { external: true };
+        });
+    },
+});
+export const vendorNPMSpecifiers = async ({ basePath, directory, functions, importMap, logger, }) => {
+    const specifiers = new Set();
+    // The directories that esbuild will use when resolving Node modules. We must
+    // set these manually because esbuild will be operating from a temporary
+    // directory that will not live inside the project root, so the normal
+    // resolution logic won't work.
+    const nodePaths = [path.join(basePath, 'node_modules')];
+    // We need to create some files on disk, which we don't want to write to the
+    // project directory. If a custom directory has been specified, we use it.
+    // Otherwise, create a random temporary directory.
+    const temporaryDirectory = directory ? { path: directory } : await tmp.dir();
+    // Do a first pass at bundling to gather a list of specifiers that should be
+    // loaded as npm dependencies, because they either use the `npm:` prefix or
+    // they are bare specifiers. We'll collect them in `specifiers`.
+    try {
+        await build({
+            banner,
+            bundle: true,
+            entryPoints: functions,
+            logLevel: 'error',
+            nodePaths,
+            outdir: temporaryDirectory.path,
+            platform: 'node',
+            plugins: [getDependencyTrackerPlugin(specifiers, importMap.getContentsWithURLObjects(), pathToFileURL(basePath))],
+            write: false,
+        });
+    }
+    catch (error) {
+        logger.system('Could not track dependencies in edge function:', error);
+        logger.user('An error occurred when trying to scan your edge functions for npm modules, which is an experimental feature. If you are loading npm modules, please share the errors above in https://ntl.fyi/edge-functions-npm. If you are not loading npm modules, you can ignore this message.');
+    }
+    // If we found no specifiers, there's nothing left to do here.
+    if (specifiers.size === 0) {
+        return;
+    }
+    logger.user('You are using npm modules in Edge Functions, which is an experimental feature. Learn more at https://ntl.fyi/edge-functions-npm.');
+    // To bundle an entire module and all its dependencies, create a barrel file
+    // where we re-export everything from that specifier. We do this for every
+    // specifier, and each of these files will become entry points to esbuild.
+    const ops = await Promise.all([...specifiers].map(async (specifier, index) => {
+        const code = `import * as mod from "${specifier}"; export default mod.default; export * from "${specifier}";`;
+        const filePath = path.join(temporaryDirectory.path, `barrel-${index}.js`);
+        await fs.writeFile(filePath, code);
+        return { filePath, specifier };
+    }));
+    const entryPoints = ops.map(({ filePath }) => filePath);
+    // Bundle each of the barrel files we created. We'll end up with a compiled
+    // version of each of the barrel files, plus any chunks of shared code
+    // between them (such that a common module isn't bundled twice).
+    await build({
+        allowOverwrite: true,
+        banner,
+        bundle: true,
+        entryPoints,
+        format: 'esm',
+        logLevel: 'error',
+        nodePaths,
+        outdir: temporaryDirectory.path,
+        platform: 'node',
+        splitting: true,
+        target: 'es2020',
+    });
+    // Add all Node.js built-ins to the import map, so any unprefixed specifiers
+    // (e.g. `process`) resolve to the prefixed versions (e.g. `node:prefix`),
+    // which Deno can process.
+    const builtIns = builtinModules.reduce((acc, name) => ({
+        ...acc,
+        [name]: `node:${name}`,
+    }), {});
+    // Creates an object that is compatible with the `imports` block of an import
+    // map, mapping specifiers to the paths of their bundled files on disk. Each
+    // specifier gets two entries in the import map, one with the `npm:` prefix
+    // and one without, such that both options are supported.
+    const newImportMap = {
+        baseURL: pathToFileURL(temporaryDirectory.path),
+        imports: ops.reduce((acc, op) => {
+            const url = pathToFileURL(op.filePath).toString();
+            return {
+                ...acc,
+                [op.specifier]: url,
+            };
+        }, builtIns),
+    };
+    const cleanup = async () => {
+        // If a custom temporary directory was specified, we leave the cleanup job
+        // up to the caller.
+        if (directory) {
+            return;
+        }
+        try {
+            await fs.rm(temporaryDirectory.path, { force: true, recursive: true });
+        }
+        catch {
+            // no-op
+        }
+    };
+    return {
+        cleanup,
+        directory: temporaryDirectory.path,
+        importMap: newImportMap,
+    };
+};

package/dist/node/npm_import_error.d.ts

@@ -1,5 +1,5 @@
 declare class NPMImportError extends Error {
-    constructor(originalError: Error, moduleName: string);
+    constructor(originalError: Error, moduleName: string, supportsNPM: boolean);
 }
-declare const wrapNpmImportError: (input: unknown) => unknown;
+declare const wrapNpmImportError: (input: unknown, supportsNPM: boolean) => unknown;
 export { NPMImportError, wrapNpmImportError };

package/dist/node/npm_import_error.js

@@ -1,23 +1,27 @@
 class NPMImportError extends Error {
-    constructor(originalError, moduleName) {
-        super(`It seems like you're trying to import an npm module. This is only supported via CDNs like esm.sh. Have you tried 'import mod from "https://esm.sh/${moduleName}"'?`);
+    constructor(originalError, moduleName, supportsNPM) {
+        let message = `It seems like you're trying to import an npm module. This is only supported via CDNs like esm.sh. Have you tried 'import mod from "https://esm.sh/${moduleName}"'?`;
+        if (supportsNPM) {
+            message = `There was an error when loading the '${moduleName}' npm module. Support for npm modules in edge functions is an experimental feature. Refer to https://ntl.fyi/edge-functions-npm for more information.`;
+        }
+        super(message);
         this.name = 'NPMImportError';
         this.stack = originalError.stack;
         // https://github.com/microsoft/TypeScript-wiki/blob/8a66ecaf77118de456f7cd9c56848a40fe29b9b4/Breaking-Changes.md#implicit-any-error-raised-for-un-annotated-callback-arguments-with-no-matching-overload-arguments
         Object.setPrototypeOf(this, NPMImportError.prototype);
     }
 }
-const wrapNpmImportError = (input) => {
+const wrapNpmImportError = (input, supportsNPM) => {
     if (input instanceof Error) {
         const match = input.message.match(/Relative import path "(.*)" not prefixed with/);
         if (match !== null) {
             const [, moduleName] = match;
-            return new NPMImportError(input, moduleName);
+            return new NPMImportError(input, moduleName, supportsNPM);
         }
         const schemeMatch = input.message.match(/Error: Module not found "npm:(.*)"/);
         if (schemeMatch !== null) {
             const [, moduleName] = schemeMatch;
-            return new NPMImportError(input, moduleName);
+            return new NPMImportError(input, moduleName, supportsNPM);
         }
     }
     return input;

package/dist/node/server/server.d.ts

@@ -7,7 +7,7 @@ import { OnAfterDownloadHook, OnBeforeDownloadHook } from '../bridge.js';
 import { FunctionConfig } from '../config.js';
 import type { EdgeFunction } from '../edge_function.js';
 import { LogFunction } from '../logger.js';
-type FormatFunction = (name: string) => string;
+export type FormatFunction = (name: string) => string;
 interface StartServerOptions {
     getFunctionsConfig?: boolean;
 }
@@ -17,6 +17,7 @@ interface InspectSettings {
     address?: string;
 }
 interface ServeOptions {
+    basePath: string;
     bootstrapURL: string;
     certificatePath?: string;
     debug?: boolean;
@@ -28,12 +29,12 @@ interface ServeOptions {
     formatExportTypeError?: FormatFunction;
     formatImportError?: FormatFunction;
     port: number;
+    servePath: string;
     systemLogger?: LogFunction;
 }
-declare const serve: ({ bootstrapURL, certificatePath, debug, distImportMapPath, inspectSettings, formatExportTypeError, formatImportError, importMapPaths, onAfterDownload, onBeforeDownload, port, systemLogger, }: ServeOptions) => Promise<(functions: EdgeFunction[], env?: NodeJS.ProcessEnv, options?: StartServerOptions) => Promise<{
+export declare const serve: ({ basePath, bootstrapURL, certificatePath, debug, distImportMapPath, inspectSettings, formatExportTypeError, formatImportError, importMapPaths, onAfterDownload, onBeforeDownload, port, servePath, systemLogger, }: ServeOptions) => Promise<(functions: EdgeFunction[], env?: NodeJS.ProcessEnv, options?: StartServerOptions) => Promise<{
     functionsConfig: FunctionConfig[];
     graph: any;
     success: boolean;
 }>>;
-export { serve };
-export type { FormatFunction };
+export {};

package/dist/node/server/server.js

@@ -1,12 +1,12 @@
-import { tmpName } from 'tmp-promise';
 import { DenoBridge } from '../bridge.js';
 import { getFunctionConfig } from '../config.js';
 import { generateStage2 } from '../formats/javascript.js';
 import { ImportMap } from '../import_map.js';
 import { getLogger } from '../logger.js';
+import { vendorNPMSpecifiers } from '../npm_dependencies.js';
 import { ensureLatestTypes } from '../types.js';
 import { killProcess, waitForServer } from './util.js';
-const prepareServer = ({ bootstrapURL, deno, distDirectory, flags: denoFlags, formatExportTypeError, formatImportError, importMap, logger, port, }) => {
+const prepareServer = ({ basePath, bootstrapURL, deno, distDirectory, distImportMapPath, flags: denoFlags, formatExportTypeError, formatImportError, importMap: baseImportMap, logger, port, }) => {
     const processRef = {};
     const startServer = async (functions, env = {}, options = {}) => {
         if ((processRef === null || processRef === void 0 ? void 0 : processRef.ps) !== undefined) {
@@ -21,6 +21,17 @@ const prepareServer = ({ bootstrapURL, deno, distDirectory, flags: denoFlags, fo
             formatExportTypeError,
             formatImportError,
         });
+        const importMap = baseImportMap.clone();
+        const vendor = await vendorNPMSpecifiers({
+            basePath,
+            directory: distDirectory,
+            functions: functions.map(({ path }) => path),
+            importMap,
+            logger,
+        });
+        if (vendor) {
+            importMap.add(vendor.importMap);
+        }
         try {
             // This command will print a JSON object with all the modules found in
             // the `stage2Path` file as well as all of their dependencies.
@@ -32,11 +43,12 @@ const prepareServer = ({ bootstrapURL, deno, distDirectory, flags: denoFlags, fo
         catch {
             // no-op
         }
-        const bootstrapFlags = ['--port', port.toString()];
+        const extraDenoFlags = [`--import-map=${importMap.toDataURL()}`];
+        const applicationFlags = ['--port', port.toString()];
         // We set `extendEnv: false` to avoid polluting the edge function context
         // with variables from the user's system, since those will not be available
         // in the production environment.
-        await deno.runInBackground(['run', ...denoFlags, stage2Path, ...bootstrapFlags], processRef, {
+        await deno.runInBackground(['run', ...denoFlags, ...extraDenoFlags, stage2Path, ...applicationFlags], processRef, {
             pipeOutput: true,
             env,
             extendEnv: false,
@@ -45,6 +57,9 @@ const prepareServer = ({ bootstrapURL, deno, distDirectory, flags: denoFlags, fo
         if (options.getFunctionsConfig) {
             functionsConfig = await Promise.all(functions.map((func) => getFunctionConfig({ func, importMap, deno, log: logger })));
         }
+        if (distImportMapPath) {
+            await importMap.writeToFile(distImportMapPath);
+        }
         const success = await waitForServer(port, processRef.ps);
         return {
             functionsConfig,
@@ -54,7 +69,7 @@ const prepareServer = ({ bootstrapURL, deno, distDirectory, flags: denoFlags, fo
     };
     return startServer;
 };
-const serve = async ({ bootstrapURL, certificatePath, debug, distImportMapPath, inspectSettings, formatExportTypeError, formatImportError, importMapPaths = [], onAfterDownload, onBeforeDownload, port, systemLogger, }) => {
+export const serve = async ({ basePath, bootstrapURL, certificatePath, debug, distImportMapPath, inspectSettings, formatExportTypeError, formatImportError, importMapPaths = [], onAfterDownload, onBeforeDownload, port, servePath, systemLogger, }) => {
     const logger = getLogger(systemLogger, debug);
     const deno = new DenoBridge({
         debug,
@@ -62,16 +77,11 @@ const serve = async ({ bootstrapURL, certificatePath, debug, distImportMapPath,
         onAfterDownload,
         onBeforeDownload,
     });
-    // We need to generate a stage 2 file and write it somewhere. We use a
-    // temporary directory for that.
-    const distDirectory = await tmpName();
     // Wait for the binary to be downloaded if needed.
     await deno.getBinaryPath();
     // Downloading latest types if needed.
     await ensureLatestTypes(deno, logger);
-    const importMap = new ImportMap();
-    await importMap.addFiles(importMapPaths, logger);
-    const flags = ['--allow-all', `--import-map=${importMap.toDataURL()}`, '--no-config'];
+    const flags = ['--allow-all', '--no-config'];
     if (certificatePath) {
         flags.push(`--cert=${certificatePath}`);
     }
@@ -89,10 +99,14 @@ const serve = async ({ bootstrapURL, certificatePath, debug, distImportMapPath,
             flags.push(inspectSettings.address ? `--inspect=${inspectSettings.address}` : '--inspect');
         }
     }
+    const importMap = new ImportMap();
+    await importMap.addFiles(importMapPaths, logger);
     const server = prepareServer({
+        basePath,
         bootstrapURL,
         deno,
-        distDirectory,
+        distDirectory: servePath,
+        distImportMapPath,
         flags,
         formatExportTypeError,
         formatImportError,
@@ -100,9 +114,5 @@ const serve = async ({ bootstrapURL, certificatePath, debug, distImportMapPath,
         logger,
         port,
     });
-    if (distImportMapPath) {
-        await importMap.writeToFile(distImportMapPath);
-    }
     return server;
 };
-export { serve };

package/dist/node/server/server.test.js

@@ -1,6 +1,7 @@
 import { join } from 'path';
 import getPort from 'get-port';
 import fetch from 'node-fetch';
+import { tmpName } from 'tmp-promise';
 import { v4 as uuidv4 } from 'uuid';
 import { test, expect } from 'vitest';
 import { fixturesDir } from '../../test/util.js';
@@ -13,10 +14,13 @@ test('Starts a server and serves requests for edge functions', async () => {
     };
     const port = await getPort();
     const importMapPaths = [join(paths.internal, 'import_map.json'), join(paths.user, 'import-map.json')];
+    const servePath = await tmpName();
     const server = await serve({
+        basePath,
         bootstrapURL: 'https://edge.netlify.com/bootstrap/index-combined.ts',
         importMapPaths,
         port,
+        servePath,
     });
     const functions = [
         {

package/dist/shared/consts.d.ts

@@ -1,2 +1,5 @@
 export declare const importMapSpecifier = "netlify:import-map";
+export declare const nodePrefix = "node:";
+export declare const npmPrefix = "npm:";
 export declare const virtualRoot = "file:///root/";
+export declare const virtualVendorRoot = "file:///vendor/";

package/dist/shared/consts.js

@@ -1,2 +1,5 @@
 export const importMapSpecifier = 'netlify:import-map';
+export const nodePrefix = 'node:';
+export const npmPrefix = 'npm:';
 export const virtualRoot = 'file:///root/';
+export const virtualVendorRoot = 'file:///vendor/';

package/dist/shared/stage2.d.ts

@@ -8,4 +8,5 @@ export interface WriteStage2Options {
     externals: string[];
     functions: InputFunction[];
     importMapData?: string;
+    vendorDirectory?: string;
 }

package/dist/test/util.d.ts

@@ -7,5 +7,5 @@ declare const useFixture: (fixtureName: string) => Promise<{
     distPath: string;
 }>;
 declare const getRouteMatcher: (manifest: Manifest) => (candidate: string) => import("../node/manifest.js").Route | undefined;
-declare const runESZIP: (eszipPath: string) => Promise<any>;
+declare const runESZIP: (eszipPath: string, vendorDirectory?: string) => Promise<any>;
 export { fixturesDir, getRouteMatcher, testLogger, runESZIP, useFixture };

package/dist/test/util.js

@@ -48,7 +48,7 @@ const getRouteMatcher = (manifest) => (candidate) => manifest.routes.find((route
     const isExcluded = excludedPatterns.some((pattern) => new RegExp(pattern).test(candidate));
     return !isExcluded;
 });
-const runESZIP = async (eszipPath) => {
+const runESZIP = async (eszipPath, vendorDirectory) => {
     var _a, _b, _c;
     const tmpDir = await tmp.dir({ unsafeCleanup: true });
     // Extract ESZIP into temporary directory.
@@ -68,7 +68,10 @@ const runESZIP = async (eszipPath) => {
     const importMapPath = join(virtualRootPath, '..', 'import-map');
     for (const path of [importMapPath, stage2Path]) {
         const file = await fs.readFile(path, 'utf8');
-        const normalizedFile = file.replace(/file:\/\/\/root/g, pathToFileURL(virtualRootPath).toString());
+        let normalizedFile = file.replace(/file:\/{3}root/g, pathToFileURL(virtualRootPath).toString());
+        if (vendorDirectory !== undefined) {
+            normalizedFile = normalizedFile.replace(/file:\/{3}vendor/g, pathToFileURL(vendorDirectory).toString());
+        }
         await fs.writeFile(path, normalizedFile);
     }
     await fs.rename(stage2Path, `${stage2Path}.js`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "8.19.1",
+  "version": "9.0.0",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",
@@ -79,6 +79,7 @@
     "better-ajv-errors": "^1.2.0",
     "common-path-prefix": "^3.0.0",
     "env-paths": "^3.0.0",
+    "esbuild": "0.19.2",
     "execa": "^6.0.0",
     "find-up": "^6.3.0",
     "get-port": "^6.1.2",

package/shared/consts.ts

@@ -1,2 +1,5 @@
 export const importMapSpecifier = 'netlify:import-map'
+export const nodePrefix = 'node:'
+export const npmPrefix = 'npm:'
 export const virtualRoot = 'file:///root/'
+export const virtualVendorRoot = 'file:///vendor/'

package/shared/stage2.ts

@@ -9,4 +9,5 @@ export interface WriteStage2Options {
   externals: string[]
   functions: InputFunction[]
   importMapData?: string
+  vendorDirectory?: string
 }