@netlify/edge-bundler 14.5.5 → 14.6.0

package/deno/extract.ts

@@ -0,0 +1,7 @@
+import { loadESZIP } from 'https://deno.land/x/eszip@v0.55.2/eszip.ts'
+
+const [functionPath, destPath] = Deno.args
+
+const eszip = await loadESZIP(functionPath)
+
+await eszip.extract(destPath)

package/deno/lib/stage2.ts

@@ -105,7 +105,7 @@ const stage2Loader = (
   }
 }
 
-const writeStage2 = async ({
+export const writeStage2 = async ({
   basePath,
   destPath,
   externals,
@@ -122,5 +122,3 @@ const writeStage2 = async ({
 
   return await Deno.writeFile(destPath, bytes)
 }
-
-export { writeStage2 }

package/deno/vendor/deno.land/x/eszip@v0.55.2/eszip.ts

@@ -0,0 +1,189 @@
+// CLI utility to build/list/extract/run ESZIPs
+
+import { build, Parser } from "./mod.ts";
+import { dirname, join } from "https://deno.land/std@0.177.0/path/mod.ts";
+
+function hasV2Header(bytes: Uint8Array) {
+  const magicV2 = new TextDecoder().decode(bytes.slice(0, 8));
+  return magicV2 === "ESZIP_V2";
+}
+
+interface ESZIP {
+  extract(dest: string): Promise<void>;
+  list(): string[];
+}
+
+interface V1Entry {
+  Source: {
+    source: string;
+    transpiled: string;
+  };
+}
+
+class V1 {
+  inner: Record<string, V1Entry>;
+
+  constructor(bytes: Uint8Array) {
+    const json = new TextDecoder().decode(bytes);
+    const eszip = JSON.parse(json);
+    this.inner = eszip;
+  }
+
+  static load(bytes: Uint8Array) {
+    return Promise.resolve(new V1(bytes));
+  }
+
+  *entries() {
+    for (
+      const [
+        url,
+        {
+          Source: { source, transpiled },
+        },
+      ] of Object.entries(this.inner.modules)
+    ) {
+      yield { url, source, transpiled };
+    }
+  }
+
+  async extract(dest: string) {
+    for (const { url, source, transpiled } of this.entries()) {
+      await write(join(dest, "source", url2path(url)), source);
+      await write(
+        join(dest, "transpiled", url2path(url)),
+        transpiled ?? source,
+      );
+    }
+  }
+
+  list() {
+    return Array.from(this.entries()).map((e) => e.url);
+  }
+}
+
+class V2 {
+  parser: Parser;
+  specifiers: string[];
+
+  constructor(parser: Parser, specifiers: string[]) {
+    this.parser = parser;
+    this.specifiers = specifiers;
+  }
+
+  static async load(bytes: Uint8Array) {
+    const parser = await Parser.createInstance();
+    const specifiers = await parser.parseBytes(bytes);
+    await parser.load();
+    return new V2(parser, specifiers as string[]);
+  }
+
+  async extract(dest: string) {
+    const imports: Record<string, string> = {};
+
+    for (const specifier of this.specifiers) {
+      const module = await this.parser.getModuleSource(specifier);
+      await write(join(dest, "source", url2path(specifier)), module);
+      // Track import
+      imports[specifier] = `./${url2path(specifier)}`;
+    }
+    // Write import map
+    const importMap = JSON.stringify({ imports }, null, 2);
+    await Deno.writeTextFile(
+      join(dest, "source", "import_map.json"),
+      importMap,
+    );
+  }
+
+  list() {
+    return this.specifiers;
+  }
+}
+
+export async function loadESZIP(filename: string): Promise<ESZIP> {
+  const bytes = await Deno.readFile(filename);
+  if (hasV2Header(bytes)) {
+    return await V2.load(bytes);
+  }
+  return await V1.load(bytes);
+}
+
+function url2path(url: string) {
+  return join(...(new URL(url).pathname.split("/").filter(Boolean)));
+}
+
+async function write(path: string, content: string) {
+  await Deno.mkdir(dirname(path), { recursive: true });
+  await Deno.writeTextFile(path, content);
+}
+
+async function run(eszip: ESZIP, specifier: string) {
+  // Extract to tmp directory
+  const tmpDir = await Deno.makeTempDir({ prefix: "esz" });
+  try {
+    // Extract
+    await eszip.extract(tmpDir);
+    const importMap = join(tmpDir, "source", "import_map.json");
+    // Run
+    const p = new Deno.Command("deno", {
+      args: [
+        "run",
+        "-A",
+        "--no-check",
+        "--import-map",
+        importMap,
+        specifier,
+      ],
+    });
+    await p.output();
+  } finally {
+    // Cleanup
+    await Deno.remove(tmpDir, { recursive: true });
+  }
+}
+
+// Main
+async function main() {
+  const args = Deno.args;
+  const [subcmd, filename, ...rest] = args;
+
+  if (subcmd === "help") {
+    return console.log("TODO");
+  }
+
+  switch (subcmd) {
+    case "build":
+    case "b": {
+      const eszip = await build([filename]);
+      let out = rest[0];
+      if (!out) {
+        // Create outfile name from url filename
+        out = new URL(filename).pathname.split("/").pop() || "out";
+      }
+      console.log(`${out}.eszip: ${eszip.length} bytes`);
+      await Deno.writeFile(`${out}.eszip`, eszip);
+      return;
+    }
+    case "x":
+    case "extract": {
+      const eszip = await loadESZIP(filename);
+      return await eszip.extract(rest[0] ?? Deno.cwd());
+    }
+    case "l":
+    case "ls":
+    case "list": {
+      const eszip = await loadESZIP(filename);
+      return console.log(eszip.list().join("\n"));
+    }
+    case "r":
+    case "run": {
+      const eszip = await loadESZIP(filename);
+      const specifier = rest[0];
+      if (!specifier) {
+        return console.error("Please provide a specifier to run");
+      }
+      return await run(eszip, specifier);
+    }
+  }
+}
+
+await main();

package/dist/node/bridge.d.ts

@@ -2,7 +2,7 @@ import { type WriteStream } from 'fs';
 import { type ExecaChildProcess } from 'execa';
 import { FeatureFlags } from './feature_flags.js';
 import { Logger } from './logger.js';
-export declare const DENO_VERSION_RANGE = "1.39.0 - 2.2.4";
+export declare const DENO_VERSION_RANGE = "^2.4.2";
 export type OnBeforeDownloadHook = () => void | Promise<void>;
 export type OnAfterDownloadHook = (error?: Error) => void | Promise<void>;
 export interface DenoOptions {

package/dist/node/bridge.js

@@ -12,24 +12,29 @@ 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
-export const DENO_VERSION_RANGE = '1.39.0 - 2.2.4';
-const NEXT_DENO_VERSION_RANGE = '^2.4.2';
+export const DENO_VERSION_RANGE = '^2.4.2';
 export class DenoBridge {
+    cacheDirectory;
+    currentDownload;
+    debug;
+    denoDir;
+    logger;
+    onAfterDownload;
+    onBeforeDownload;
+    useGlobal;
+    versionRange;
     constructor(options) {
-        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.cacheDirectory = options.cacheDirectory ?? getPathInHome('deno-cli');
+        this.debug = options.debug ?? false;
         this.denoDir = options.denoDir;
-        this.logger = (_c = options.logger) !== null && _c !== void 0 ? _c : getLogger(undefined, undefined, options.debug);
+        this.logger = options.logger ?? getLogger(undefined, undefined, options.debug);
         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 : (((_f = options.featureFlags) === null || _f === void 0 ? void 0 : _f.edge_bundler_generate_tarball) ? NEXT_DENO_VERSION_RANGE : DENO_VERSION_RANGE);
+        this.useGlobal = options.useGlobal ?? true;
+        this.versionRange = options.versionRange ?? DENO_VERSION_RANGE;
     }
     async downloadBinary() {
-        var _a, _b, _c;
-        await ((_a = this.onBeforeDownload) === null || _a === void 0 ? void 0 : _a.call(this));
+        await this.onBeforeDownload?.();
         await this.ensureCacheDirectory();
         this.logger.system(`Downloading Deno CLI to ${this.cacheDirectory}`);
         const binaryPath = await download(this.cacheDirectory, this.versionRange, this.logger);
@@ -39,12 +44,12 @@ export class DenoBridge {
         // that the tests catch it.
         if (downloadedVersion === undefined) {
             const error = new Error('There was a problem setting up the Edge Functions environment. To try a manual installation, visit https://ntl.fyi/install-deno.');
-            await ((_b = this.onAfterDownload) === null || _b === void 0 ? void 0 : _b.call(this, error));
+            await this.onAfterDownload?.(error);
             this.logger.system('Could not run downloaded Deno CLI', error);
             throw error;
         }
         await this.writeVersionFile(downloadedVersion);
-        await ((_c = this.onAfterDownload) === null || _c === void 0 ? void 0 : _c.call(this));
+        await this.onAfterDownload?.();
         return binaryPath;
     }
     async getBinaryVersion(binaryPath) {
@@ -97,19 +102,18 @@ export class DenoBridge {
         return this.currentDownload;
     }
     static runWithBinary(binaryPath, args, { options, pipeOutput, stderr, stdout, }) {
-        var _a, _b, _c, _d;
         const runDeno = execa(binaryPath, args, options);
         if (stderr) {
-            (_a = runDeno.stderr) === null || _a === void 0 ? void 0 : _a.pipe(stderr);
+            runDeno.stderr?.pipe(stderr);
         }
         else if (pipeOutput) {
-            (_b = runDeno.stderr) === null || _b === void 0 ? void 0 : _b.pipe(process.stderr);
+            runDeno.stderr?.pipe(process.stderr);
         }
         if (stdout) {
-            (_c = runDeno.stdout) === null || _c === void 0 ? void 0 : _c.pipe(stdout);
+            runDeno.stdout?.pipe(stdout);
         }
         else if (pipeOutput) {
-            (_d = runDeno.stdout) === null || _d === void 0 ? void 0 : _d.pipe(process.stdout);
+            runDeno.stdout?.pipe(process.stdout);
         }
         return runDeno;
     }
@@ -124,14 +128,14 @@ export class DenoBridge {
     async getBinaryPath(options) {
         const globalPath = await this.getGlobalBinary();
         if (globalPath !== undefined) {
-            if (!(options === null || options === void 0 ? void 0 : options.silent)) {
+            if (!options?.silent) {
                 this.logger.system('Using global installation of Deno CLI');
             }
             return { global: true, path: globalPath };
         }
         const cachedPath = await this.getCachedBinary();
         if (cachedPath !== undefined) {
-            if (!(options === null || options === void 0 ? void 0 : options.silent)) {
+            if (!options?.silent) {
                 this.logger.system('Using cached Deno CLI from', cachedPath);
             }
             return { global: false, path: cachedPath };

package/dist/node/bridge.test.js

@@ -12,8 +12,7 @@ import { getPlatformTarget } from './platform.js';
 const require = createRequire(import.meta.url);
 const archiver = require('archiver');
 const getMockDenoBridge = function (tmpDir, mockBinaryOutput) {
-    var _a, _b;
-    const latestVersion = (_b = (_a = semver.minVersion(DENO_VERSION_RANGE)) === null || _a === void 0 ? void 0 : _a.version) !== null && _b !== void 0 ? _b : '';
+    const latestVersion = semver.minVersion(DENO_VERSION_RANGE)?.version ?? '';
     const data = new PassThrough();
     const archive = archiver('zip', { zlib: { level: 9 } });
     archive.pipe(data);
@@ -32,7 +31,6 @@ const getMockDenoBridge = function (tmpDir, mockBinaryOutput) {
     });
 };
 test('Does not inherit environment variables if `extendEnv` is false', async () => {
-    var _a;
     const tmpDir = await tmp.dir();
     const deno = getMockDenoBridge(tmpDir, `#!/usr/bin/env sh
 
@@ -46,9 +44,9 @@ test('Does not inherit environment variables if `extendEnv` is false', async ()
     const referenceOutput = await deno.run(['test'], { env: {}, extendEnv: false });
     env.TADA = 'TUDU';
     const result = await deno.run(['test'], { env: { LULU: 'LALA' }, extendEnv: false });
-    let output = (_a = result === null || result === void 0 ? void 0 : result.stdout) !== null && _a !== void 0 ? _a : '';
+    let output = result?.stdout ?? '';
     delete env.TADA;
-    referenceOutput === null || referenceOutput === void 0 ? void 0 : referenceOutput.stdout.split('\n').forEach((line) => {
+    referenceOutput?.stdout.split('\n').forEach((line) => {
         output = output.replace(line.trim(), '');
     });
     output = output.trim().replace(/\n+/g, '\n');
@@ -56,7 +54,6 @@ test('Does not inherit environment variables if `extendEnv` is false', async ()
     await rm(tmpDir.path, { force: true, recursive: true, maxRetries: 10 });
 });
 test('Does inherit environment variables if `extendEnv` is true', async () => {
-    var _a;
     const tmpDir = await tmp.dir();
     const deno = getMockDenoBridge(tmpDir, `#!/usr/bin/env sh
 
@@ -70,9 +67,9 @@ test('Does inherit environment variables if `extendEnv` is true', async () => {
     const referenceOutput = await deno.run(['test'], { env: {}, extendEnv: true });
     env.TADA = 'TUDU';
     const result = await deno.run(['test'], { env: { LULU: 'LALA' }, extendEnv: true });
-    let output = (_a = result === null || result === void 0 ? void 0 : result.stdout) !== null && _a !== void 0 ? _a : '';
+    let output = result?.stdout ?? '';
     delete env.TADA;
-    referenceOutput === null || referenceOutput === void 0 ? void 0 : referenceOutput.stdout.split('\n').forEach((line) => {
+    referenceOutput?.stdout.split('\n').forEach((line) => {
         output = output.replace(line.trim(), '');
     });
     // lets remove holes, split lines and sort lines by name, as different OSes might order them different
@@ -81,7 +78,6 @@ test('Does inherit environment variables if `extendEnv` is true', async () => {
     await rm(tmpDir.path, { force: true, recursive: true, maxRetries: 10 });
 });
 test('Does inherit environment variables if `extendEnv` is not set', async () => {
-    var _a;
     const tmpDir = await tmp.dir();
     const deno = getMockDenoBridge(tmpDir, `#!/usr/bin/env sh
 
@@ -95,9 +91,9 @@ test('Does inherit environment variables if `extendEnv` is not set', async () =>
     const referenceOutput = await deno.run(['test'], { env: {}, extendEnv: true });
     env.TADA = 'TUDU';
     const result = await deno.run(['test'], { env: { LULU: 'LALA' } });
-    let output = (_a = result === null || result === void 0 ? void 0 : result.stdout) !== null && _a !== void 0 ? _a : '';
+    let output = result?.stdout ?? '';
     delete env.TADA;
-    referenceOutput === null || referenceOutput === void 0 ? void 0 : referenceOutput.stdout.split('\n').forEach((line) => {
+    referenceOutput?.stdout.split('\n').forEach((line) => {
         output = output.replace(line.trim(), '');
     });
     // lets remove holes, split lines and sort lines by name, as different OSes might order them different

package/dist/node/bundle_error.d.ts

@@ -1,5 +1,6 @@
 interface BundleErrorOptions {
-    format: string;
+    cause?: unknown;
+    format?: string;
 }
 declare const getCustomErrorInfo: (options?: BundleErrorOptions) => {
     location: {
@@ -8,12 +9,12 @@ declare const getCustomErrorInfo: (options?: BundleErrorOptions) => {
     };
     type: string;
 };
-declare class BundleError extends Error {
+export declare class BundleError extends Error {
     customErrorInfo: ReturnType<typeof getCustomErrorInfo>;
     constructor(originalError: Error, options?: BundleErrorOptions);
 }
 /**
  * BundleErrors are treated as user-error, so Netlify Team is not alerted about them.
  */
-declare const wrapBundleError: (input: unknown, options?: BundleErrorOptions) => unknown;
-export { BundleError, wrapBundleError };
+export declare const wrapBundleError: (input: unknown, options?: BundleErrorOptions) => unknown;
+export {};

package/dist/node/bundle_error.js

@@ -1,13 +1,14 @@
 const getCustomErrorInfo = (options) => ({
     location: {
-        format: options === null || options === void 0 ? void 0 : options.format,
+        format: options?.format,
         runtime: 'deno',
     },
     type: 'functionsBundling',
 });
-class BundleError extends Error {
+export class BundleError extends Error {
+    customErrorInfo;
     constructor(originalError, options) {
-        super(originalError.message);
+        super(originalError.message, { cause: options?.cause });
         this.customErrorInfo = getCustomErrorInfo(options);
         this.name = 'BundleError';
         this.stack = originalError.stack;
@@ -18,7 +19,7 @@ class BundleError extends Error {
 /**
  * BundleErrors are treated as user-error, so Netlify Team is not alerted about them.
  */
-const wrapBundleError = (input, options) => {
+export const wrapBundleError = (input, options) => {
     if (input instanceof Error) {
         if (input.message.includes("The module's source code could not be parsed")) {
             input.message = input.stderr;
@@ -27,4 +28,3 @@ const wrapBundleError = (input, options) => {
     }
     return input;
 };
-export { BundleError, wrapBundleError };

package/dist/node/bundler.js

@@ -1,5 +1,5 @@
 import { promises as fs } from 'fs';
-import { join } from 'path';
+import { join, relative } from 'path';
 import commonPathPrefix from 'common-path-prefix';
 import { v4 as uuidv4 } from 'uuid';
 import { importMapSpecifier } from '../shared/consts.js';
@@ -9,7 +9,7 @@ import { mergeDeclarations } from './declaration.js';
 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 bundleESZIP, extension as eszipExtension, extract as extractESZIP } from './formats/eszip.js';
 import { bundle as bundleTarball } from './formats/tarball.js';
 import { ImportMap } from './import_map.js';
 import { getLogger } from './logger.js';
@@ -47,7 +47,7 @@ export const bundle = async (sourceDirectories, distDirectory, tomlDeclarations
     const internalSrcFolders = (Array.isArray(internalSrcFolder) ? internalSrcFolder : [internalSrcFolder]).filter(nonNullable);
     const userSourceDirectories = sourceDirectories.filter((dir) => !internalSrcFolders.includes(dir));
     const importMap = new ImportMap();
-    await importMap.addFiles([deployConfig === null || deployConfig === void 0 ? void 0 : deployConfig.importMap, ...importMapPaths], logger);
+    await importMap.addFiles([deployConfig?.importMap, ...importMapPaths], logger);
     const userFunctions = userSourceDirectories.length === 0 ? [] : await findFunctions(userSourceDirectories);
     const internalFunctions = internalSrcFolder ? await findFunctions(internalSrcFolders) : [];
     const functions = [...internalFunctions, ...userFunctions];
@@ -57,7 +57,7 @@ export const bundle = async (sourceDirectories, distDirectory, tomlDeclarations
         functions,
         importMap,
         logger,
-        rootPath: rootPath !== null && rootPath !== void 0 ? rootPath : basePath,
+        rootPath: rootPath ?? basePath,
         vendorDirectory,
     });
     const bundles = [];
@@ -71,7 +71,7 @@ export const bundle = async (sourceDirectories, distDirectory, tomlDeclarations
             functions,
             featureFlags,
             importMap: importMap.clone(),
-            vendorDirectory: vendor === null || vendor === void 0 ? void 0 : vendor.directory,
+            vendorDirectory: vendor?.directory,
         }));
     }
     if (vendor) {
@@ -87,19 +87,22 @@ export const bundle = async (sourceDirectories, distDirectory, tomlDeclarations
         functions,
         featureFlags,
         importMap,
-        vendorDirectory: vendor === null || vendor === void 0 ? void 0 : vendor.directory,
+        vendorDirectory: 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(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 })]);
-    const userConfigPromises = userFunctions.map(async (func) => [func.name, await getFunctionConfig({ func, importMap, deno, log: logger })]);
-    // Creating a hash of function names to configuration objects.
-    const internalFunctionsWithConfig = Object.fromEntries(await Promise.all(internalConfigPromises));
-    const userFunctionsWithConfig = Object.fromEntries(await Promise.all(userConfigPromises));
+    const bundlePaths = await createFinalBundles(bundles, distDirectory, buildID);
+    const eszipPath = bundlePaths.find((path) => path.endsWith(eszipExtension));
+    const { internalFunctions: internalFunctionsWithConfig, userFunctions: userFunctionsWithConfig } = await getFunctionConfigs({
+        basePath,
+        deno,
+        eszipPath,
+        importMap,
+        internalFunctions,
+        log: logger,
+        userFunctions,
+    });
     // Creating a final declarations array by combining the TOML file with the
     // deploy configuration API and the in-source configuration.
     const declarations = mergeDeclarations(tomlDeclarations, userFunctionsWithConfig, internalFunctionsWithConfig, deployConfig.declarations, featureFlags);
@@ -118,19 +121,54 @@ export const bundle = async (sourceDirectories, distDirectory, tomlDeclarations
         importMap: importMapSpecifier,
         layers: deployConfig.layers,
     });
-    await (vendor === null || vendor === void 0 ? void 0 : vendor.cleanup());
+    await vendor?.cleanup();
     if (distImportMapPath) {
         await importMap.writeToFile(distImportMapPath);
     }
     return { functions, manifest };
 };
+const getFunctionConfigs = async ({ basePath, deno, eszipPath, importMap, log, internalFunctions, userFunctions, }) => {
+    try {
+        const internalConfigPromises = internalFunctions.map(async (func) => [func.name, await getFunctionConfig({ functionPath: func.path, importMap, deno, log })]);
+        const userConfigPromises = userFunctions.map(async (func) => [func.name, await getFunctionConfig({ functionPath: func.path, importMap, deno, log })]);
+        // Creating a hash of function names to configuration objects.
+        const internalFunctionsWithConfig = Object.fromEntries(await Promise.all(internalConfigPromises));
+        const userFunctionsWithConfig = Object.fromEntries(await Promise.all(userConfigPromises));
+        return {
+            internalFunctions: internalFunctionsWithConfig,
+            userFunctions: userFunctionsWithConfig,
+        };
+    }
+    catch (err) {
+        if (!(err instanceof Error && err.cause === 'IMPORT_ASSERT') || !eszipPath) {
+            throw err;
+        }
+        // We failed to extract the configuration because there is an import assert
+        // in the function code, a deprecated feature that we used to support with
+        // Deno 1.x. To avoid a breaking change, we treat this error as a special
+        // case, using the generated ESZIP to extract the configuration. This works
+        // because import asserts are transpiled to import attributes.
+        const extractedESZIP = await extractESZIP(deno, eszipPath);
+        const configs = await Promise.all([...internalFunctions, ...userFunctions].map(async (func) => {
+            const relativePath = relative(basePath, func.path);
+            const functionPath = join(extractedESZIP.path, relativePath);
+            return [func.name, await getFunctionConfig({ functionPath, importMap, deno, log })];
+        }));
+        await extractedESZIP.cleanup();
+        return {
+            internalFunctions: Object.fromEntries(configs.slice(0, internalFunctions.length)),
+            userFunctions: Object.fromEntries(configs.slice(internalFunctions.length)),
+        };
+    }
+};
 const createFinalBundles = async (bundles, distDirectory, buildID) => {
     const renamingOps = bundles.map(async ({ extension, hash }) => {
         const tempBundlePath = join(distDirectory, `${buildID}${extension}`);
         const finalBundlePath = join(distDirectory, `${hash}${extension}`);
         await fs.rename(tempBundlePath, finalBundlePath);
+        return finalBundlePath;
     });
-    await Promise.all(renamingOps);
+    return await Promise.all(renamingOps);
 };
 const getBasePath = (sourceDirectories, inputBasePath) => {
     // If there's a specific base path supplied, that takes precedence.
@@ -148,11 +186,11 @@ const getBasePath = (sourceDirectories, inputBasePath) => {
 // declaration level. We want these properties to live at the function level
 // in their config object, so we translate that for backwards-compatibility.
 const mergeWithDeclarationConfig = ({ functionName, config, declarations }) => {
-    const declaration = declarations === null || declarations === void 0 ? void 0 : declarations.find((decl) => decl.function === functionName);
+    const declaration = declarations?.find((decl) => decl.function === functionName);
     return {
         ...config,
-        name: (declaration === null || declaration === void 0 ? void 0 : declaration.name) || config.name,
-        generator: (declaration === null || declaration === void 0 ? void 0 : declaration.generator) || config.generator,
+        name: declaration?.name || config.name,
+        generator: declaration?.generator || config.generator,
     };
 };
 const addGeneratorFallback = (config) => ({

package/dist/node/bundler.test.js

@@ -3,7 +3,7 @@ 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 { lt } from 'semver';
 import * as tar from 'tar';
 import tmp from 'tmp-promise';
 import { test, expect, vi, describe } from 'vitest';
@@ -498,22 +498,12 @@ test('Loads JSON modules with `with` attribute', 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 () => {
+test('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, {
+    await bundle([sourceDirectory], distPath, [], {
         basePath,
         systemLogger,
         vendorDirectory: vendorDirectory.path,
@@ -524,6 +514,12 @@ test.skipIf(lt(denoVersion, '1.46.3') || gte(denoVersion, '2.0.0'))('Emits a sys
     const { func1 } = await runESZIP(bundlePath, vendorDirectory.path);
     expect(func1).toBe(`{"foo":"bar"}`);
     expect(systemLogger).toHaveBeenCalledWith(`Edge function uses import assertions: ${join(sourceDirectory, 'func1.ts')}`);
+    expect(manifest.routes[0]).toEqual({
+        function: 'func1',
+        pattern: '^/with-import-assert/?$',
+        excluded_patterns: [],
+        path: '/with-import-assert',
+    });
     await cleanup();
     await rm(vendorDirectory.path, { force: true, recursive: true });
 });
@@ -581,7 +577,7 @@ test('Loads edge functions from the Frameworks API', async () => {
     });
     await cleanup();
 });
-describe.skipIf(lt(denoVersion, '2.4.2'))('Produces a tarball bundle', () => {
+describe.skipIf(lt(denoVersion, '2.4.3'))('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 });
@@ -623,8 +619,7 @@ describe.skipIf(lt(denoVersion, '2.4.2'))('Produces a tarball bundle', () => {
         await cleanup();
         await rm(vendorDirectory.path, { force: true, recursive: true });
     });
-    // TODO: https://github.com/denoland/deno/issues/30187
-    test.todo('Using npm modules', async () => {
+    test('Using npm and remote modules', async () => {
         const systemLogger = vi.fn();
         const { basePath, cleanup, distPath } = await useFixture('imports_npm_module', { copyDirectory: true });
         const sourceDirectory = join(basePath, 'functions');
@@ -657,4 +652,4 @@ describe.skipIf(lt(denoVersion, '2.4.2'))('Produces a tarball bundle', () => {
         await cleanup();
         await rm(vendorDirectory.path, { force: true, recursive: true });
     });
-}, 10000);
+}, 10_000);