@netlify/edge-bundler 5.3.3 → 5.5.0

package/deno/bundle.ts

@@ -1,6 +1,6 @@
 import { writeStage2 } from './lib/stage2.ts'
 
 const [payload] = Deno.args
-const { basePath, destPath, externals, functions, importMapURL } = JSON.parse(payload)
+const { basePath, destPath, externals, functions, importMapData } = JSON.parse(payload)
 
-await writeStage2({ basePath, destPath, externals, functions, importMapURL })
+await writeStage2({ basePath, destPath, externals, functions, importMapData })

package/deno/lib/stage2.ts

@@ -3,7 +3,7 @@ import { build, LoadResponse } from 'https://deno.land/x/eszip@v0.28.0/mod.ts'
 import * as path from 'https://deno.land/std@0.127.0/path/mod.ts'
 
 import type { InputFunction, WriteStage2Options } from '../../shared/stage2.ts'
-import { virtualRoot } from '../../shared/consts.ts'
+import { importMapSpecifier, virtualRoot } from '../../shared/consts.ts'
 import { PUBLIC_SPECIFIER, STAGE2_SPECIFIER } from './consts.ts'
 import { inlineModule, loadFromVirtualRoot, loadWithRetry } from './common.ts'
 
@@ -63,7 +63,7 @@ const getVirtualPath = (basePath: string, filePath: string) => {
   return url
 }
 
