@netlify/edge-bundler 9.4.1 → 10.0.0

package/deno/vendor/deno.land/x/wasmbuild@0.15.1/cache.ts

@@ -0,0 +1,157 @@
+// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
+import { default as localDataDir } from "https://deno.land/x/dir@1.5.1/data_local_dir/mod.ts";
+
+export async function cacheToLocalDir(
+  url: URL,
+  decompress: (bytes: Uint8Array) => Uint8Array,
+) {
+  const localPath = await getUrlLocalPath(url);
+  if (localPath == null) {
+    return undefined;
+  }
+  if (!await exists(localPath)) {
+    const fileBytes = decompress(new Uint8Array(await getUrlBytes(url)));
+    try {
+      await Deno.writeFile(localPath, fileBytes);
+    } catch {
+      // ignore and return the wasm bytes
+      return fileBytes;
+    }
+  }
+  return toFileUrl(localPath);
+}
+
+async function getUrlLocalPath(url: URL) {
+  try {
+    const dataDirPath = await getInitializedLocalDataDirPath();
+    const hash = await getUrlHash(url);
+    return `${dataDirPath}/${hash}.wasm`;
+  } catch {
+    return undefined;
+  }
+}
+
+async function getInitializedLocalDataDirPath() {
+  const dataDir = localDataDir();
+  if (dataDir == null) {
+    throw new Error(`Could not find local data directory.`);
+  }
+  const dirPath = `${dataDir}/deno-wasmbuild`;
+  await ensureDir(dirPath);
+  return dirPath;
+}
+
+async function exists(filePath: string | URL): Promise<boolean> {
+  try {
+    await Deno.lstat(filePath);
+    return true;
+  } catch (error) {
+    if (error instanceof Deno.errors.NotFound) {
+      return false;
+    }
+    throw error;
+  }
+}
+
+async function ensureDir(dir: string) {
+  try {
+    const fileInfo = await Deno.lstat(dir);
+    if (!fileInfo.isDirectory) {
+      throw new Error(`Path was not a directory '${dir}'`);
+    }
+  } catch (err) {
+    if (err instanceof Deno.errors.NotFound) {
+      // if dir not exists. then create it.
+      await Deno.mkdir(dir, { recursive: true });
+      return;
+    }
+    throw err;
+  }
+}
+
+async function getUrlHash(url: URL) {
+  // Taken from MDN: https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/digest
+  const hashBuffer = await crypto.subtle.digest(
+    "SHA-256",
+    new TextEncoder().encode(url.href),
+  );
+  // convert buffer to byte array
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  // convert bytes to hex string
+  const hashHex = hashArray
+    .map((b) => b.toString(16).padStart(2, "0"))
+    .join("");
+  return hashHex;
+}
+
+async function getUrlBytes(url: URL) {
+  const response = await fetchWithRetries(url);
+  return await response.arrayBuffer();
+}
+
+// the below is extracted from deno_std/path
+
+const WHITESPACE_ENCODINGS: Record<string, string> = {
+  "\u0009": "%09",
+  "\u000A": "%0A",
+  "\u000B": "%0B",
+  "\u000C": "%0C",
+  "\u000D": "%0D",
+  "\u0020": "%20",
+};
+
+function encodeWhitespace(string: string): string {
+  return string.replaceAll(/[\s]/g, (c) => {
+    return WHITESPACE_ENCODINGS[c] ?? c;
+  });
+}
+
+function toFileUrl(path: string): URL {
+  return Deno.build.os === "windows"
+    ? windowsToFileUrl(path)
+    : posixToFileUrl(path);
+}
+
+function posixToFileUrl(path: string): URL {
+  const url = new URL("file:///");
+  url.pathname = encodeWhitespace(
+    path.replace(/%/g, "%25").replace(/\\/g, "%5C"),
+  );
+  return url;
+}
+
+function windowsToFileUrl(path: string): URL {
+  const [, hostname, pathname] = path.match(
+    /^(?:[/\\]{2}([^/\\]+)(?=[/\\](?:[^/\\]|$)))?(.*)/,
+  )!;
+  const url = new URL("file:///");
+  url.pathname = encodeWhitespace(pathname.replace(/%/g, "%25"));
+  if (hostname != null && hostname != "localhost") {
+    url.hostname = hostname;
+    if (!url.hostname) {
+      throw new TypeError("Invalid hostname.");
+    }
+  }
+  return url;
+}
+
+export async function fetchWithRetries(url: URL | string, maxRetries = 5) {
+  let sleepMs = 250;
+  let iterationCount = 0;
+  while (true) {
+    iterationCount++;
+    try {
+      const res = await fetch(url);
+      if (res.ok || iterationCount > maxRetries) {
+        return res;
+      }
+    } catch (err) {
+      if (iterationCount > maxRetries) {
+        throw err;
+      }
+    }
+    console.warn(`Failed fetching. Retrying in ${sleepMs}ms...`);
+    await new Promise((resolve) => setTimeout(resolve, sleepMs));
+    sleepMs = Math.min(sleepMs * 2, 10_000);
+  }
+}

