feedBack/tests/js/highway_3d_lean_sustain.test.js

// Pins the "lean sustain" rendering default in plugins/highway_3d/screen.js.
//
// Dense palm-mute / fret-hand-mute passages are GPU fill-bound: the
// transparent sustain trails/rails stack many blended fragments. Profiling
// (a pinned A/B loop) traced most of the cost to the additive rail BLOOM
// halo, so by default the renderer skips ONLY the bloom (the most expensive
// per-pixel layer) while KEEPING the thin trail/ribbon white outline that
// gives tails their hit/miss-coloured border.
//
// A refactor that (a) flips the lean default off, (b) re-gates the trail or
// ribbon outline behind the lean flag, or (c) stops feeding the outline the
// hit/miss-aware material would silently regress the look or the perf win.
//
// Source-level only — same strategy as the other tests/js/ files.

const { test } = require('node:test');
const assert = require('node:assert/strict');
const fs = require('node:fs');
const path = require('node:path');

const SCREEN_JS = path.join(__dirname, '..', '..', 'plugins', 'highway_3d', 'screen.js');
// h3d-carve-14: sustain trail code moved to note-renderer.js; trail tests
// must now search both files.
const NOTE_RENDERER_JS = path.join(__dirname, '..', '..', 'plugins', 'highway_3d', 'src', 'note-renderer.js');
const RENDERER_JS = path.join(__dirname, '..', '..', 'plugins', 'highway_3d', 'src', 'renderer.js');
const _noteRendererSrc = fs.readFileSync(NOTE_RENDERER_JS, 'utf8');
const _rendererSrc = fs.readFileSync(RENDERER_JS, 'utf8');

test('lean sustain rendering is the default (_leanSus starts true)', () => {
    const src = fs.readFileSync(SCREEN_JS, 'utf8');
    assert.match(
        src,
        /let\s+_leanSus\s*=\s*true\s*;/,
        '_leanSus must default to true so lean rendering is the out-of-the-box behaviour',
    );
});

test('the full-quality look is an opt-out via localStorage h3d_full_sus', () => {
    // h3d-carve-15: lean poll + setLeanSus call now in renderer.js update()
    const src = fs.readFileSync(SCREEN_JS, 'utf8') + '\n' + fs.readFileSync(RENDERER_JS, 'utf8');
    assert.match(
        src,
        /setLeanSus\s*\(\s*localStorage\.getItem\(\s*['"]h3d_full_sus['"]\s*\)\s*!==\s*['"]1['"]\s*\)/,
        "lean must stay on unless localStorage.h3d_full_sus === '1' opts back into the full look",
    );
});

test('exactly one element is gated behind the lean flag, and it is the rail bloom', () => {
    // h3d-carve-15: lean gate moved to renderer.js; getter form getLeanSus()
    const src = fs.readFileSync(SCREEN_JS, 'utf8') + '\n' + fs.readFileSync(RENDERER_JS, 'utf8');
    // Only the additive rail bloom may hide behind the lean flag. If a future
    // edit re-gates the trail or ribbon outline behind !getLeanSus(), this count
    // climbs above 1 and the test fails — that's the regression guard.
    const gates = src.match(/if\s*\(\s*!getLeanSus\s*\(\s*\)\s*\)/g) || [];
    assert.equal(
        gates.length,
        1,
        'expected exactly one `if (!getLeanSus())` gate (the rail bloom); the outline must stay ungated',
    );
    assert.match(
        src,
        /if\s*\(\s*!getLeanSus\s*\(\s*\)\s*\)\s*\{[\s\S]{0,200}?pSusRailBloom\.get\(\)/,
        'the single lean gate must be the one that wraps pSusRailBloom.get()',
    );
});

test('the trail + ribbon outline always draw and use the hit/miss-aware material', () => {
    // h3d-carve-14: sustain trail body now in note-renderer.js
    const src = fs.readFileSync(SCREEN_JS, 'utf8') + '\n' + _noteRendererSrc;
    // Outline material is hit/miss aware: miss -> mMissOutline, confirmed hit
    // -> bright, otherwise the default mSusOutline white border.
    assert.match(
        src,
        /_susOlMat\s*=\s*_ndState\s*===\s*'miss'\s*\?\s*mMissOutline[\s\S]*?:\s*mSusOutline\s*;/,
        '_susOlMat must remain hit/miss aware so the tail border colours track note state',
    );
    // Box trail: the outline (trOut, pSusOutline) is drawn and fed _susOlMat,
    // immediately followed by the coloured core (tr, pSus) — both ungated.
    assert.match(
        src,
        /const\s+trOut\s*=\s*pSusOutline\.get\(\)\s*;[\s\S]*?trOut\.material\s*=\s*_susOlMat\s*;[\s\S]{0,400}?const\s+tr\s*=\s*pSus\.get\(\)/,
        'the box-trail outline (pSusOutline + _susOlMat) must draw alongside the core trail',
    );
    // Ribbon trail (slide / bend / tremolo / vibrato): the outline (olMesh,
    // pSusRibbonOl) is drawn and fed _susOlMat, then the ribbon body.
    assert.match(
        src,
        /const\s+olMesh\s*=\s*pSusRibbonOl\.get\(\)\s*;[\s\S]*?olMesh\.material\s*=\s*_susOlMat\s*;[\s\S]*?const\s+body\s*=\s*pSusRibbon\.get\(\)/,
        'the ribbon-trail outline (pSusRibbonOl + _susOlMat) must draw alongside the ribbon body',
    );
});