-const stage2Loader = (basePath: string, functions: InputFunction[], externals: Set<string>) => {
+const stage2Loader = (basePath: string, functions: InputFunction[], externals: Set<string>, importMapData?: string) => {
   return async (specifier: string): Promise<LoadResponse | undefined> => {
     if (specifier === STAGE2_SPECIFIER) {
       const stage2Entry = getStage2Entry(basePath, functions)
@@ -71,6 +71,10 @@ const stage2Loader = (basePath: string, functions: InputFunction[], externals: S
       return inlineModule(specifier, stage2Entry)
     }
 
+    if (specifier === importMapSpecifier && importMapData !== undefined) {
+      return inlineModule(specifier, importMapData)
+    }
+
     if (specifier === PUBLIC_SPECIFIER || externals.has(specifier)) {
       return {
         kind: 'external',
@@ -86,8 +90,9 @@ const stage2Loader = (basePath: string, functions: InputFunction[], externals: S
   }
 }
 
-const writeStage2 = async ({ basePath, destPath, externals, functions, importMapURL }: WriteStage2Options) => {
-  const loader = stage2Loader(basePath, functions, new Set(externals))
+const writeStage2 = async ({ basePath, destPath, externals, functions, importMapData }: WriteStage2Options) => {
+  const importMapURL = importMapData ? importMapSpecifier : undefined
+  const loader = stage2Loader(basePath, functions, new Set(externals), importMapData)
   const bytes = await build([STAGE2_SPECIFIER], loader, importMapURL)
   const directory = path.dirname(destPath)
 

package/dist/node/bundle.d.ts

@@ -6,5 +6,4 @@ export interface Bundle {
     extension: string;
     format: BundleFormat;
     hash: string;
-    importMapURL?: string;
 }

package/dist/node/bundler.js

@@ -2,6 +2,7 @@ import { promises as fs } from 'fs';
 import { join } from 'path';
 import commonPathPrefix from 'common-path-prefix';
 import { v4 as uuidv4 } from 'uuid';
+import { importMapSpecifier } from '../shared/consts.js';
 import { DenoBridge } from './bridge.js';
 import { getFunctionConfig } from './config.js';
 import { getDeclarationsFromConfig } from './declaration.js';
@@ -76,7 +77,7 @@ const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], {
         declarations,
         distDirectory,
         functions,
-        importMapURL: functionBundle.importMapURL,
+        importMap: importMapSpecifier,
         layers: deployConfig.layers,
     });
     if (distImportMapPath) {

package/dist/node/bundler.test.js

@@ -1,10 +1,10 @@
 import { promises as fs } from 'fs';
 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 } from 'vitest';
+import { importMapSpecifier } from '../shared/consts.js';
 import { useFixture } from '../test/util.js';
 import { BundleError } from './bundle_error.js';
 import { bundle } from './bundler.js';
@@ -25,8 +25,7 @@ test('Produces an ESZIP bundle', async () => {
     });
     const generatedFiles = await fs.readdir(distPath);
     expect(result.functions.length).toBe(1);
-    // ESZIP, manifest and import map.
-    expect(generatedFiles.length).toBe(3);
+    expect(generatedFiles.length).toBe(2);
     const manifestFile = await fs.readFile(resolve(distPath, 'manifest.json'), 'utf8');
     const manifest = JSON.parse(manifestFile);
     expect(() => validateManifest(manifest)).not.toThrowError();
@@ -34,7 +33,7 @@ test('Produces an ESZIP bundle', async () => {
     expect(bundles.length).toBe(1);
     expect(bundles[0].format).toBe('eszip2');
     expect(generatedFiles.includes(bundles[0].asset)).toBe(true);
-    expect(importMapURL).toBe('file:///root/.netlify/edge-functions-dist/import_map.json');
+    expect(importMapURL).toBe(importMapSpecifier);
     await cleanup();
 });
 test('Uses the vendored eszip module instead of fetching it from deno.land', async () => {
@@ -52,8 +51,7 @@ test('Uses the vendored eszip module instead of fetching it from deno.land', asy
     });
     const generatedFiles = await fs.readdir(distPath);
     expect(result.functions.length).toBe(1);
-    // ESZIP, manifest and import map.
-    expect(generatedFiles.length).toBe(3);
+    expect(generatedFiles.length).toBe(2);
     const manifestFile = await fs.readFile(resolve(distPath, 'manifest.json'), 'utf8');
     const manifest = JSON.parse(manifestFile);
     const { bundles } = manifest;
@@ -140,8 +138,7 @@ test('Uses the cache directory as the `DENO_DIR` value if the `edge_functions_ca
     const result1 = await bundle([sourceDirectory], distPath, declarations, options);
     const outFiles1 = await fs.readdir(distPath);
     expect(result1.functions.length).toBe(1);
-    // ESZIP, manifest and import map.
-    expect(outFiles1.length).toBe(3);
+    expect(outFiles1.length).toBe(2);
     try {
         await fs.readdir(join(cacheDir.path, 'deno_dir'));
     }
@@ -157,8 +154,7 @@ test('Uses the cache directory as the `DENO_DIR` value if the `edge_functions_ca
     });
     const outFiles2 = await fs.readdir(distPath);
     expect(result2.functions.length).toBe(1);
-    // ESZIP, manifest and import map.
-    expect(outFiles2.length).toBe(3);
+    expect(outFiles2.length).toBe(2);
     const denoDir2 = await fs.readdir(join(cacheDir.path, 'deno_dir'));
     expect(denoDir2.includes('gen')).toBe(true);
     await cleanup();
@@ -178,8 +174,7 @@ test('Supports import maps with relative paths', async () => {
     });
     const generatedFiles = await fs.readdir(distPath);
     expect(result.functions.length).toBe(1);
-    // ESZIP, manifest and import map.
-    expect(generatedFiles.length).toBe(3);
+    expect(generatedFiles.length).toBe(2);
     const manifestFile = await fs.readFile(resolve(distPath, 'manifest.json'), 'utf8');
     const manifest = JSON.parse(manifestFile);
     const { bundles } = manifest;
@@ -247,8 +242,7 @@ test('Processes a function that imports a custom layer', async () => {
     });
     const generatedFiles = await fs.readdir(distPath);
     expect(result.functions.length).toBe(1);
-    // ESZIP, manifest and import map.
-    expect(generatedFiles.length).toBe(3);
+    expect(generatedFiles.length).toBe(2);
     const manifestFile = await fs.readFile(resolve(distPath, 'manifest.json'), 'utf8');
     const manifest = JSON.parse(manifestFile);
     const { bundles, layers } = manifest;
@@ -273,8 +267,7 @@ test('Loads declarations and import maps from the deploy configuration', async (
     });
     const generatedFiles = await fs.readdir(distPath);
     expect(result.functions.length).toBe(2);
-    // ESZIP, manifest and import map.
-    expect(generatedFiles.length).toBe(3);
+    expect(generatedFiles.length).toBe(2);
     const manifestFile = await fs.readFile(resolve(distPath, 'manifest.json'), 'utf8');
     const manifest = JSON.parse(manifestFile);
     const { bundles } = manifest;
@@ -283,33 +276,3 @@ test('Loads declarations and import maps from the deploy configuration', async (
     expect(generatedFiles.includes(bundles[0].asset)).toBe(true);
     await cleanup();
 });
-test('Uses an absolute URL for the import map when the dist directory is not a child of the base path', async () => {
-    const { basePath, cleanup } = await useFixture('with_import_maps');
-    const { path: distPath } = await tmp.dir();
-    const declarations = [
-        {
-            function: 'func1',
-            path: '/func1',
-        },
-    ];
-    const sourceDirectory = join(basePath, 'functions');
-    const result = await bundle([sourceDirectory], distPath, declarations, {
-        basePath,
-        configPath: join(sourceDirectory, 'config.json'),
-    });
-    const generatedFiles = await fs.readdir(distPath);
-    expect(result.functions.length).toBe(1);
-    // ESZIP, manifest and import map.
-    expect(generatedFiles.length).toBe(3);
-    const manifestFile = await fs.readFile(resolve(distPath, 'manifest.json'), 'utf8');
-    const manifest = JSON.parse(manifestFile);
-    expect(() => validateManifest(manifest)).not.toThrowError();
-    const { bundles, import_map: importMapURL } = manifest;
-    expect(bundles.length).toBe(1);
-    expect(bundles[0].format).toBe('eszip2');
-    expect(generatedFiles.includes(bundles[0].asset)).toBe(true);
-    const importMapPath = join(distPath, 'import_map.json');
-    expect(importMapURL).toBe(pathToFileURL(importMapPath).toString());
-    await cleanup();
-    await fs.rm(distPath, { recursive: true });
-});

package/dist/node/config.test.js

@@ -131,8 +131,7 @@ test('Ignores function paths from the in-source `config` function if the feature
     });
     const generatedFiles = await fs.readdir(distPath);
     expect(result.functions.length).toBe(6);
-    // ESZIP, manifest and import map.
-    expect(generatedFiles.length).toBe(3);
+    expect(generatedFiles.length).toBe(2);
     const manifestFile = await fs.readFile(resolve(distPath, 'manifest.json'), 'utf8');
     const manifest = JSON.parse(manifestFile);
     const { bundles, routes } = manifest;
@@ -165,8 +164,7 @@ test('Loads function paths from the in-source `config` function', async () => {
     });
     const generatedFiles = await fs.readdir(distPath);
     expect(result.functions.length).toBe(6);
-    // ESZIP, manifest and import map.
-    expect(generatedFiles.length).toBe(3);
+    expect(generatedFiles.length).toBe(2);
     const manifestFile = await fs.readFile(resolve(distPath, 'manifest.json'), 'utf8');
     const manifest = JSON.parse(manifestFile);
     const { bundles, routes, post_cache_routes: postCacheRoutes } = manifest;

package/dist/node/formats/eszip.js

@@ -1,5 +1,4 @@
-import { join, relative } from 'path';
-import { pathToFileURL } from 'url';
+import { join } from 'path';
 import { virtualRoot } from '../../shared/consts.js';
 import { BundleFormat } from '../bundle.js';
 import { wrapBundleError } from '../bundle_error.js';
@@ -10,13 +9,13 @@ const bundleESZIP = async ({ basePath, buildID, debug, deno, distDirectory, exte
     const extension = '.eszip';
     const destPath = join(distDirectory, `${buildID}${extension}`);
     const { bundler, importMap: bundlerImportMap } = getESZIPPaths();
-    const importMapURL = await createUserImportMap(importMap, basePath, distDirectory);
+    const importMapData = JSON.stringify(importMap.getContents(basePath, virtualRoot));
     const payload = {
         basePath,
         destPath,
         externals,
         functions,
-        importMapURL,
+        importMapData,
     };
     const flags = ['--allow-all', '--no-config', `--import-map=${bundlerImportMap}`];
     if (!debug) {
@@ -29,24 +28,7 @@ const bundleESZIP = async ({ basePath, buildID, debug, deno, distDirectory, exte
         throw wrapBundleError(wrapNpmImportError(error), { format: 'eszip' });
     }
     const hash = await getFileHash(destPath);
-    return { extension, format: BundleFormat.ESZIP2, hash, importMapURL };
-};
-// Takes an import map, writes it to a file on disk, and gets its URL relative
-// to the ESZIP root (i.e. using the virtual root prefix).
-const createUserImportMap = async (importMap, basePath, distDirectory) => {
-    const destPath = join(distDirectory, 'import_map.json');
-    await importMap.writeToFile(destPath);
-    const virtualPath = relative(basePath, destPath);
-    // If the dist directory is not a child of the base path, we can't represent
-    // the relative path as a file URL (because something like 'file://../foo' is
-    // not valid). This should never happen, but it's best to leave the absolute
-    // path untransformed to avoid getting a build error due to a missing import
-    // map.
-    if (virtualPath.startsWith('..')) {
-        return pathToFileURL(destPath).toString();
-    }
-    const importMapURL = new URL(virtualPath, virtualRoot);
-    return importMapURL.toString();
+    return { extension, format: BundleFormat.ESZIP2, hash };
 };
 const getESZIPPaths = () => {
     const denoPath = join(getPackagePath(), 'deno');

package/dist/node/formats/javascript.js

@@ -3,7 +3,7 @@ import { join } from 'path';
 import { env } from 'process';
 import { pathToFileURL } from 'url';
 import { deleteAsync } from 'del';
-const BOOTSTRAP_LATEST = 'https://638f0e00dc20510008d6a1f4--edge.netlify.com/bootstrap/index-combined.ts';
+const BOOTSTRAP_LATEST = 'https://639708f6d7f813000870695c--edge.netlify.com/bootstrap/index-combined.ts';
 const defaultFormatExportTypeError = (name) => `The Edge Function "${name}" has failed to load. Does it have a function as the default export?`;
 const defaultFormatImpoortError = (name) => `There was an error with Edge Function "${name}".`;
 const generateStage2 = async ({ distDirectory, fileName, formatExportTypeError, formatImportError, functions, }) => {

package/dist/node/import_map.d.ts

@@ -6,12 +6,14 @@ interface ImportMapFile {
 declare class ImportMap {
     files: ImportMapFile[];
     constructor(files?: ImportMapFile[]);
-    static resolve(importMapFile: ImportMapFile, rootPath?: string): {
+    static resolve(importMapFile: ImportMapFile, basePath?: string, prefix?: string): {
         imports: Record<string, string>;
         scopes?: import("@import-maps/resolve/types/src/types").ParsedScopesMap | undefined;
     };
     add(file: ImportMapFile): void;
-    getContents(rootPath?: string): string;
+    getContents(basePath?: string, prefix?: string): {
+        imports: Record<string, string>;
+    };
     toDataURL(): string;
     writeToFile(path: string): Promise<void>;
 }

package/dist/node/import_map.js

@@ -1,6 +1,6 @@
 import { Buffer } from 'buffer';
 import { promises as fs } from 'fs';
-import { dirname, isAbsolute, posix, relative, sep } from 'path';
+import { dirname, posix, relative, sep } from 'path';
 import { fileURLToPath, pathToFileURL } from 'url';
 import { parse } from '@import-maps/resolve';
 const INTERNAL_IMPORTS = {
@@ -17,7 +17,7 @@ class ImportMap {
     }
     // Transforms an import map by making any relative paths use a different path
     // as a base.
-    static resolve(importMapFile, rootPath) {
+    static resolve(importMapFile, basePath, prefix = 'file://') {
         const { baseURL, ...importMap } = importMapFile;
         const parsedImportMap = parse(importMap, baseURL);
         const { imports = {} } = parsedImportMap;
@@ -29,13 +29,23 @@ class ImportMap {
                 return;
             }
             // If this is a file URL, we might want to transform it to use another
-            // root path, as long as that root path is defined.
-            if (url.protocol === 'file:' && rootPath !== undefined) {
+            // base path, as long as one is provided.
+            if (url.protocol === 'file:' && basePath !== undefined) {
+                const path = fileURLToPath(url);
+                const relativePath = relative(basePath, path);
+                if (relativePath.startsWith('..')) {
+                    throw new Error(`Import map cannot reference '${path}' as it's outside of the base directory '${basePath}'`);
+                }
                 // We want to use POSIX paths for the import map regardless of the OS
                 // we're building in.
-                const path = relative(rootPath, fileURLToPath(url)).split(sep).join(posix.sep);
-                const value = isAbsolute(path) ? path : `.${posix.sep}${path}`;
-                newImports[specifier] = value;
+                let normalizedPath = relativePath.split(sep).join(posix.sep);
+                // If the original URL had a trailing slash, ensure the normalized path
+                // has one too.
+                if (normalizedPath !== '' && url.pathname.endsWith(posix.sep) && !normalizedPath.endsWith(posix.sep)) {
+                    normalizedPath += posix.sep;
+                }
+                const newURL = new URL(normalizedPath, prefix);
+                newImports[specifier] = newURL.toString();
                 return;
             }
             newImports[specifier] = url.toString();
@@ -45,10 +55,10 @@ class ImportMap {
     add(file) {
         this.files.push(file);
     }
-    getContents(rootPath) {
+    getContents(basePath, prefix) {
         let imports = {};
         this.files.forEach((file) => {
-            const importMap = ImportMap.resolve(file, rootPath);
+            const importMap = ImportMap.resolve(file, basePath, prefix);
             imports = { ...imports, ...importMap.imports };
         });
         // Internal imports must come last, because we need to guarantee that
@@ -57,20 +67,20 @@ class ImportMap {
             const [specifier, url] = internalImport;
             imports[specifier] = url;
         });
-        const contents = {
+        return {
             imports,
         };
-        return JSON.stringify(contents);
     }
     toDataURL() {
-        const encodedImportMap = Buffer.from(this.getContents()).toString('base64');
+        const data = JSON.stringify(this.getContents());
+        const encodedImportMap = Buffer.from(data).toString('base64');
         return `data:application/json;base64,${encodedImportMap}`;
     }
     async writeToFile(path) {
         const distDirectory = dirname(path);
         await fs.mkdir(distDirectory, { recursive: true });
-        const contents = this.getContents(distDirectory);
-        await fs.writeFile(path, contents);
+        const contents = this.getContents();
+        await fs.writeFile(path, JSON.stringify(contents));
     }
 }
 const readFile = async (path) => {

package/dist/node/import_map.test.js

@@ -1,6 +1,8 @@
+import { promises as fs } from 'fs';
 import { join } from 'path';
 import { cwd } from 'process';
 import { pathToFileURL } from 'url';
+import tmp from 'tmp-promise';
 import { test, expect } from 'vitest';
 import { ImportMap } from './import_map.js';
 test('Handles import maps with full URLs without specifying a base URL', () => {
@@ -18,12 +20,12 @@ test('Handles import maps with full URLs without specifying a base URL', () => {
         },
     };
     const map = new ImportMap([inputFile1, inputFile2]);
-    const { imports } = JSON.parse(map.getContents());
+    const { imports } = map.getContents();
     expect(imports['netlify:edge']).toBe('https://edge.netlify.com/v1/index.ts');
     expect(imports['alias:jamstack']).toBe('https://jamstack.org/');
     expect(imports['alias:pets']).toBe('https://petsofnetlify.com/');
 });
-test('Resolves relative paths to absolute paths if a root path is not provided', () => {
+test('Resolves relative paths to absolute paths if a base path is not provided', () => {
     const basePath = join(cwd(), 'my-cool-site', 'import-map.json');
     const inputFile1 = {
         baseURL: pathToFileURL(basePath),
@@ -32,12 +34,12 @@ test('Resolves relative paths to absolute paths if a root path is not provided',
         },
     };
     const map = new ImportMap([inputFile1]);
-    const { imports } = JSON.parse(map.getContents());
+    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');
     expect(imports['alias:pets']).toBe(`${pathToFileURL(expectedPath).toString()}/`);
 });
-test('Transforms relative paths so that they use the root path as a base', () => {
+test('Transforms relative paths so that they become relative to the base path', () => {
     const basePath = join(cwd(), 'my-cool-site', 'import-map.json');
     const inputFile1 = {
         baseURL: pathToFileURL(basePath),
@@ -45,8 +47,43 @@ test('Transforms relative paths so that they use the root path as a base', () =>
             'alias:pets': './heart/pets/',
         },
     };
+    // Without a prefix.
+    const map1 = new ImportMap([inputFile1]);
+    const { imports: imports1 } = map1.getContents(cwd());
+    expect(imports1['netlify:edge']).toBe('https://edge.netlify.com/v1/index.ts');
+    expect(imports1['alias:pets']).toBe('file:///my-cool-site/heart/pets/');
+    // With a prefix.
+    const map2 = new ImportMap([inputFile1]);
+    const { imports: imports2 } = map2.getContents(cwd(), 'file:///root/');
+    expect(imports2['netlify:edge']).toBe('https://edge.netlify.com/v1/index.ts');
+    expect(imports2['alias:pets']).toBe('file:///root/my-cool-site/heart/pets/');
+});
+test('Throws when an import map uses a relative path to reference a file outside of the base path', () => {
+    const basePath = join(cwd(), 'my-cool-site');
+    const inputFile1 = {
+        baseURL: pathToFileURL(join(basePath, 'import_map.json')),
+        imports: {
+            'alias:file': '../file.js',
+        },
+    };
+    const map = new ImportMap([inputFile1]);
+    expect(() => map.getContents(basePath)).toThrowError(`Import map cannot reference '${join(cwd(), 'file.js')}' as it's outside of the base directory '${basePath}'`);
+});
+test('Writes import map file to disk', async () => {
+    const file = await tmp.file();
+    const basePath = join(cwd(), 'my-cool-site', 'import-map.json');
+    const inputFile1 = {
+        baseURL: pathToFileURL(basePath),
+        imports: {
+            'alias:pets': './heart/pets/file.ts',
+        },
+    };
     const map = new ImportMap([inputFile1]);
-    const { imports } = JSON.parse(map.getContents(cwd()));
+    await map.writeToFile(file.path);
+    const createdFile = await fs.readFile(file.path, 'utf8');
+    const { imports } = JSON.parse(createdFile);
+    const expectedPath = join(cwd(), 'my-cool-site', 'heart', 'pets', 'file.ts');
+    await file.cleanup();
     expect(imports['netlify:edge']).toBe('https://edge.netlify.com/v1/index.ts');
-    expect(imports['alias:pets']).toBe('./my-cool-site/heart/pets');
+    expect(imports['alias:pets']).toBe(pathToFileURL(expectedPath).toString());
 });

package/dist/node/manifest.d.ts

@@ -6,7 +6,7 @@ interface GenerateManifestOptions {
     bundles?: Bundle[];
     declarations?: Declaration[];
     functions: EdgeFunction[];
-    importMapURL?: string;
+    importMap?: string;
     layers?: Layer[];
 }
 interface Manifest {
@@ -31,14 +31,14 @@ interface Manifest {
         pattern: string;
     }[];
 }
-declare const generateManifest: ({ bundles, declarations, functions, importMapURL, layers, }: GenerateManifestOptions) => Manifest;
+declare const generateManifest: ({ bundles, declarations, functions, importMap, layers, }: GenerateManifestOptions) => Manifest;
 interface WriteManifestOptions {
     bundles: Bundle[];
     declarations: Declaration[];
     distDirectory: string;
     functions: EdgeFunction[];
-    importMapURL?: string;
+    importMap?: string;
     layers?: Layer[];
 }
-declare const writeManifest: ({ bundles, declarations, distDirectory, functions, importMapURL, layers, }: WriteManifestOptions) => Promise<Manifest>;
+declare const writeManifest: ({ bundles, declarations, distDirectory, functions, importMap, layers, }: WriteManifestOptions) => Promise<Manifest>;
 export { generateManifest, Manifest, writeManifest };

package/dist/node/manifest.js

@@ -3,7 +3,7 @@ import { join } from 'path';
 import globToRegExp from 'glob-to-regexp';
 import { getPackageVersion } from './package_json.js';
 import { nonNullable } from './utils/non_nullable.js';
-const generateManifest = ({ bundles = [], declarations = [], functions, importMapURL, layers = [], }) => {
+const generateManifest = ({ bundles = [], declarations = [], functions, importMap, layers = [], }) => {
     const preCacheRoutes = [];
     const postCacheRoutes = [];
     declarations.forEach((declaration) => {
@@ -35,7 +35,7 @@ const generateManifest = ({ bundles = [], declarations = [], functions, importMa
         post_cache_routes: postCacheRoutes.filter(nonNullable),
         bundler_version: getPackageVersion(),
         layers,
-        import_map: importMapURL,
+        import_map: importMap,
     };
     return manifest;
 };
@@ -52,8 +52,8 @@ const getRegularExpression = (declaration) => {
     const normalizedSource = `^${regularExpression.source}\\/?$`;
     return new RegExp(normalizedSource);
 };
-const writeManifest = async ({ bundles, declarations = [], distDirectory, functions, importMapURL, layers, }) => {
-    const manifest = generateManifest({ bundles, declarations, functions, importMapURL, layers });
+const writeManifest = async ({ bundles, declarations = [], distDirectory, functions, importMap, layers, }) => {
+    const manifest = generateManifest({ bundles, declarations, functions, importMap, layers });
     const manifestPath = join(distDirectory, 'manifest.json');
     await fs.writeFile(manifestPath, JSON.stringify(manifest));
     return manifest;

package/dist/node/server/server.js

@@ -70,7 +70,7 @@ const serve = async ({ certificatePath, debug, distImportMapPath, inspectSetting
     await ensureLatestTypes(deno, logger);
     // Creating an ImportMap instance with any import maps supplied by the user,
     // if any.
-    const importMap = new ImportMap(importMaps !== null && importMaps !== void 0 ? importMaps : []);
+    const importMap = new ImportMap(importMaps);
     const flags = ['--allow-all', '--unstable', `--import-map=${importMap.toDataURL()}`, '--no-config'];
     if (certificatePath) {
         flags.push(`--cert=${certificatePath}`);

package/dist/shared/consts.d.ts

@@ -1 +1,2 @@
+export declare const importMapSpecifier = "netlify:import-map";
 export declare const virtualRoot = "file:///root/";

package/dist/shared/consts.js

@@ -1 +1,2 @@
+export const importMapSpecifier = 'netlify:import-map';
 export const virtualRoot = 'file:///root/';

package/dist/shared/stage2.d.ts

@@ -7,5 +7,5 @@ export interface WriteStage2Options {
     destPath: string;
     externals: string[];
     functions: InputFunction[];
-    importMapURL?: string;
+    importMapData?: string;
 }

package/dist/test/util.js

@@ -1,11 +1,11 @@
 import { promises as fs } from 'fs';
 import { join, resolve } from 'path';
 import { fileURLToPath } from 'url';
-import cpy from 'cpy';
 import tmp from 'tmp-promise';
 import { getLogger } from '../node/logger.js';
-// eslint-disable-next-line @typescript-eslint/no-empty-function
-const testLogger = getLogger(() => { });
+const testLogger = getLogger(() => {
+    // no-op
+});
 const url = new URL(import.meta.url);
 const dirname = fileURLToPath(url);
 const fixturesDir = resolve(dirname, '..', 'fixtures');
@@ -13,10 +13,9 @@ const useFixture = async (fixtureName) => {
     const tmpDir = await tmp.dir();
     const cleanup = () => fs.rmdir(tmpDir.path, { recursive: true });
     const fixtureDir = resolve(fixturesDir, fixtureName);
-    await cpy(`${fixtureDir}/**`, tmpDir.path);
     const distPath = join(tmpDir.path, '.netlify', 'edge-functions-dist');
     return {
-        basePath: tmpDir.path,
+        basePath: fixtureDir,
         cleanup,
         distPath,
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "5.3.3",
+  "version": "5.5.0",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",
@@ -66,7 +66,7 @@
     "nock": "^13.2.4",
     "tar": "^6.1.11",
     "typescript": "^4.5.4",
-    "vite": "^3.1.3",
+    "vite": "^4.0.0",
     "vitest": "^0.25.0"
   },
   "engines": {

package/shared/consts.ts

@@ -1 +1,2 @@
+export const importMapSpecifier = 'netlify:import-map'
 export const virtualRoot = 'file:///root/'

package/shared/stage2.ts

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