package/deno/vendor/deno.land/x/wasmbuild@0.15.1/loader.ts

@@ -0,0 +1,126 @@
+// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
+import { fetchWithRetries } from "./cache.ts";
+
+export type DecompressCallback = (bytes: Uint8Array) => Uint8Array;
+
+export interface LoaderOptions {
+  /** The Wasm module's imports. */
+  imports: WebAssembly.Imports | undefined;
+  /** A function that caches the Wasm module to a local path so that
+   * so that a network request isn't required on every load.
+   *
+   * Returns an ArrayBuffer with the bytes on download success, but
+   * cache save failure.
+   */
+  cache?: (
+    url: URL,
+    decompress: DecompressCallback | undefined,
+  ) => Promise<URL | Uint8Array>;
+}
+
+export class Loader {
+  #options: LoaderOptions;
+  #lastLoadPromise:
+    | Promise<WebAssembly.WebAssemblyInstantiatedSource>
+    | undefined;
+  #instantiated: WebAssembly.WebAssemblyInstantiatedSource | undefined;
+
+  constructor(options: LoaderOptions) {
+    this.#options = options;
+  }
+
+  get instance() {
+    return this.#instantiated?.instance;
+  }
+
+  get module() {
+    return this.#instantiated?.module;
+  }
+
+  load(
+    url: URL,
+    decompress: DecompressCallback | undefined,
+  ): Promise<WebAssembly.WebAssemblyInstantiatedSource> {
+    if (this.#instantiated) {
+      return Promise.resolve(this.#instantiated);
+    } else if (this.#lastLoadPromise == null) {
+      this.#lastLoadPromise = (async () => {
+        try {
+          this.#instantiated = await this.#instantiate(url, decompress);
+          return this.#instantiated;
+        } finally {
+          this.#lastLoadPromise = undefined;
+        }
+      })();
+    }
+    return this.#lastLoadPromise;
+  }
+
+  async #instantiate(url: URL, decompress: DecompressCallback | undefined) {
+    const imports = this.#options.imports;
+    if (this.#options.cache != null && url.protocol !== "file:") {
+      try {
+        const result = await this.#options.cache(
+          url,
+          decompress ?? ((bytes) => bytes),
+        );
+        if (result instanceof URL) {
+          url = result;
+          decompress = undefined; // already decompressed
+        } else if (result != null) {
+          return WebAssembly.instantiate(result, imports);
+        }
+      } catch {
+        // ignore if caching ever fails (ex. when on deploy)
+      }
+    }
+
+    const isFile = url.protocol === "file:";
+
+    // make file urls work in Node via dnt
+    // deno-lint-ignore no-explicit-any
+    const isNode = (globalThis as any).process?.versions?.node != null;
+    if (isFile && typeof Deno !== "object") {
+      throw new Error(
+        "Loading local files are not supported in this environment",
+      );
+    }
+    if (isNode && isFile) {
+      // the deno global will be shimmed by dnt
+      const wasmCode = await Deno.readFile(url);
+      return WebAssembly.instantiate(
+        decompress ? decompress(wasmCode) : wasmCode,
+        imports,
+      );
+    }
+
+    switch (url.protocol) {
+      case "file:":
+      case "https:":
+      case "http:": {
+        const wasmResponse = await fetchWithRetries(url);
+        if (decompress) {
+          const wasmCode = new Uint8Array(await wasmResponse.arrayBuffer());
+          return WebAssembly.instantiate(decompress(wasmCode), imports);
+        }
+        if (
+          isFile ||
+          wasmResponse.headers.get("content-type")?.toLowerCase()
+            .startsWith("application/wasm")
+        ) {
+          // Cast to any so there's no type checking issues with dnt
+          // (https://github.com/denoland/wasmbuild/issues/92)
+          // deno-lint-ignore no-explicit-any
+          return WebAssembly.instantiateStreaming(wasmResponse as any, imports);
+        } else {
+          return WebAssembly.instantiate(
+            await wasmResponse.arrayBuffer(),
+            imports,
+          );
+        }
+      }
+      default:
+        throw new Error(`Unsupported protocol: ${url.protocol}`);
+    }
+  }
+}

