SoundFont local initialAttenuation does not override global attenuation, making affected presets too quiet

const assert = require('node:assert/strict');
const alphaTab = require('@coderline/alphatab');

// Build an original, looping sine-wave SF2 in memory. Generator 48 uses centibels.
function sf2({ pg, pl, ig, il } = {}) {
  const words = (size, values) => {
    const b = Buffer.alloc(size * values.length);
    values.forEach((v, i) => size === 2 ? b.writeUInt16LE(v & 65535, i * size) : b.writeUInt32LE(v, i * size));
    return b;
  };
  const u16 = (...v) => words(2, v), u32 = (...v) => words(4, v);
  const name = s => { const b = Buffer.alloc(20); b.write(s); return b; };
  const chunk = (id, ...parts) => {
    const body = Buffer.concat(parts);
    return Buffer.concat([Buffer.from(id), u32(body.length), body, Buffer.alloc(body.length % 2)]);
  };
  function zones(global, local, terminal) {
    const gens = [], bags = [u16(0, 0)];
    if (global !== undefined) { gens.push(u16(48, global)); bags.push(u16(gens.length, 0)); }
    if (local !== undefined) gens.push(u16(48, local));
    gens.push(...terminal);
    bags.push(u16(gens.length, 0));
    gens.push(u16(0, 0));
    return { bags: Buffer.concat(bags), gens: Buffer.concat(gens), count: bags.length - 1 };
  }
  const p = zones(pg, pl, [u16(41, 0)]);
  const i = zones(ig, il, [u16(54, 1), u16(53, 0)]);
  const pcm = Buffer.alloc((512 + 46) * 2);
  for (let n = 0; n < 512; n++) pcm.writeInt16LE(Math.round(8000 * Math.sin(2 * Math.PI * n / 64)), n * 2);
  return chunk('RIFF', Buffer.from('sfbk'),
    chunk('LIST', Buffer.from('INFO'), chunk('ifil', u16(2, 1))),
    chunk('LIST', Buffer.from('sdta'), chunk('smpl', pcm)),
    chunk('LIST', Buffer.from('pdta'),
      chunk('phdr', name('Test'), u16(0, 0, 0), u32(0, 0, 0), name('EOP'), u16(0, 0, p.count), u32(0, 0, 0)),
      chunk('pbag', p.bags), chunk('pmod', Buffer.alloc(10)), chunk('pgen', p.gens),
      chunk('inst', name('Test'), u16(0), name('EOI'), u16(i.count)),
      chunk('ibag', i.bags), chunk('imod', Buffer.alloc(10)), chunk('igen', i.gens),
      chunk('shdr', name('Sine'), u32(0, 512, 64, 448, 22050), Buffer.from([60, 0]), u16(0, 1),
        name('EOS'), u32(512, 512, 512, 512, 0), Buffer.from([0, 0]), u16(0, 1))));
}

const xml = `<score-partwise version="4.0"><part-list><score-part id="P">
<part-name>Test</part-name><score-instrument id="I"><instrument-name>Test</instrument-name></score-instrument>
<midi-instrument id="I"><midi-channel>1</midi-channel><midi-program>1</midi-program></midi-instrument>
</score-part></part-list><part id="P"><measure number="1"><attributes><divisions>1</divisions>
<time><beats>4</beats><beat-type>4</beat-type></time><clef><sign>G</sign><line>2</line></clef></attributes>
<direction><sound tempo="96"/></direction><note><pitch><step>C</step><octave>4</octave></pitch>
<duration>4</duration><type>whole</type></note></measure></part></score-partwise>`;
const score = alphaTab.importer.ScoreLoader.loadScoreFromBytes(new TextEncoder().encode(xml));
const midi = new alphaTab.midi.MidiFile();
const generator = new alphaTab.midi.MidiFileGenerator(score, new alphaTab.Settings(), new alphaTab.midi.AlphaSynthMidiFileHandler(midi));
generator.generate();
class Event { on(f) { this.f = f; } trigger() { this.f?.(); } }
function render(parameters) {
  // Offline output adapter: no browser, audio device, network, or external SF2 needed.
  const output = {
    sampleRate: 44100, ready: new Event(), sampleRequest: new Event(), samplesPlayed: new Event(),
    open() { this.ready.trigger(); }, destroy() {}, pause() {}, play() {}, resetSamples() {}, addSamples() {}
  };
  const synth = new alphaTab.synth.AlphaSynth(output, 200);
  const options = new alphaTab.synth.AudioExportOptions();
  options.soundFonts = [sf2(parameters)];
  const exporter = synth.exportAudio(options, midi, generator.syncPoints, generator.transpositionPitches);
  return exporter.render(400).samples;
}
const rms = samples => Math.sqrt(samples.reduce((sum, v) => sum + v * v, 0) / samples.length);
const reference = rms(render({}));
assert.ok(reference > 0.0001, 'Reference must be audible');
const cases = [
  ['preset override', { pg: 200, pl: 120 }, 12],
  ['instrument override', { ig: 127, il: 50 }, 5],
  ['both overrides', { pg: 200, pl: 120, ig: 127, il: 50 }, 17],
  ['inherit missing locals', { pg: 200, ig: 50 }, 25],
  ['preset zero override', { pg: 200, pl: 0, il: 50 }, 5],
  ['instrument zero override', { pl: 120, ig: 127, il: 0 }, 12],
  ['cross-level addition', { pl: 120, il: 50 }, 17],
  ['negative preset offset', { pl: -60, il: 100 }, 4],
  ['default', {}, 0]
];
const results = cases.map(([name, parameters, expectedDb]) => {
  const actualDb = -20 * Math.log10(rms(render(parameters)) / reference);
  return { name, expectedDb, actualDb: Number(actualDb.toFixed(4)), pass: Math.abs(actualDb - expectedDb) < 0.00001 };
});
console.table(results);
assert.ok(results.every(r => r.pass), 'Local attenuation must replace global attenuation at the same level');