@netlify/edge-bundler 12.2.2 → 12.3.0

package/dist/node/bridge.d.ts

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

package/dist/node/bridge.js

@@ -9,11 +9,10 @@ import { getPathInHome } from './home_path.js';
 import { getLogger } from './logger.js';
 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!
-// We're pinning the range because of an issue with v1.45.0 of the Deno CLI:
-// https://linear.app/netlify/issue/FRP-775/deno-cli-v1450-causing-issues
-const DENO_VERSION_RANGE = '1.37.0 - 1.44.4';
+// 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 - 1.46.3';
 class DenoBridge {
     constructor(options) {
         var _a, _b, _c, _d, _e;

package/dist/node/bundler.test.js

@@ -355,6 +355,32 @@ test('Handles imports with the `node:` prefix', async () => {
     expect(func1).toBe('ok');
     await cleanup();
 });
+test('Handles Node builtin imports without the `node:` prefix', async () => {
+    const { basePath, cleanup, distPath } = await useFixture('imports_node_builtin');
+    const userDirectory = join(basePath, 'netlify', 'edge-functions');
+    const result = await bundle([userDirectory], distPath, [], {
+        basePath,
+        importMapPaths: [join(userDirectory, 'import_map.json')],
+    });
+    const generatedFiles = await readdir(distPath);
+    expect(result.functions.length).toBe(1);
+    expect(generatedFiles.length).toBe(2);
+    const manifestFile = await readFile(resolve(distPath, 'manifest.json'), 'utf8');
+    const manifest = JSON.parse(manifestFile);
+    expect(() => validateManifest(manifest)).not.toThrowError();
+    const { bundles, import_map: importMapURL, routes } = manifest;
+    expect(bundles.length).toBe(1);
+    expect(bundles[0].format).toBe('eszip2');
+    expect(generatedFiles.includes(bundles[0].asset)).toBe(true);
+    expect(importMapURL).toBe(importMapSpecifier);
+    expect(routes.length).toBe(1);
+    expect(routes[0].function).toBe('func1');
+    expect(routes[0].pattern).toBe('^/func1/?$');
+    const bundlePath = join(distPath, bundles[0].asset);
+    const { func1 } = await runESZIP(bundlePath);
+    expect(func1).toBe('ok');
+    await cleanup();
+});
 test('Loads npm modules from bare specifiers', async () => {
     const systemLogger = vi.fn();
     const { basePath, cleanup, distPath } = await useFixture('imports_npm_module');

package/dist/node/npm_dependencies.d.ts

@@ -18,5 +18,5 @@ export declare const vendorNPMSpecifiers: ({ basePath, directory, functions, imp
     };
     npmSpecifiersWithExtraneousFiles: string[];
     outputFiles: string[];
-} | undefined>;
+}>;
 export {};

package/dist/node/npm_dependencies.js

@@ -185,10 +185,6 @@ export const vendorNPMSpecifiers = async ({ basePath, directory, functions, impo
         environment,
         rootPath,
     });
-    // If we found no specifiers, there's nothing left to do here.
-    if (Object.keys(npmSpecifiers).length === 0) {
-        return;
-    }
     // To bundle an entire module and all its dependencies, create a entrypoint file
     // where we re-export everything from that specifier. We do this for every
     // specifier, and each of these files will become entry points to esbuild.
@@ -198,39 +194,43 @@ export const vendorNPMSpecifiers = async ({ basePath, directory, functions, impo
         await fs.writeFile(filePath, code);
         return { filePath, specifier, types };
     }));
-    const entryPoints = ops.map(({ filePath }) => filePath);
-    // Bundle each of the entrypoints we created. We'll end up with a compiled
-    // version of each, plus any chunks of shared code
-    // between them (such that a common module isn't bundled twice).
-    const { outputFiles } = await build({
-        allowOverwrite: true,
-        banner,
-        bundle: true,
-        entryPoints,
-        format: 'esm',
-        mainFields: ['module', 'browser', 'main'],
-        logLevel: 'error',
-        nodePaths,
-        outdir: temporaryDirectory.path,
-        platform: 'node',
-        splitting: true,
-        target: 'es2020',
-        write: false,
-        define: environment === 'production'
-            ? {
-                'process.env.NODE_ENV': '"production"',
+    const outputFiles = [];
+    if (ops.length !== 0) {
+        const entryPoints = ops.map(({ filePath }) => filePath);
+        // Bundle each of the entrypoints we created. We'll end up with a compiled
+        // version of each, plus any chunks of shared code
+        // between them (such that a common module isn't bundled twice).
+        const { outputFiles: outputFilesFromEsBuild } = await build({
+            allowOverwrite: true,
+            banner,
+            bundle: true,
+            entryPoints,
+            format: 'esm',
+            mainFields: ['module', 'browser', 'main'],
+            logLevel: 'error',
+            nodePaths,
+            outdir: temporaryDirectory.path,
+            platform: 'node',
+            splitting: true,
+            target: 'es2020',
+            write: false,
+            define: environment === 'production'
+                ? {
+                    'process.env.NODE_ENV': '"production"',
+                }
+                : undefined,
+        });
+        outputFiles.push(...outputFilesFromEsBuild.map((file) => file.path));
+        await Promise.all(outputFilesFromEsBuild.map(async (file) => {
+            var _a;
+            const types = (_a = ops.find((op) => path.basename(file.path) === path.basename(op.filePath))) === null || _a === void 0 ? void 0 : _a.types;
+            let content = file.text;
+            if (types) {
+                content = `/// <reference types="${path.relative(path.dirname(file.path), types)}" />\n${content}`;
             }
-            : undefined,
-    });
-    await Promise.all(outputFiles.map(async (file) => {
-        var _a;
-        const types = (_a = ops.find((op) => path.basename(file.path) === path.basename(op.filePath))) === null || _a === void 0 ? void 0 : _a.types;
-        let content = file.text;
-        if (types) {
-            content = `/// <reference types="${path.relative(path.dirname(file.path), types)}" />\n${content}`;
-        }
-        await fs.writeFile(file.path, content);
-    }));
+            await fs.writeFile(file.path, content);
+        }));
+    }
     // Add all Node.js built-ins to the import map, so any unprefixed specifiers
     // (e.g. `process`) resolve to the prefixed versions (e.g. `node:prefix`),
     // which Deno can process.
@@ -270,6 +270,6 @@ export const vendorNPMSpecifiers = async ({ basePath, directory, functions, impo
         directory: temporaryDirectory.path,
         importMap: newImportMap,
         npmSpecifiersWithExtraneousFiles,
-        outputFiles: outputFiles.map((file) => file.path),
+        outputFiles,
     };
 };

package/dist/node/server/util.js

@@ -1,5 +1,7 @@
+import { platform } from 'os';
 import fetch from 'node-fetch';
 import waitFor from 'p-wait-for';
+import { satisfies } from 'semver';
 // 1 second
 const SERVER_KILL_TIMEOUT = 1e3;
 // 1 second
@@ -29,9 +31,19 @@ const killProcess = (ps) => {
     return new Promise((resolve, reject) => {
         ps.on('close', resolve);
         ps.on('error', reject);
-        ps.kill('SIGTERM', {
-            forceKillAfterTimeout: SERVER_KILL_TIMEOUT,
-        });
+        // On Windows with Node 21+, there's a bug where attempting to kill a child process
+        // results in an EPERM error. Ignore the error in that case.
+        // See: https://github.com/nodejs/node/issues/51766
+        // We also disable execa's `forceKillAfterTimeout` in this case
+        // which can cause unhandled rejection.
+        try {
+            ps.kill('SIGTERM', {
+                forceKillAfterTimeout: platform() === 'win32' && satisfies(process.version, '>=21') ? false : SERVER_KILL_TIMEOUT,
+            });
+        }
+        catch {
+            // no-op
+        }
     });
 };
 const waitForServer = async (port, ps) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "12.2.2",
+  "version": "12.3.0",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",
@@ -84,5 +84,5 @@
     "urlpattern-polyfill": "8.0.2",
     "uuid": "^9.0.0"
   },
-  "gitHead": "11ec8d0f0bd573150a134cd9af077f5b56afdbb6"
+  "gitHead": "0b25c72f762393fa13a50e673a0fd48eb37f5120"
 }