package/dist/node/bootstrap.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/node/bootstrap.test.js

@@ -0,0 +1,26 @@
+import { Buffer } from 'buffer';
+import { env } from 'process';
+import fetch, { Headers } from 'node-fetch';
+import { test, expect } from 'vitest';
+import { getBootstrapURL } from './formats/javascript.js';
+test('Imports the bootstrap layer from a valid URL', async () => {
+    const importURL = new URL(getBootstrapURL());
+    const headers = new Headers();
+    // `node-fetch` doesn't let us send credentials as part of the URL, so we
+    // have to transform them into an `Authorization` header.
+    if (importURL.username) {
+        const auth = Buffer.from(`${importURL.username}:${importURL.password}`);
+        importURL.username = '';
+        importURL.password = '';
+        headers.set('Authorization', `Basic ${auth.toString('base64')}`);
+    }
+    const canonicalURL = importURL.toString();
+    const { status } = await fetch(canonicalURL, { headers });
+    expect(status).toBe(200);
+});
+test('Imports the bootstrap layer from the URL present in the `NETLIFY_EDGE_BOOTSTRAP` environment variable, if present', () => {
+    const mockURL = 'https://example.com/boot.ts';
+    env.NETLIFY_EDGE_BOOTSTRAP = mockURL;
+    expect(getBootstrapURL()).toBe(mockURL);
+    env.NETLIFY_EDGE_BOOTSTRAP = undefined;
+});

package/dist/node/bridge.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import { ExecaChildProcess } from 'execa';
 import { Logger } from './logger.js';
