@netlify/edge-bundler 14.2.2 → 14.4.0

package/deno/lib/common.ts

@@ -42,7 +42,7 @@ const loadWithRetry = (specifier: string, delay = 1000, maxTry = 3) => {
       maxTry,
     });
   } catch (error) {
-    if (isTooManyTries(error as Error)) {
+    if (error instanceof Error && isTooManyTries(error)) {
       console.error(`Loading ${specifier} failed after ${maxTry} tries.`);
     }
     throw error;

package/dist/node/bridge.d.ts

@@ -1,23 +1,26 @@
 import { type WriteStream } from 'fs';
 import { type ExecaChildProcess } from 'execa';
+import { FeatureFlags } from './feature_flags.js';
 import { Logger } from './logger.js';
-declare const DENO_VERSION_RANGE = "1.39.0 - 2.2.4";
-type OnBeforeDownloadHook = () => void | Promise<void>;
-type OnAfterDownloadHook = (error?: Error) => void | Promise<void>;
-interface DenoOptions {
+export declare const DENO_VERSION_RANGE = "1.39.0 - 2.2.4";
+export type OnBeforeDownloadHook = () => void | Promise<void>;
+export type OnAfterDownloadHook = (error?: Error) => void | Promise<void>;
+export interface DenoOptions {
     cacheDirectory?: string;
     debug?: boolean;
     denoDir?: string;
+    featureFlags?: FeatureFlags;
     logger?: Logger;
     onAfterDownload?: OnAfterDownloadHook;
     onBeforeDownload?: OnBeforeDownloadHook;
     useGlobal?: boolean;
     versionRange?: string;
 }
-interface ProcessRef {
+export interface ProcessRef {
     ps?: ExecaChildProcess<string>;
 }
 interface RunOptions {
+    cwd?: string;
     env?: NodeJS.ProcessEnv;
     extendEnv?: boolean;
     pipeOutput?: boolean;
@@ -25,7 +28,7 @@ interface RunOptions {
     stdout?: WriteStream;
     rejectOnExitCode?: boolean;
 }
-declare class DenoBridge {
+export declare class DenoBridge {
     cacheDirectory: string;
     currentDownload?: ReturnType<DenoBridge['downloadBinary']>;
     debug: boolean;
@@ -51,8 +54,7 @@ declare class DenoBridge {
         path: string;
     }>;
     getEnvironmentVariables(inputEnv?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
-    run(args: string[], { env: inputEnv, extendEnv, rejectOnExitCode, stderr, stdout }?: RunOptions): Promise<import("execa").ExecaReturnValue<string>>;
+    run(args: string[], { cwd, env: inputEnv, extendEnv, rejectOnExitCode, stderr, stdout }?: RunOptions): Promise<import("execa").ExecaReturnValue<string>>;
     runInBackground(args: string[], ref?: ProcessRef, { env: inputEnv, extendEnv, pipeOutput, stderr, stdout }?: RunOptions): Promise<void>;
 }
-export { DENO_VERSION_RANGE, DenoBridge };
-export type { DenoOptions, OnAfterDownloadHook, OnBeforeDownloadHook, ProcessRef };
+export {};

package/dist/node/bridge.js

@@ -12,10 +12,11 @@ const DENO_VERSION_FILE = 'version.txt';
 // When updating DENO_VERSION_RANGE, ensure that the deno version
 // on the netlify/buildbot build image satisfies this range!
 // https://github.com/netlify/buildbot/blob/f9c03c9dcb091d6570e9d0778381560d469e78ad/build-image/noble/Dockerfile#L410
-const DENO_VERSION_RANGE = '1.39.0 - 2.2.4';
-class DenoBridge {
+export const DENO_VERSION_RANGE = '1.39.0 - 2.2.4';
+const NEXT_DENO_VERSION_RANGE = '^2.4.2';
+export class DenoBridge {
     constructor(options) {
-        var _a, _b, _c, _d, _e;
+        var _a, _b, _c, _d, _e, _f;
         this.cacheDirectory = (_a = options.cacheDirectory) !== null && _a !== void 0 ? _a : getPathInHome('deno-cli');
         this.debug = (_b = options.debug) !== null && _b !== void 0 ? _b : false;
         this.denoDir = options.denoDir;
@@ -23,7 +24,8 @@ class DenoBridge {
         this.onAfterDownload = options.onAfterDownload;
         this.onBeforeDownload = options.onBeforeDownload;
         this.useGlobal = (_d = options.useGlobal) !== null && _d !== void 0 ? _d : true;
-        this.versionRange = (_e = options.versionRange) !== null && _e !== void 0 ? _e : DENO_VERSION_RANGE;
+        this.versionRange =
+            (_e = options.versionRange) !== null && _e !== void 0 ? _e : (((_f = options.featureFlags) === null || _f === void 0 ? void 0 : _f.edge_bundler_generate_tarball) ? NEXT_DENO_VERSION_RANGE : DENO_VERSION_RANGE);
     }
     async downloadBinary() {
         var _a, _b, _c;
@@ -148,10 +150,10 @@ class DenoBridge {
     }
     // Runs the Deno CLI in the background and returns a reference to the child
     // process, awaiting its execution.
-    async run(args, { env: inputEnv, extendEnv = true, rejectOnExitCode = true, stderr, stdout } = {}) {
+    async run(args, { cwd, env: inputEnv, extendEnv = true, rejectOnExitCode = true, stderr, stdout } = {}) {
         const { path: binaryPath } = await this.getBinaryPath();
         const env = this.getEnvironmentVariables(inputEnv);
-        const options = { env, extendEnv, reject: rejectOnExitCode };
+        const options = { cwd, env, extendEnv, reject: rejectOnExitCode };
         return DenoBridge.runWithBinary(binaryPath, args, { options, stderr, stdout });
     }
     // Runs the Deno CLI in the background, assigning a reference of the child
@@ -166,4 +168,3 @@ class DenoBridge {
         }
     }
 }
-export { DENO_VERSION_RANGE, DenoBridge };

package/dist/node/bundle.d.ts

@@ -1,6 +1,7 @@
 export declare enum BundleFormat {
     ESZIP2 = "eszip2",
-    JS = "js"
+    JS = "js",
+    TARBALL = "tar"
 }
 export interface Bundle {
     extension: string;

package/dist/node/bundle.js

@@ -2,4 +2,5 @@ export var BundleFormat;
 (function (BundleFormat) {
     BundleFormat["ESZIP2"] = "eszip2";
     BundleFormat["JS"] = "js";
+    BundleFormat["TARBALL"] = "tar";
 })(BundleFormat || (BundleFormat = {}));

package/dist/node/bundler.js

@@ -10,6 +10,7 @@ import { load as loadDeployConfig } from './deploy_config.js';
 import { getFlags } from './feature_flags.js';
 import { findFunctions } from './finder.js';
 import { bundle as bundleESZIP } from './formats/eszip.js';
+import { bundle as bundleTarball } from './formats/tarball.js';
 import { ImportMap } from './import_map.js';
 import { getLogger } from './logger.js';
 import { writeManifest } from './manifest.js';
@@ -22,6 +23,7 @@ export const bundle = async (sourceDirectories, distDirectory, tomlDeclarations
     const options = {
         debug,
         cacheDirectory,
+        featureFlags,
         logger,
         onAfterDownload,
         onBeforeDownload,
@@ -58,10 +60,24 @@ export const bundle = async (sourceDirectories, distDirectory, tomlDeclarations
         rootPath: rootPath !== null && rootPath !== void 0 ? rootPath : basePath,
         vendorDirectory,
     });
+    const bundles = [];
+    if (featureFlags.edge_bundler_generate_tarball) {
+        bundles.push(await bundleTarball({
+            basePath,
+            buildID,
+            debug,
+            deno,
+            distDirectory,
+            functions,
+            featureFlags,
+            importMap: importMap.clone(),
+            vendorDirectory: vendor === null || vendor === void 0 ? void 0 : vendor.directory,
+        }));
+    }
     if (vendor) {
         importMap.add(vendor.importMap);
     }
-    const functionBundle = await bundleESZIP({
+    bundles.push(await bundleESZIP({
         basePath,
         buildID,
         debug,
@@ -72,11 +88,11 @@ export const bundle = async (sourceDirectories, distDirectory, tomlDeclarations
         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
     // rename the bundles to their permanent names.
-    await createFinalBundles([functionBundle], distDirectory, buildID);
+    await createFinalBundles(bundles, distDirectory, buildID);
     // Retrieving a configuration object for each function.
     // Run `getFunctionConfig` in parallel as it is a non-trivial operation and spins up deno
     const internalConfigPromises = internalFunctions.map(async (func) => [func.name, await getFunctionConfig({ func, importMap, deno, log: logger })]);
@@ -92,7 +108,7 @@ export const bundle = async (sourceDirectories, distDirectory, tomlDeclarations
         declarations,
     });
     const manifest = await writeManifest({
-        bundles: [functionBundle],
+        bundles,
         declarations,
         distDirectory,
         featureFlags,

package/dist/node/bundler.test.js

@@ -3,10 +3,11 @@ import { access, readdir, readFile, rm, writeFile } from 'fs/promises';
 import { join, resolve } from 'path';
 import process from 'process';
 import { pathToFileURL } from 'url';
+import { gte, lt } from 'semver';
 import tmp from 'tmp-promise';
-import { test, expect, vi } from 'vitest';
+import { test, expect, vi, describe } from 'vitest';
 import { importMapSpecifier } from '../shared/consts.js';
-import { runESZIP, useFixture } from '../test/util.js';
+import { denoVersion, runESZIP, runTarball, useFixture } from '../test/util.js';
 import { BundleError } from './bundle_error.js';
 import { bundle } from './bundler.js';
 import { isFileNotFoundError } from './utils/error.js';
@@ -398,7 +399,7 @@ test('Loads npm modules from bare specifiers', async () => {
     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>`);
+    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>, TmV0bGlmeQ==`);
     await cleanup();
     await rm(vendorDirectory.path, { force: true, recursive: true });
 });
@@ -474,7 +475,7 @@ test('Loads npm modules in a monorepo setup', async () => {
     await cleanup();
     await rm(vendorDirectory.path, { force: true, recursive: true });
 });
-test('Loads JSON modules', async () => {
+test('Loads JSON modules with `with` attribute', async () => {
     const { basePath, cleanup, distPath } = await useFixture('imports_json');
     const sourceDirectory = join(basePath, 'functions');
     const declarations = [
@@ -496,6 +497,35 @@ test('Loads JSON modules', async () => {
     await cleanup();
     await rm(vendorDirectory.path, { force: true, recursive: true });
 });
+// We can't run this on versions above 2.0.0 because the bundling will fail
+// entirely, and what we're asserting here is that we emit a system log when
+// import assertions are detected on successful builds. Also, running it on
+// earlier versions won't work either, since those won't even show a warning.
+test.skipIf(lt(denoVersion, '1.46.3') || gte(denoVersion, '2.0.0'))('Emits a system log when import assertions are used', async () => {
+    const { basePath, cleanup, distPath } = await useFixture('with_import_assert');
+    const sourceDirectory = join(basePath, 'functions');
+    const declarations = [
+        {
+            function: 'func1',
+            path: '/func1',
+        },
+    ];
+    const vendorDirectory = await tmp.dir();
+    const systemLogger = vi.fn();
+    await bundle([sourceDirectory], distPath, declarations, {
+        basePath,
+        systemLogger,
+        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(`{"foo":"bar"}`);
+    expect(systemLogger).toHaveBeenCalledWith(`Edge function uses import assertions: ${join(sourceDirectory, 'func1.ts')}`);
+    await cleanup();
+    await rm(vendorDirectory.path, { force: true, recursive: true });
+});
 test('Supports TSX and process.env', async () => {
     const { basePath, cleanup, distPath } = await useFixture('tsx');
     const sourceDirectory = join(basePath, 'functions');
@@ -550,3 +580,72 @@ test('Loads edge functions from the Frameworks API', async () => {
     });
     await cleanup();
 });
+describe.skipIf(lt(denoVersion, '2.4.2'))('Produces a tarball bundle', () => {
+    test('With only local imports', async () => {
+        const systemLogger = vi.fn();
+        const { basePath, cleanup, distPath } = await useFixture('imports_node_builtin', { copyDirectory: true });
+        const declarations = [
+            {
+                function: 'func1',
+                path: '/func1',
+            },
+        ];
+        const vendorDirectory = await tmp.dir();
+        await bundle([join(basePath, 'netlify/edge-functions')], distPath, declarations, {
+            basePath,
+            configPath: join(basePath, '.netlify/edge-functions/config.json'),
+            featureFlags: {
+                edge_bundler_generate_tarball: true,
+            },
+            systemLogger,
+        });
+        expect(systemLogger.mock.calls.find((call) => call[0] === 'Could not track dependencies in edge function:')).toBeUndefined();
+        const expectedOutput = {
+            func1: 'ok',
+        };
+        const manifestFile = await readFile(resolve(distPath, 'manifest.json'), 'utf8');
+        const manifest = JSON.parse(manifestFile);
+        const tarballPath = join(distPath, manifest.bundles[0].asset);
+        const tarballResult = await runTarball(tarballPath);
+        expect(tarballResult).toStrictEqual(expectedOutput);
+        const eszipPath = join(distPath, manifest.bundles[1].asset);
+        const eszipResult = await runESZIP(eszipPath);
+        expect(eszipResult).toStrictEqual(expectedOutput);
+        await cleanup();
+        await rm(vendorDirectory.path, { force: true, recursive: true });
+    });
+    // TODO: https://github.com/denoland/deno/issues/30187
+    test.todo('Using npm modules', async () => {
+        const systemLogger = vi.fn();
+        const { basePath, cleanup, distPath } = await useFixture('imports_npm_module', { copyDirectory: true });
+        const sourceDirectory = join(basePath, 'functions');
+        const declarations = [
+            {
+                function: 'func1',
+                path: '/func1',
+            },
+        ];
+        const vendorDirectory = await tmp.dir();
+        await bundle([sourceDirectory], distPath, declarations, {
+            basePath,
+            featureFlags: {
+                edge_bundler_generate_tarball: true,
+            },
+            importMapPaths: [join(basePath, 'import_map.json')],
+            vendorDirectory: vendorDirectory.path,
+            systemLogger,
+        });
+        expect(systemLogger.mock.calls.find((call) => call[0] === 'Could not track dependencies in edge function:')).toBeUndefined();
+        const expectedOutput = `<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>, TmV0bGlmeQ==`;
+        const manifestFile = await readFile(resolve(distPath, 'manifest.json'), 'utf8');
+        const manifest = JSON.parse(manifestFile);
+        const tarballPath = join(distPath, manifest.bundles[0].asset);
+        const tarballResult = await runTarball(tarballPath);
+        expect(tarballResult.func1).toBe(expectedOutput);
+        const eszipPath = join(distPath, manifest.bundles[1].asset);
+        const eszipResult = await runESZIP(eszipPath, vendorDirectory.path);
+        expect(eszipResult.func1).toBe(expectedOutput);
+        await cleanup();
+        await rm(vendorDirectory.path, { force: true, recursive: true });
+    });
+}, 10000);

package/dist/node/config.js

@@ -37,10 +37,11 @@ export const getFunctionConfig = async ({ func, importMap, deno, log, }) => {
     // the config function to write to stdout and stderr without that interfering
     // with the extractor.
     const collector = await tmp.file();
+    // Retrieving the version of Deno.
+    const version = new SemVer((await deno.getBinaryVersion((await deno.getBinaryPath({ silent: true })).path)) || '');
     // The extractor will use its exit code to signal different error scenarios,
     // based on the list of exit codes we send as an argument. We then capture
     // the exit code to know exactly what happened and guide people accordingly.
-    const version = new SemVer((await deno.getBinaryVersion((await deno.getBinaryPath({ silent: true })).path)) || '');
     const { exitCode, stderr, stdout } = await deno.run([
         'run',
         '--allow-env',
@@ -57,6 +58,9 @@ export const getFunctionConfig = async ({ func, importMap, deno, log, }) => {
         pathToFileURL(collector.path).href,
         JSON.stringify(ConfigExitCode),
     ].filter(Boolean), { rejectOnExitCode: false });
+    if (stderr.includes('Import assertions are deprecated')) {
+        log.system(`Edge function uses import assertions: ${func.path}`);
+    }
     if (exitCode !== ConfigExitCode.Success) {
         handleConfigError(func, exitCode, stderr, log);
         return {};

package/dist/node/feature_flags.d.ts

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

package/dist/node/feature_flags.js

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

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

@@ -0,0 +1,18 @@
+import { DenoBridge } from '../bridge.js';
+import { Bundle } from '../bundle.js';
+import { EdgeFunction } from '../edge_function.js';
+import { FeatureFlags } from '../feature_flags.js';
+import { ImportMap } from '../import_map.js';
+interface BundleTarballOptions {
+    basePath: string;
+    buildID: string;
+    debug?: boolean;
+    deno: DenoBridge;
+    distDirectory: string;
+    featureFlags: FeatureFlags;
+    functions: EdgeFunction[];
+    importMap: ImportMap;
+    vendorDirectory?: string;
+}
+export declare const bundle: ({ basePath, buildID, deno, distDirectory, functions, importMap, vendorDirectory, }: BundleTarballOptions) => Promise<Bundle>;
+export {};

package/dist/node/formats/tarball.js

@@ -0,0 +1,92 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import commonPathPrefix from 'common-path-prefix';
+import * as tar from 'tar';
+import tmp from 'tmp-promise';
+import { BundleFormat } from '../bundle.js';
+import { getDirectoryHash, getStringHash } from '../utils/sha256.js';
+const TARBALL_EXTENSION = '.tar';
+const getUnixPath = (input) => input.split(path.sep).join('/');
+export const bundle = async ({ basePath, buildID, deno, distDirectory, functions, importMap, vendorDirectory, }) => {
+    const sideFilesDir = await tmp.dir({ unsafeCleanup: true });
+    const cleanup = [sideFilesDir.cleanup];
+    let denoDir = vendorDirectory ? path.join(vendorDirectory, 'deno_dir') : undefined;
+    if (!denoDir) {
+        const tmpDir = await tmp.dir({ unsafeCleanup: true });
+        denoDir = tmpDir.path;
+        cleanup.push(tmpDir.cleanup);
+    }
+    const manifest = {
+        functions: {},
+        version: 1,
+    };
+    const entryPoints = functions.map((func) => func.path);
+    // `deno bundle` does not return the paths of the files it emits, so we have
+    // to infer them. When multiple entry points are supplied, it will find the
+    // common path prefix and use that as the base directory in `outdir`. When
+    // using a single entry point, `commonPathPrefix` returns an empty string,
+    // so we use the path of the first entry point's directory.
+    const commonPath = commonPathPrefix(entryPoints) || path.dirname(entryPoints[0]);
+    for (const func of functions) {
+        const relativePath = path.relative(commonPath, func.path);
+        const bundledPath = path.format({
+            ...path.parse(relativePath),
+            base: undefined,
+            ext: '.js',
+        });
+        manifest.functions[func.name] = getUnixPath(bundledPath);
+    }
+    await deno.run([
+        'bundle',
+        '--import-map',
+        importMap.withNodeBuiltins().toDataURL(),
+        '--quiet',
+        '--code-splitting',
+        '--outdir',
+        distDirectory,
+        ...functions.map((func) => func.path),
+    ], {
+        cwd: basePath,
+    });
+    const manifestPath = path.join(sideFilesDir.path, 'manifest.json');
+    const manifestContents = JSON.stringify(manifest);
+    await fs.writeFile(manifestPath, manifestContents);
+    const denoConfigPath = path.join(sideFilesDir.path, 'deno.json');
+    const denoConfigContents = JSON.stringify(importMap.getContentsWithRelativePaths());
+    await fs.writeFile(denoConfigPath, denoConfigContents);
+    const rootLevel = await fs.readdir(distDirectory);
+    const hash = await getDirectoryHash(distDirectory);
+    const tarballPath = path.join(distDirectory, buildID + TARBALL_EXTENSION);
+    await fs.mkdir(path.dirname(tarballPath), { recursive: true });
+    // Adding all the bundled files.
+    await tar.create({
+        cwd: distDirectory,
+        file: tarballPath,
+        onWriteEntry(entry) {
+            entry.path = getUnixPath(`./${entry.path}`);
+        },
+    }, rootLevel);
+    // Adding `deno.json`.
+    await tar.update({
+        cwd: distDirectory,
+        file: tarballPath,
+        onWriteEntry(entry) {
+            entry.path = './deno.json';
+        },
+    }, [denoConfigPath]);
+    // Adding the manifest file.
+    await tar.update({
+        cwd: distDirectory,
+        file: tarballPath,
+        onWriteEntry(entry) {
+            entry.path = './___netlify-edge-functions.json';
+        },
+    }, [manifestPath]);
+    await Promise.all(cleanup);
+    const finalHash = [hash, getStringHash(manifestContents), getStringHash(denoConfigContents)].join('');
+    return {
+        extension: TARBALL_EXTENSION,
+        format: BundleFormat.TARBALL,
+        hash: finalHash,
+    };
+};

package/dist/node/import_map.d.ts

@@ -24,6 +24,10 @@ export declare class ImportMap {
         imports: Imports;
         scopes: {};
     };
+    getContentsWithRelativePaths(): {
+        imports: Imports;
+        scopes: Record<string, Imports>;
+    };
     getContentsWithURLObjects(prefixes?: Record<string, string>): {
         imports: Record<string, URL>;
         scopes: Record<string, Record<string, URL>>;
@@ -34,6 +38,7 @@ export declare class ImportMap {
         scopes: Record<string, Imports>;
     };
     toDataURL(): string;
+    withNodeBuiltins(): this;
     writeToFile(path: string): Promise<void>;
 }
 export {};

package/dist/node/import_map.js

@@ -1,7 +1,8 @@
-import { Buffer } from 'buffer';
-import { promises as fs } from 'fs';
-import { dirname, relative } from 'path';
-import { fileURLToPath, pathToFileURL } from 'url';
+import { Buffer } from 'node:buffer';
+import { promises as fs } from 'node:fs';
+import { builtinModules } from 'node:module';
+import { dirname, relative } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 import { parse } from '@import-maps/resolve';
 import { isFileNotFoundError } from './utils/error.js';
 const INTERNAL_IMPORTS = {
@@ -134,6 +135,24 @@ export class ImportMap {
             scopes: transformedScopes,
         };
     }
+    getContentsWithRelativePaths() {
+        let imports = {};
+        let scopes = {};
+        this.sources.forEach((file) => {
+            imports = { ...imports, ...file.imports };
+            scopes = { ...scopes, ...file.scopes };
+        });
+        // Internal imports must come last, because we need to guarantee that
+        // `netlify:edge` isn't user-defined.
+        Object.entries(INTERNAL_IMPORTS).forEach((internalImport) => {
+            const [specifier, url] = internalImport;
+            imports[specifier] = url;
+        });
+        return {
+            imports,
+            scopes,
+        };
+    }
     // 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.
@@ -182,6 +201,19 @@ export class ImportMap {
         const encodedImportMap = Buffer.from(data).toString('base64');
         return `data:application/json;base64,${encodedImportMap}`;
     }
+    // Adds an import map source mapping Node.js built-in modules to their prefixed
+    // version (e.g. "path" => "node:path").
+    withNodeBuiltins() {
+        const imports = {};
+        for (const name of builtinModules) {
+            imports[name] = `node:${name}`;
+        }
+        this.sources.push({
+            baseURL: new URL(import.meta.url),
+            imports,
+        });
+        return this;
+    }
     async writeToFile(path) {
         const distDirectory = dirname(path);
         await fs.mkdir(distDirectory, { recursive: true });

package/dist/node/npm_dependencies.js

@@ -8,7 +8,7 @@ import { findUp } from 'find-up';
 import { parseImports } from 'parse-imports';
 import tmp from 'tmp-promise';
 import { pathsBetween } from './utils/fs.js';
-const TYPESCRIPT_EXTENSIONS = new Set(['.ts', '.tsx', '.cts', '.ctsx', '.mts', '.mtsx']);
+import { TYPESCRIPT_EXTENSIONS } from './utils/typescript.js';
 const slugifyFileName = (specifier) => {
     return specifier.replace(/\//g, '_');
 };

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

@@ -2,6 +2,11 @@ import { createWriteStream } from 'fs';
 import { readFile } from 'fs/promises';
 import { join } from 'path';
 import process from 'process';
+// @ts-expect-error TypeScript is complaining about the values for the `module`
+// and `moduleResolution` configuration properties, but changing those to more
+// modern values causes other packages to fail. Leaving this for now, but we
+// should have a proper fix for this.
+import { getURL as getBootstrapURL } from '@netlify/edge-functions-bootstrap/version';
 import getPort from 'get-port';
 import tmp from 'tmp-promise';
 import { v4 as uuidv4 } from 'uuid';
@@ -19,7 +24,7 @@ test('Starts a server and serves requests for edge functions', async () => {
     const servePath = join(basePath, '.netlify', 'edge-functions-serve');
     const server = await serve({
         basePath,
-        bootstrapURL: 'https://edge.netlify.com/bootstrap/index-combined.ts',
+        bootstrapURL: await getBootstrapURL(),
         port,
         servePath,
     });
@@ -99,7 +104,7 @@ test('Serves edge functions in a monorepo setup', async () => {
     const servePath = join(basePath, '.netlify', 'edge-functions-serve');
     const server = await serve({
         basePath,
-        bootstrapURL: 'https://edge.netlify.com/bootstrap/index-combined.ts',
+        bootstrapURL: await getBootstrapURL(),
         port,
         rootPath,
         servePath,

package/dist/node/utils/sha256.d.ts

@@ -1,2 +1,3 @@
-declare const getFileHash: (path: string) => Promise<string>;
-export { getFileHash };
+export declare const getDirectoryHash: (dirPath: string) => Promise<string>;
+export declare const getFileHash: (path: string) => Promise<string>;
+export declare const getStringHash: (input: string) => string;

package/dist/node/utils/sha256.js

@@ -1,10 +1,30 @@
-import crypto from 'crypto';
-import fs from 'fs';
-const getFileHash = (path) => {
+import crypto from 'node:crypto';
+import { createReadStream, promises as fs } from 'node:fs';
+import path from 'node:path';
+export const getDirectoryHash = async (dirPath) => {
+    const entries = [];
+    async function walk(currentPath) {
+        const dirents = await fs.readdir(currentPath, { withFileTypes: true });
+        for (const dirent of dirents) {
+            const fullPath = path.join(currentPath, dirent.name);
+            const relativePath = path.relative(dirPath, fullPath);
+            if (dirent.isDirectory()) {
+                await walk(fullPath);
+            }
+            else if (dirent.isFile() || dirent.isSymbolicLink()) {
+                const fileHash = await getFileHash(fullPath);
+                entries.push(`${relativePath}:${fileHash}`);
+            }
+        }
+    }
+    await walk(dirPath);
+    return getStringHash(entries.sort((a, b) => a.localeCompare(b)).join('\n'));
+};
+export const getFileHash = (path) => {
     const hash = crypto.createHash('sha256');
     hash.setEncoding('hex');
     return new Promise((resolve, reject) => {
-        const file = fs.createReadStream(path);
+        const file = createReadStream(path);
         file.on('end', () => {
             hash.end();
             resolve(hash.read());
@@ -13,4 +33,9 @@ const getFileHash = (path) => {
         file.pipe(hash);
     });
 };
-export { getFileHash };
+export const getStringHash = (input) => {
+    const hash = crypto.createHash('sha256');
+    hash.setEncoding('hex');
+    hash.update(input);
+    return hash.digest('hex');
+};

package/dist/node/utils/typescript.d.ts

@@ -0,0 +1 @@
+export declare const TYPESCRIPT_EXTENSIONS: Set<string>;

package/dist/node/utils/typescript.js

@@ -0,0 +1 @@
+export const TYPESCRIPT_EXTENSIONS = new Set(['.ts', '.tsx', '.cts', '.ctsx', '.mts', '.mtsx']);

package/dist/test/util.d.ts

@@ -1,11 +1,20 @@
 import type { Manifest } from '../node/manifest.js';
-declare const testLogger: import("../node/logger.js").Logger;
-declare const fixturesDir: string;
-declare const useFixture: (fixtureName: string) => Promise<{
+export declare const testLogger: import("../node/logger.js").Logger;
+export declare const fixturesDir: string;
+interface UseFixtureOptions {
+    copyDirectory?: boolean;
+}
+export declare const useFixture: (fixtureName: string, { copyDirectory }?: UseFixtureOptions) => Promise<{
+    basePath: string;
+    cleanup: () => Promise<[PromiseSettledResult<() => Promise<void>>, PromiseSettledResult<() => Promise<void>>]>;
+    distPath: string;
+} | {
     basePath: string;
     cleanup: () => Promise<void>;
     distPath: string;
 }>;
-declare const getRouteMatcher: (manifest: Manifest) => (candidate: string) => import("../node/manifest.js").Route | undefined;
-declare const runESZIP: (eszipPath: string, vendorDirectory?: string) => Promise<any>;
-export { fixturesDir, getRouteMatcher, testLogger, runESZIP, useFixture };
+export declare const getRouteMatcher: (manifest: Manifest) => (candidate: string) => import("../node/manifest.js").Route | undefined;
+export declare const runESZIP: (eszipPath: string, vendorDirectory?: string) => Promise<any>;
+export declare const runTarball: (tarballPath: string) => Promise<any>;
+export declare const denoVersion: string;
+export {};

package/dist/test/util.js

@@ -1,27 +1,40 @@
-import { promises as fs } from 'fs';
-import { join, resolve } from 'path';
-import { stderr, stdout } from 'process';
-import { fileURLToPath, pathToFileURL } from 'url';
+import { execSync } from 'node:child_process';
+import { promises as fs } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { stderr, stdout } from 'node:process';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import cpy from 'cpy';
 import { execa } from 'execa';
+import * as tar from 'tar';
 import tmp from 'tmp-promise';
 import { getLogger } from '../node/logger.js';
-const testLogger = getLogger(() => {
+export const testLogger = getLogger(() => {
     // no-op
 });
 const url = new URL(import.meta.url);
 const dirname = fileURLToPath(url);
-const fixturesDir = resolve(dirname, '..', 'fixtures');
-const useFixture = async (fixtureName) => {
-    const tmpDir = await tmp.dir({ unsafeCleanup: true });
+export const fixturesDir = resolve(dirname, '..', 'fixtures');
+export const useFixture = async (fixtureName, { copyDirectory } = {}) => {
+    const tmpDistDir = await tmp.dir({ unsafeCleanup: true });
     const fixtureDir = resolve(fixturesDir, fixtureName);
-    const distPath = join(tmpDir.path, '.netlify', 'edge-functions-dist');
+    const distPath = join(tmpDistDir.path, '.netlify', 'edge-functions-dist');
+    if (copyDirectory) {
+        const tmpFixtureDir = await tmp.dir({ unsafeCleanup: true });
+        // TODO: Replace with `fs.cp` once the Node.js version range allows.
+        await cpy(`${fixtureDir}/**`, tmpFixtureDir.path);
+        return {
+            basePath: tmpFixtureDir.path,
+            cleanup: () => Promise.allSettled([tmpDistDir.cleanup, tmpFixtureDir.cleanup]),
+            distPath,
+        };
+    }
     return {
         basePath: fixtureDir,
-        cleanup: tmpDir.cleanup,
+        cleanup: tmpDistDir.cleanup,
         distPath,
     };
 };
-const inspectFunction = (path) => `
+const inspectESZIPFunction = (path) => `
   import { functions } from "${pathToFileURL(path)}.js";
 
   const responses = {};
@@ -35,7 +48,25 @@ const inspectFunction = (path) => `
   
   console.log(JSON.stringify(responses));
 `;
-const getRouteMatcher = (manifest) => (candidate) => manifest.routes.find((route) => {
+const inspectTarballFunction = () => `
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import manifest from "./___netlify-edge-functions.json" with { type: "json" };
+
+const responses = {};
+
+for (const functionName in manifest.functions) {
+  const req = new Request("https://test.netlify");
+  const entrypoint = path.resolve(manifest.functions[functionName]);
+  const func = await import(pathToFileURL(entrypoint))
+  const res = await func.default(req);
+
+  responses[functionName] = await res.text();
+}
+
+console.log(JSON.stringify(responses));
+`;
+export const getRouteMatcher = (manifest) => (candidate) => manifest.routes.find((route) => {
     var _a, _b;
     const regex = new RegExp(route.pattern);
     if (!regex.test(candidate)) {
@@ -48,13 +79,14 @@ const getRouteMatcher = (manifest) => (candidate) => manifest.routes.find((route
     const isExcluded = excludedPatterns.some((pattern) => new RegExp(pattern).test(candidate));
     return !isExcluded;
 });
-const runESZIP = async (eszipPath, vendorDirectory) => {
+export const runESZIP = async (eszipPath, vendorDirectory) => {
     var _a, _b, _c;
     const tmpDir = await tmp.dir({ unsafeCleanup: true });
     // Extract ESZIP into temporary directory.
     const extractCommand = execa('deno', [
         'run',
         '--allow-all',
+        '--no-lock',
         'https://deno.land/x/eszip@v0.55.2/eszip.ts',
         'x',
         eszipPath,
@@ -76,10 +108,25 @@ const runESZIP = async (eszipPath, vendorDirectory) => {
     }
     await fs.rename(stage2Path, `${stage2Path}.js`);
     // Run function that imports the extracted stage 2 and invokes each function.
-    const evalCommand = execa('deno', ['eval', '--import-map', importMapPath, inspectFunction(stage2Path)]);
+    const evalCommand = execa('deno', ['eval', '--import-map', importMapPath, inspectESZIPFunction(stage2Path)]);
     (_c = evalCommand.stderr) === null || _c === void 0 ? void 0 : _c.pipe(stderr);
     const result = await evalCommand;
     await tmpDir.cleanup();
     return JSON.parse(result.stdout);
 };
-export { fixturesDir, getRouteMatcher, testLogger, runESZIP, useFixture };
+export const runTarball = async (tarballPath) => {
+    var _a;
+    const tmpDir = await tmp.dir({ unsafeCleanup: true });
+    await tar.extract({
+        cwd: tmpDir.path,
+        file: tarballPath,
+    });
+    const evalCommand = execa('deno', ['eval', inspectTarballFunction()], {
+        cwd: tmpDir.path,
+    });
+    (_a = evalCommand.stderr) === null || _a === void 0 ? void 0 : _a.pipe(stderr);
+    const result = await evalCommand;
+    await tmpDir.cleanup();
+    return JSON.parse(result.stdout);
+};
+export const denoVersion = execSync('deno eval --no-lock "console.log(Deno.version.deno)"').toString();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "14.2.2",
+  "version": "14.4.0",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",
@@ -42,6 +42,7 @@
     "test": "test/node"
   },
   "devDependencies": {
+    "@netlify/edge-functions-bootstrap": "^2.14.0",
     "@types/node": "^18.19.111",
     "@types/semver": "^7.3.9",
     "@types/uuid": "^10.0.0",
@@ -51,7 +52,6 @@
     "cpy": "^11.1.0",
     "nock": "^14.0.0",
     "npm-run-all2": "^6.0.0",
-    "tar": "^7.0.0",
     "typescript": "^5.0.0",
     "vitest": "^3.0.0"
   },
@@ -77,9 +77,10 @@
     "parse-imports": "^2.2.1",
     "path-key": "^4.0.0",
     "semver": "^7.3.8",
+    "tar": "^7.4.3",
     "tmp-promise": "^3.0.3",
     "urlpattern-polyfill": "8.0.2",
     "uuid": "^11.0.0"
   },
-  "gitHead": "8b7583e1890636bd64b54e20aee40ae5365edeaf"
+  "gitHead": "1f098009f518b66b0d6604910aff38824d7f9a69"
 }