Sum in 2540 sums
Haskell, 25 bytes
b~zw=sum(fromEnum`map`zw)
Try it online!
The ~ is not an infix operator, but a marker for a lazy pattern match on argument zw of b, while conveniently being the largest-valued ASCII character at 126. The infix-ized `map` is also used because the backtick has a large ASCII value of 96. With both of these, we can avoid any spaces or other whitespace, which have low ASCII values.
The dense 24-byter
z~zz=sum$fromEnum`map`zz
comes just short in its sum of 2525, 15 too small. Its average ASCII value is 105.21, with the only values below 97 (for a) being = at 61, $ at 36, and E at 69. An improvement would like involve finding an alternative for one of these.
(Non-ASCII characters can surely do better by having higher character values, but I'm not doing that because this is more interesting.)
Python 3, 11 10 9 bytes
Thanks @MariaMiller for finding the right Unicode character, saving 1 byte!
ࠂ,=sum,
Try it online!
This is essentially just sum, padded with extra characters to reach the sum of 2540. Usage is ࠂ(s) where s is a byte string (which acts like both string and integer array). Feels kinda cheaty, but ¯\_(ツ)_/¯.
The first character in source code is the Unicode character with codepoint 2050 (Samaritan letter Gaman). This character might not be displayable depending on your browser.
The previous solution is longer but has nice Unicode characters:
11 bytes
ϕ,ϴ=sum,9
Try it online!
Brain-Flak, 32 bytes
<[[[{({}()<>)<>}<>({{}[()]})]]]>
Try it online!
Explanation
First the observations I made my first time around (that solution and its explanation is below) continue to be important here. We need and even number of () pairs for a valid answer.
This time however we are going to use a starting program that already has an even number of ()s.
{({}()<>)<>}<>({{}[()]})
This program first increments every element by 1 then calculates the sum of 1 less than every element. If we look at all possible ways to delete from this without causing a bracket mismatch here are what they do:
{(()<>)<>}<>({{}[()]}) # Never halts
{({}<>)<>}<>({{}[()]}) # Sums 1 less than every element
{({}())<>}<>({{}[()]}) # One more than above
{({}()<>)}<>({{}[()]}) # Never halts
{({}()<>)<>}({{}[()]}) # No output
{({}()<>)<>}<>({[()]}) # Never halts
{({}()<>)<>}<>({{}[]}) # Complex output still incorrect
{(<>)<>}<>({{}[()]}) # Never halts
{({})<>}<>({{}[()]}) # Sums 1 less than every element
{({}()<>)<>}<>({{}}) # Sums 1 more than every element
{()<>}<>({{}[()]}) # Sums 1 less than every element
{({}()<>)<>}<>({}) # Adds 1 to every element
{<>}<>({{}[()]}) # Sums 1 less than every element
{({}()<>)<>}<>() # Adds 1 to every element
{}<>({{}[()]}) # Outputs 0
{({}()<>)<>}<> # Adds 1 to every element
<>({{}[()]}) # Outputs 0
{({}()<>)<>} # Outputs nothing
({{}[()]}) # Sums 1 less than every element
So this is a good starting place. To make it the correct sum I use the same method I outlined for the first attempt.
Now we just need the proper combination of
[..]s<..>s and((..){}){}s to hit 2540. Unfortunately while[..]s would be ideal seeing as they have the highest codepoint average I can't seem to get it to work with any of them present.
This time we are luckier and the winning combination is <[[[..]]]>.
Brain-Flak, 34 bytes
<<<<<<<<(((({{}})){}){}){}>>>>>>>>
Try it online!
Explanation
The code that does the task is ({{}}). But we need to pad it to 2540. The main issue is that apart from () every pair has an even total. This means we need and even number of () pairs, and at the same time our starting code uses only 1 () pair.
On top of this unlike [] or <> () pairs are not so easy to add. The one way we can do that is to wrap the entire program in (..){}, so to rectify our issue we alter the base program to
(({{}})){}
Now we just need the proper combination of [..]s <..>s and ((..){}){}s to hit 2540. Unfortunately while [..]s would be ideal seeing as they have the highest codepoint average I can't seem to get it to work with any of them present. The one that works is the one used above.