-declare const DENO_VERSION_RANGE = "^1.32.5";
+declare const DENO_VERSION_RANGE = "^1.37.0";
 type OnBeforeDownloadHook = () => void | Promise<void>;
 type OnAfterDownloadHook = (error?: Error) => void | Promise<void>;
 interface DenoOptions {

package/dist/node/bridge.js

@@ -11,7 +11,7 @@ import { getBinaryExtension } from './platform.js';
 const DENO_VERSION_FILE = 'version.txt';
 // When updating DENO_VERSION_RANGE, ensure that the deno version installed in the
 // build-image/buildbot does satisfy this range!
-const DENO_VERSION_RANGE = '^1.32.5';
+const DENO_VERSION_RANGE = '^1.37.0';
 class DenoBridge {
     constructor(options) {
         var _a, _b, _c, _d, _e;

package/dist/node/bundler.d.ts

@@ -15,11 +15,12 @@ export interface BundleOptions {
     internalSrcFolder?: string;
     onAfterDownload?: OnAfterDownloadHook;
     onBeforeDownload?: OnBeforeDownloadHook;
+    rootPath?: string;
     systemLogger?: LogFunction;
     userLogger?: LogFunction;
     vendorDirectory?: string;
 }
-export declare const bundle: (sourceDirectories: string[], distDirectory: string, tomlDeclarations?: Declaration[], { basePath: inputBasePath, cacheDirectory, configPath, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMapPaths, internalSrcFolder, onAfterDownload, onBeforeDownload, userLogger, systemLogger, vendorDirectory, }?: BundleOptions) => Promise<{
+export declare const bundle: (sourceDirectories: string[], distDirectory: string, tomlDeclarations?: Declaration[], { basePath: inputBasePath, cacheDirectory, configPath, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMapPaths, internalSrcFolder, onAfterDownload, onBeforeDownload, rootPath, userLogger, systemLogger, vendorDirectory, }?: BundleOptions) => Promise<{
     functions: EdgeFunction[];
     manifest: import("./manifest.js").Manifest;
 }>;

package/dist/node/bundler.js

@@ -15,7 +15,7 @@ import { getLogger } from './logger.js';
 import { writeManifest } from './manifest.js';
 import { vendorNPMSpecifiers } from './npm_dependencies.js';
 import { ensureLatestTypes } from './types.js';
-export const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], { basePath: inputBasePath, cacheDirectory, configPath, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMapPaths = [], internalSrcFolder, onAfterDownload, onBeforeDownload, userLogger, systemLogger, vendorDirectory, } = {}) => {
+export const bundle = async (sourceDirectories, distDirectory, tomlDeclarations = [], { basePath: inputBasePath, cacheDirectory, configPath, debug, distImportMapPath, featureFlags: inputFeatureFlags, importMapPaths = [], internalSrcFolder, onAfterDownload, onBeforeDownload, rootPath, userLogger, systemLogger, vendorDirectory, } = {}) => {
     const logger = getLogger(systemLogger, userLogger, debug);
     const featureFlags = getFlags(inputFeatureFlags);
     const options = {
@@ -53,6 +53,7 @@ export const bundle = async (sourceDirectories, distDirectory, tomlDeclarations
         functions,
         importMap,
         logger,
+        rootPath: rootPath !== null && rootPath !== void 0 ? rootPath : basePath,
         vendorDirectory,
     });
     if (vendor) {
@@ -147,10 +148,7 @@ const createFunctionConfig = ({ internalFunctionsWithConfig, declarations }) =>
         [functionName]: addGeneratorFallback(mergedConfigFields),
     };
 }, {});
-const safelyVendorNPMSpecifiers = async ({ basePath, featureFlags, functions, importMap, logger, vendorDirectory, }) => {
-    if (!featureFlags.edge_functions_npm_modules) {
-        return;
-    }
+const safelyVendorNPMSpecifiers = async ({ basePath, functions, importMap, logger, rootPath, vendorDirectory, }) => {
     try {
         return await vendorNPMSpecifiers({
             basePath,
@@ -159,6 +157,7 @@ const safelyVendorNPMSpecifiers = async ({ basePath, featureFlags, functions, im
             importMap,
             logger,
             referenceTypes: false,
+            rootPath,
         });
     }
     catch (error) {

package/dist/node/bundler.test.js

@@ -105,31 +105,7 @@ test('Adds a custom error property to user errors during bundling', async () =>
         await cleanup();
     }
 });
-test('Prints a nice error message when user tries importing an npm module and npm support is disabled', async () => {
-    expect.assertions(2);
-    const { basePath, cleanup, distPath } = await useFixture('imports_npm_module');
-    const sourceDirectory = join(basePath, 'functions');
-    const declarations = [
-        {
-            function: 'func1',
-            path: '/func1',
-        },
-    ];
-    try {
-        await bundle([sourceDirectory], distPath, declarations, {
-            basePath,
-            importMapPaths: [join(basePath, 'import_map.json')],
-        });
-    }
-    catch (error) {
-        expect(error).toBeInstanceOf(BundleError);
-        expect(error.message).toEqual(`It seems like you're trying to import an npm module. This is only supported via CDNs like esm.sh. Have you tried 'import mod from "https://esm.sh/parent-1"'?`);
-    }
-    finally {
-        await cleanup();
-    }
-});
-test('Prints a nice error message when user tries importing an npm module and npm support is enabled', async () => {
+test('Prints a nice error message when user tries importing an npm module', async () => {
     expect.assertions(2);
     const { basePath, cleanup, distPath } = await useFixture('imports_npm_module_scheme');
     const sourceDirectory = join(basePath, 'functions');
@@ -142,7 +118,6 @@ test('Prints a nice error message when user tries importing an npm module and np
     try {
         await bundle([sourceDirectory], distPath, declarations, {
             basePath,
-            featureFlags: { edge_functions_npm_modules: true },
         });
     }
     catch (error) {
@@ -153,27 +128,6 @@ test('Prints a nice error message when user tries importing an npm module and np
         await cleanup();
     }
 });
-test('Prints a nice error message when user tries importing NPM module with npm: scheme', async () => {
-    expect.assertions(2);
-    const { basePath, cleanup, distPath } = await useFixture('imports_npm_module_scheme');
-    const sourceDirectory = join(basePath, 'functions');
-    const declarations = [
-        {
-            function: 'func1',
-            path: '/func1',
-        },
-    ];
-    try {
-        await bundle([sourceDirectory], distPath, declarations, { basePath });
-    }
-    catch (error) {
-        expect(error).toBeInstanceOf(BundleError);
-        expect(error.message).toEqual(`It seems like you're trying to import an npm module. This is only supported via CDNs like esm.sh. Have you tried 'import mod from "https://esm.sh/p-retry"'?`);
-    }
-    finally {
-        await cleanup();
-    }
-});
 test('Does not add a custom error property to system errors during bundling', async () => {
     expect.assertions(1);
     try {
@@ -413,7 +367,6 @@ test('Loads npm modules from bare specifiers', async () => {
     const vendorDirectory = await tmp.dir();
     await bundle([sourceDirectory], distPath, declarations, {
         basePath,
-        featureFlags: { edge_functions_npm_modules: true },
         importMapPaths: [join(basePath, 'import_map.json')],
         vendorDirectory: vendorDirectory.path,
         systemLogger,
@@ -427,3 +380,53 @@ test('Loads npm modules from bare specifiers', async () => {
     await cleanup();
     await rm(vendorDirectory.path, { force: true, recursive: true });
 });
+test('Loads npm modules in a monorepo setup', async () => {
+    const systemLogger = vi.fn();
+    const { basePath: rootPath, cleanup, distPath } = await useFixture('monorepo_npm_module');
+    const basePath = join(rootPath, 'packages', 'frontend');
+    const sourceDirectory = join(basePath, 'functions');
+    const declarations = [
+        {
+            function: 'func1',
+            path: '/func1',
+        },
+    ];
+    const vendorDirectory = await tmp.dir();
+    await bundle([sourceDirectory], distPath, declarations, {
+        basePath,
+        importMapPaths: [join(basePath, 'import_map.json')],
+        rootPath,
+        vendorDirectory: vendorDirectory.path,
+        systemLogger,
+    });
+    expect(systemLogger.mock.calls.find((call) => call[0] === 'Could not track dependencies in edge function:')).toBeUndefined();
+    const manifestFile = await readFile(resolve(distPath, 'manifest.json'), 'utf8');
+    const manifest = JSON.parse(manifestFile);
+    const bundlePath = join(distPath, manifest.bundles[0].asset);
+    const { func1 } = await runESZIP(bundlePath, vendorDirectory.path);
+    expect(func1).toBe(`<parent-1><child-1>JavaScript</child-1></parent-1>, <parent-2><child-2><grandchild-1>APIs<cwd>${process.cwd()}</cwd></grandchild-1></child-2></parent-2>, <parent-3><child-2><grandchild-1>Markup<cwd>${process.cwd()}</cwd></grandchild-1></child-2></parent-3>`);
+    await cleanup();
+    await rm(vendorDirectory.path, { force: true, recursive: true });
+});
+test('Loads JSON modules', async () => {
+    const { basePath, cleanup, distPath } = await useFixture('imports_json');
+    const sourceDirectory = join(basePath, 'functions');
+    const declarations = [
+        {
+            function: 'func1',
+            path: '/func1',
+        },
+    ];
+    const vendorDirectory = await tmp.dir();
+    await bundle([sourceDirectory], distPath, declarations, {
+        basePath,
+        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"}`);
+    await cleanup();
+    await rm(vendorDirectory.path, { force: true, recursive: true });
+});

package/dist/node/deno_config.d.ts

@@ -0,0 +1,5 @@
+interface DenoConfigFile {
+    importMap?: string;
+}
+export declare const getConfig: (basePath?: string) => Promise<DenoConfigFile | undefined>;
+export {};

package/dist/node/deno_config.js

@@ -0,0 +1,40 @@
+import { promises as fs } from 'fs';
+import { join, resolve } from 'path';
+import { parse as parseJSONC } from 'jsonc-parser';
+import { isNodeError } from './utils/error.js';
+const filenames = ['deno.json', 'deno.jsonc'];
+export const getConfig = async (basePath) => {
+    if (basePath === undefined) {
+        return;
+    }
+    for (const filename of filenames) {
+        const candidatePath = join(basePath, filename);
+        const config = await getConfigFromFile(candidatePath);
+        if (config !== undefined) {
+            return normalizeConfig(config, basePath);
+        }
+    }
+};
+const getConfigFromFile = async (filePath) => {
+    try {
+        const data = await fs.readFile(filePath, 'utf8');
+        const config = parseJSONC(data);
+        return config;
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === 'ENOENT') {
+            return;
+        }
+        return {};
+    }
+};
+const normalizeConfig = (rawConfig, basePath) => {
+    const config = {};
+    if (rawConfig.importMap) {
+        if (typeof rawConfig.importMap !== 'string') {
+            throw new TypeError(`'importMap' property in Deno config must be a string`);
+        }
+        config.importMap = resolve(basePath, rawConfig.importMap);
+    }
+    return config;
+};

package/dist/node/deno_config.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/node/deno_config.test.js

@@ -0,0 +1,37 @@
+import { promises as fs } from 'fs';
+import { join } from 'path';
+import tmp from 'tmp-promise';
+import { expect, test } from 'vitest';
+import { getConfig } from './deno_config.js';
+test('Returns `undefined` if no config file is found', async () => {
+    const { cleanup, path } = await tmp.dir({ unsafeCleanup: true });
+    const config = await getConfig(path);
+    expect(config).toBeUndefined();
+    await cleanup();
+});
+test('Returns an empty object if the config file cannot be parsed', async () => {
+    const { cleanup, path } = await tmp.dir({ unsafeCleanup: true });
+    const configPath = join(path, 'deno.json');
+    await fs.writeFile(configPath, '{');
+    const config = await getConfig(path);
+    expect(config).toEqual({});
+    await cleanup();
+});
+test('Resolves `importMap` into an absolute path', async () => {
+    const { cleanup, path } = await tmp.dir({ unsafeCleanup: true });
+    const configPath = join(path, 'deno.json');
+    const data = JSON.stringify({ importMap: 'import_map.json' });
+    await fs.writeFile(configPath, data);
+    const config = await getConfig(path);
+    expect(config).toEqual({ importMap: join(path, 'import_map.json') });
+    await cleanup();
+});
+test('Supports JSONC', async () => {
+    const { cleanup, path } = await tmp.dir({ unsafeCleanup: true });
+    const configPath = join(path, 'deno.jsonc');
+    const data = JSON.stringify({ importMap: 'import_map.json' });
+    await fs.writeFile(configPath, `// This is a comment\n${data}`);
+    const config = await getConfig(path);
+    expect(config).toEqual({ importMap: join(path, 'import_map.json') });
+    await cleanup();
+});

package/dist/node/feature_flags.d.ts

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

package/dist/node/feature_flags.js

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

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

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

package/dist/node/formats/eszip.js

@@ -6,7 +6,7 @@ import { wrapBundleError } from '../bundle_error.js';
 import { wrapNpmImportError } from '../npm_import_error.js';
 import { getPackagePath } from '../package_json.js';
 import { getFileHash } from '../utils/sha256.js';
-const bundleESZIP = async ({ basePath, buildID, debug, deno, distDirectory, externals, featureFlags, functions, importMap, vendorDirectory, }) => {
+const bundleESZIP = async ({ basePath, buildID, debug, deno, distDirectory, externals, functions, importMap, vendorDirectory, }) => {
     const extension = '.eszip';
     const destPath = join(distDirectory, `${buildID}${extension}`);
     const importMapPrefixes = {
@@ -33,7 +33,7 @@ const bundleESZIP = async ({ basePath, buildID, debug, deno, distDirectory, exte
         await deno.run(['run', ...flags, bundler, JSON.stringify(payload)], { pipeOutput: true });
     }
     catch (error) {
-        throw wrapBundleError(wrapNpmImportError(error, Boolean(featureFlags.edge_functions_npm_modules)), {
+        throw wrapBundleError(wrapNpmImportError(error), {
             format: 'eszip',
         });
     }

package/dist/node/formats/javascript.js

@@ -1,10 +1,9 @@
-import { mkdir, rm, writeFile } from 'fs/promises';
+import { mkdir, writeFile } from 'fs/promises';
 import { join } from 'path';
 import { pathToFileURL } from 'url';
 const defaultFormatExportTypeError = (name) => `The Edge Function "${name}" has failed to load. Does it have a function as the default export?`;
 const defaultFormatImportError = (name) => `There was an error with Edge Function "${name}".`;
 const generateStage2 = async ({ bootstrapURL, distDirectory, fileName, formatExportTypeError, formatImportError, functions, }) => {
-    await rm(distDirectory, { force: true, recursive: true, maxRetries: 3 });
     await mkdir(distDirectory, { recursive: true });
     const entryPoint = getLocalEntryPoint(functions, { bootstrapURL, formatExportTypeError, formatImportError });
     const stage2Path = join(distDirectory, fileName);