@netlify/edge-bundler 5.3.2 → 5.4.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

@@ -4,6 +4,7 @@ import process from 'process';
 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';
@@ -24,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();
@@ -33,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 () => {
@@ -51,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;
@@ -139,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'));
     }
@@ -156,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();
@@ -177,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;
@@ -246,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;
@@ -272,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;

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,4 +1,4 @@
-import { join, relative } from 'path';
+import { join } from 'path';
 import { virtualRoot } from '../../shared/consts.js';
 import { BundleFormat } from '../bundle.js';
 import { wrapBundleError } from '../bundle_error.js';
@@ -9,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) {
@@ -28,16 +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 relativePath = relative(basePath, destPath);
-    const importMapURL = new URL(relativePath, virtualRoot);
-    return importMapURL.toString();
+    return { extension, format: BundleFormat.ESZIP2, hash };
 };
 const getESZIPPaths = () => {
     const denoPath = join(getPackagePath(), 'deno');

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);
+        await fs.writeFile(path, JSON.stringify(contents));
     }
 }
 const readFile = async (path) => {

package/dist/node/import_map.test.js

@@ -18,12 +18,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 +32,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 +45,25 @@ 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]);
-    const { imports } = JSON.parse(map.getContents(cwd()));
-    expect(imports['netlify:edge']).toBe('https://edge.netlify.com/v1/index.ts');
-    expect(imports['alias:pets']).toBe('./my-cool-site/heart/pets');
+    expect(() => map.getContents(basePath)).toThrowError(`Import map cannot reference '${join(cwd(), 'file.js')}' as it's outside of the base directory '${basePath}'`);
 });

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.2",
+  "version": "5.4.0",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",
@@ -57,7 +57,7 @@
     "@types/node": "^14.18.32",
     "@types/semver": "^7.3.9",
     "@types/sinon": "^10.0.8",
-    "@types/uuid": "^8.3.4",
+    "@types/uuid": "^9.0.0",
     "@vitest/coverage-c8": "^0.25.0",
     "archiver": "^5.3.1",
     "cpy": "^9.0.1",

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
 }