@netlify/edge-bundler 14.10.2 → 14.10.3

package/dist/node/formats/tarball.js

@@ -165,33 +165,95 @@ async function getRequiredSourceFiles(deno, entryPoints, importMap) {
             pathToFileURL(entryPoint).href,
         ]);
         const graph = JSON.parse(stdout);
+        // Collect the specifiers of every module reachable through a *code* (runtime)
+        // import edge. Deno's module graph classifies each dependency as either a `code`
+        // edge (a real runtime import) or a `type`-only edge (`import type`, `@deno-types`).
+        // Type-only edges are erased during transpilation and are never loaded at runtime
+        // (`deno run` doesn't type-check), so the files they point to don't belong in the
+        // bundle. The entry points themselves are always runtime.
+        const runtimeSpecifiers = new Set(graph.roots);
+        for (const module of graph.modules) {
+            for (const dependency of module.dependencies ?? []) {
+                if (dependency.code?.specifier) {
+                    runtimeSpecifiers.add(dependency.code.specifier);
+                }
+            }
+        }
         // Extract all local files from the module graph
         for (const module of graph.modules) {
-            if (module.specifier.startsWith('file://')) {
-                if (module.error?.startsWith('Module not found')) {
-                    // Module graph contains all found imported/required modules, even if they don't actually exist
-                    // This can happen for optional dependencies (dynamic import or require in try/catch).
+            if (!module.specifier.startsWith('file://')) {
+                continue;
+            }
+            if (module.error) {
+                // A module reachable only through type-only edges (e.g. a directory specifier
+                // behind `import type`) can fail to resolve as an ES module. That's safe to
+                // ignore: the runtime never loads it.
+                if (!runtimeSpecifiers.has(module.specifier)) {
+                    continue;
+                }
+                if (module.error.startsWith('Module not found')) {
+                    // Module graph contains all found imported/required modules, even if they don't
+                    // actually exist. This can happen for optional dependencies (dynamic import or
+                    // require in try/catch).
                     continue;
                 }
-                const filePath = fileURLToPath(module.specifier);
-                localFiles.add(filePath);
             }
+            localFiles.add(fileURLToPath(module.specifier));
         }
     }
     return localFiles;
 }
+// WebAssembly binary magic bytes: `\0asm` (0x00 0x61 0x73 0x6d).
+const WASM_MAGIC = Buffer.from([0x00, 0x61, 0x73, 0x6d]);
+/**
+ * Detects whether a file is a raw WebAssembly module by its magic bytes.
+ * Deno <2.6 vendors imported `.wasm` modules under a `.d.mts` extension even
+ * though the content is the raw WASM binary, so we cannot rely on extension
+ * alone to decide whether a file is safe to read as UTF-8 and rewrite.
+ */
+async function isWasm(sourceFile) {
+    const fd = await fs.open(sourceFile, 'r');
+    try {
+        const buf = Buffer.alloc(WASM_MAGIC.length);
+        const { bytesRead } = await fd.read(buf, 0, buf.length, 0);
+        return bytesRead === WASM_MAGIC.length && buf.equals(WASM_MAGIC);
+    }
+    finally {
+        await fd.close();
+    }
+}
+/**
+ * Decides whether a source file should be parsed and rewritten. Cheap extension
+ * check first; only if it passes do we open the file to rule out raw WebAssembly
+ * binaries (Deno <2.6 vendors `.wasm` imports under `.d.mts`) — reading those
+ * as UTF-8 would corrupt the binary on round-trip.
+ */
+async function shouldRewrite(sourceFile) {
+    if (!REWRITABLE_EXTENSIONS.has(path.extname(sourceFile))) {
+        return false;
+    }
+    if (await isWasm(sourceFile)) {
+        return false;
+    }
+    return true;
+}
 /**
  * Rewrites import assert into import with in the bundle directory
  * Defaults to copying the file in its current form
  */
 export async function rewriteImportAssertions(sourceFile, destPath) {
-    if (!REWRITABLE_EXTENSIONS.has(path.extname(sourceFile))) {
+    if (!(await shouldRewrite(sourceFile))) {
         if (sourceFile !== destPath) {
             await fs.copyFile(sourceFile, destPath);
         }
         return;
     }
-    const source = await fs.readFile(sourceFile, 'utf-8');
-    const modified = rewriteSourceImportAssertions(source);
-    await fs.writeFile(destPath, modified);
+    try {
+        const source = await fs.readFile(sourceFile, 'utf-8');
+        const modified = rewriteSourceImportAssertions(source);
+        await fs.writeFile(destPath, modified);
+    }
+    catch (error) {
+        throw new Error(`Failed to rewrite import assertions in ${sourceFile}`, { cause: error });
+    }
 }

package/dist/node/utils/import_attributes.js

@@ -1,6 +1,25 @@
 import { Parser } from 'acorn';
 import { tsPlugin } from '@sveltejs/acorn-typescript';
-const acorn = Parser.extend(tsPlugin({ jsx: true }));
+const acornNoJSX = Parser.extend(tsPlugin({ jsx: false }));
+const acornJSX = Parser.extend(tsPlugin({ jsx: true }));
+const parseOptions = {
+    ecmaVersion: 'latest',
+    sourceType: 'module',
+    locations: true,
+};
+const parseAST = (source) => {
+    try {
+        return acornJSX.parse(source, parseOptions);
+    }
+    catch (error) {
+        // for non-jsx typescript casting to type via "<type> value" (normally done with "value as type") will throw an "Unexpected token" error in acorn-jsx,
+        // but is valid syntax in TypeScript. In this case, we can retry parsing with the non-jsx parser.
+        if (error instanceof SyntaxError) {
+            return acornNoJSX.parse(source, parseOptions);
+        }
+        throw error;
+    }
+};
 /**
  * Given source code rewrites import assert into import with
  */
@@ -10,11 +29,7 @@ export function rewriteSourceImportAssertions(source) {
     }
     let modified = source;
     try {
-        const parsedAST = acorn.parse(source, {
-            ecmaVersion: 'latest',
-            sourceType: 'module',
-            locations: true,
-        });
+        const parsedAST = parseAST(source);
         const statements = collectImportAssertions(source, parsedAST.body);
         // Bulk replacement of import assertions
         for (const statement of statements.sort((a, b) => b.start - a.start)) {

package/dist/test/util.js

@@ -49,16 +49,18 @@ const inspectESZIPFunction = (path) => `
   console.log(JSON.stringify(responses));
 `;
 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))
+  // Import via a relative specifier so Deno resolves the module URL itself,
+  // keeping its encoding consistent with the import map base (both derived from
+  // cwd). Pre-building an absolute file:// URL on the Node side encodes paths
+  // differently from Deno (e.g. '~' in Windows 8.3 short names), which breaks
+  // import map prefix matching on Deno 2.8+.
+  const func = await import("./" + manifest.functions[functionName]);
   const res = await func.default(req);
 
   responses[functionName] = await res.text();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/edge-bundler",
-  "version": "14.10.2",
+  "version": "14.10.3",
   "description": "Intelligently prepare Netlify Edge Functions for deployment",
   "type": "module",
   "main": "./dist/node/index.js",
@@ -80,5 +80,5 @@
     "tmp-promise": "^3.0.3",
     "urlpattern-polyfill": "8.0.2"
   },
-  "gitHead": "0f6098d436437ff65fa97f6c191137f83e42918c"
+  "gitHead": "42d439a0a7c6e12f2444ce3feb66b030e8e4be81"
 }