Spaces:
Sleeping
Sleeping
| // follower_sim.mjs — offline simulator for the frame-based score follower | |
| // (spec: docs/frame-follower-spec.md §8). Node 22 ESM, no dependencies. | |
| // | |
| // WHY: the follower's numbers cannot be tuned on the live rig (one run per | |
| // minute, no ground truth better than typed keys). The sim synthesises a | |
| // deliberately mismatched piano from a trace's score, adds the accompaniment | |
| // bleed on the true timeline exactly as the app reports it, runs the SAME | |
| // FrameAnalyzer and ScoreFollower the browser runs, and scores commits against | |
| // the true onsets. Every scenario in §8.4 has a pass/fail target; exit code 1 | |
| // on any miss. | |
| // | |
| // node scripts/follower_sim.mjs --all | |
| // node scripts/follower_sim.mjs --scenario bleed --seeds 3 --wav /tmp/bleed.wav --out /tmp/bleed.json | |
| // node scripts/follower_sim.mjs --scenario bleed --timeline # per-event: onset, commit, hold reasons | |
| // node scripts/follower_sim.mjs --scenario bleed --synth legacy # the pre-2026-09-15 tone, for audit | |
| // node scripts/follower_sim.mjs --scenario phone-bleed # the mobile case: speaker and mic inches apart | |
| // SIM_DEBUG_MIX=1 node scripts/follower_sim.mjs --scenario phone-bleed # print the mix's measured SER and nonlinear residual | |
| // | |
| // THE TONE THIS SYNTHESISES was measured off the rig on 2026-09-15, not | |
| // guessed: see the RIG block below and scenario table's re-baseline note. Until | |
| // then it was 8 partials with h^-1.3 amplitudes — fundamental-dominant, nothing | |
| // above 784 Hz at a G2 — which is to say it was a picture of the notes the | |
| // engine's shipped 6-partial template already fits, so every attempt to model | |
| // the real rig's upper tail looked like a regression here. `--synth legacy` | |
| // restores that tone exactly (same random draws, same order) so every | |
| // before/after number in the scenario table can be re-checked in one command. | |
| // | |
| // Debug environment (frame-level, for one scenario at a time): | |
| // SIM_DEBUG=t0,t1 print one line per frame between t0 and t1 seconds of audio | |
| // SIM_DEBUG_H=1 add the candidate/committed hypothesis internals (caps, gains, onset score, pitch margin) | |
| // SIM_DEBUG_ELL=1 add the candidate's and committed state's likelihoods and NNLS gains | |
| // SIM_DEBUG_X=1 dump the whitened observation and the best hypothesis' templates | |
| // SIM_DEBUG_RES=1 dump the committed fit, its residual and the observation's top rows | |
| // SIM_DEBUG_BEAM=1 list every live hypothesis (index, weight, evidence, birth, parent) per frame | |
| // SIM_VERBOSE=1 print false/missed lists and hold histograms for passing scenarios too | |
| // | |
| // KNOWN LIMIT, found while building `low-note-weak` and not fixed here. Through | |
| // a laptop speaker a G2 arrives as its partials, and its strongest one is | |
| // 196 Hz — which IS G3. So a plain G3 fits a fundamental-starved G2 template | |
| // almost exactly, while a G2 does NOT fit a G3 template (294 Hz is left over). | |
| // The confusion is one-way, and it is sharp: with a G2 written immediately | |
| // before a G3, the G3's attack spawns a fresh "the G2 starts NOW" hypothesis | |
| // that out-weighs the real one, the committed state's onset clock jumps a beat | |
| // late, and the future guard then refuses the G3 for a whole IOI — measured | |
| // recall 0.05 with the engine tracking the right rhythm five events behind. | |
| // Twinkle never writes that interval (all five of its G2s are followed by B2 or | |
| // C3), so no scenario here contains it; a piece that did would need the engine | |
| // to price the missing 294 Hz, not just tolerate a missing fundamental. | |
| import fs from 'node:fs'; | |
| import path from 'node:path'; | |
| import { fileURLToPath, pathToFileURL } from 'node:url'; | |
| const HERE = path.dirname(fileURLToPath(import.meta.url)); | |
| const ROOT = path.resolve(HERE, '..'); | |
| const STATIC = path.join(ROOT, 'static'); | |
| // Import the very modules the browser loads (query strings are part of the | |
| // specifier in follower.js; Node resolves them as distinct file URLs). | |
| const salience = await import(pathToFileURL(path.join(STATIC, 'salience.js')).href); | |
| const followerMod = await import(pathToFileURL(path.join(STATIC, 'follower.js')).href); | |
| const { FrameAnalyzer } = salience; | |
| const { ScoreFollower, FOLLOWER_DEFAULTS, FOLLOWER_VERSION, normaliseEvents } = followerMod; | |
| // --------------------------------------------------------------------------- | |
| // CLI | |
| // --------------------------------------------------------------------------- | |
| function parseArgs(argv) { | |
| const a = { opt: {}, seeds: 1, seed: 1, scenario: null, all: false, sr: 48000, json: false, quiet: false, dumpSal: false, trackerDebounce: false, reverb: false }; | |
| for (let i = 0; i < argv.length; i++) { | |
| const k = argv[i]; | |
| const next = () => argv[++i]; | |
| switch (k) { | |
| case '--trace': a.trace = next(); break; | |
| case '--score': a.score = next(); break; | |
| case '--scenario': a.scenario = next(); break; | |
| case '--all': a.all = true; break; | |
| case '--seeds': a.seeds = Number(next()); break; | |
| case '--seed': a.seed = Number(next()); break; | |
| case '--bpm': a.bpm = Number(next()); break; | |
| case '--tempo-scale': a.tempoScale = Number(next()); break; | |
| case '--bleed': a.bleed = Number(next()); break; | |
| case '--snr': a.snr = Number(next()); break; | |
| case '--hpf': a.hpf = Number(next()); break; | |
| case '--jitter': a.jitter = Number(next()); break; | |
| case '--rubato': a.rubato = Number(next()); break; | |
| case '--bleed-lag': a.bleedLag = Number(next()); break; | |
| case '--bleed-clip': a.bleedClip = Number(next()); break; // phone-speaker soft clip drive (0 = linear) | |
| case '--sr': a.sr = Number(next()); break; | |
| case '--synth': a.synth = next(); break; // rig (measured, default) | legacy (pre-2026-09-15 8-partial h^-1.3) | |
| case '--opt': { const s = next(); const eq = s.indexOf('='); a.opt[s.slice(0, eq)] = parseOptValue(s.slice(eq + 1)); break; } | |
| case '--wav': a.wav = next(); break; | |
| case '--out': a.out = next(); break; | |
| case '--replay': a.replay = next(); break; | |
| case '--json': a.json = true; break; | |
| case '--dump-sal': a.dumpSal = true; break; | |
| case '--quiet': a.quiet = true; break; | |
| case '--reverb': a.reverb = true; break; | |
| case '--tracker-debounce': a.trackerDebounce = true; break; | |
| case '--timeline': a.timeline = true; break; | |
| case '--help': case '-h': usage(); process.exit(0); | |
| default: console.error('unknown argument ' + k); usage(); process.exit(2); | |
| } | |
| } | |
| if (a.scenario === 'all') { a.all = true; a.scenario = null; } | |
| return a; | |
| } | |
| function parseOptValue(s) { | |
| if (s === 'true') return true; | |
| if (s === 'false') return false; | |
| if (s.startsWith('[') || s.startsWith('{')) return JSON.parse(s); | |
| const n = Number(s); | |
| return Number.isFinite(n) ? n : s; | |
| } | |
| function usage() { | |
| console.log(`node scripts/follower_sim.mjs [--trace PATH] [--score twinkle|repeated] [--scenario NAME|all|--all] [--seeds N] [--seed N] | |
| [--bpm X] [--tempo-scale X] [--bleed G] [--snr DB] [--hpf HZ] [--jitter MS] [--rubato PCT] [--bleed-lag MS] [--bleed-clip G] | |
| [--sr 48000|44100] [--synth rig|legacy] [--opt key=value ...] [--wav OUT.wav] [--out TRACE.json] [--replay SESSION.json] | |
| [--json] [--dump-sal] [--quiet] [--reverb] [--tracker-debounce]`); | |
| } | |
| // --------------------------------------------------------------------------- | |
| // Deterministic randomness | |
| // --------------------------------------------------------------------------- | |
| function makeRng(seed) { | |
| let s = (seed >>> 0) || 1; | |
| const rnd = () => { | |
| s = (s + 0x6D2B79F5) >>> 0; | |
| let t = s; | |
| t = Math.imul(t ^ (t >>> 15), t | 1); | |
| t ^= t + Math.imul(t ^ (t >>> 7), t | 61); | |
| return ((t ^ (t >>> 14)) >>> 0) / 4294967296; | |
| }; | |
| return { | |
| uniform: (lo = 0, hi = 1) => lo + (hi - lo) * rnd(), | |
| normal: (mu = 0, sd = 1) => { | |
| let u = 0; while (u === 0) u = rnd(); | |
| return mu + sd * Math.sqrt(-2 * Math.log(u)) * Math.cos(2 * Math.PI * rnd()); | |
| }, | |
| next: rnd, | |
| }; | |
| } | |
| // --------------------------------------------------------------------------- | |
| // Scores | |
| // --------------------------------------------------------------------------- | |
| // Twinkle as recorded in .accompy_traces (solo G2–A3 with a chord at the ends, | |
| // accompaniment one octave up — the harmonic-overlap bleed the rig actually has). | |
| const TWINKLE_RH = [[[48],0],[[55],1],[[52],2],[[55],3],[[53],4],[[57],5],[[48],6],[[55],7],[[43],8],[[47],9],[[48],10],[[52],11],[[43],12],[[47],13],[[48,52],14],[[52],16],[[55],17],[[50],18],[[55],19],[[48],20],[[55],21],[[47],22],[[55],23],[[52],24],[[55],25],[[50],26],[[55],27],[[48],28],[[55],29],[[47],30],[[43],31],[[48],32],[[55],33],[[52],34],[[55],35],[[53],36],[[57],37],[[48],38],[[55],39],[[43],40],[[47],41],[[48],42],[[52],43],[[43],44],[[47],45],[[48,52],46]]; | |
| const TWINKLE_LH = [[[60],0],[[60],1],[[67],2],[[67],3],[[69],4],[[69],5],[[67],6],[[65],8],[[65],9],[[64],10],[[64],11],[[62],12],[[62],13],[[60],14],[[67],16],[[67],17],[[65],18],[[65],19],[[64],20],[[64],21],[[62],22],[[67],24],[[67],25],[[65],26],[[65],27],[[64],28],[[64],29],[[62],30],[[60],32],[[60],33],[[67],34],[[67],35],[[69],36],[[69],37],[[67],38],[[65],40],[[65],41],[[64],42],[[64],43],[[62],44],[[62],45],[[60],46]]; | |
| // Repeats and unison-with-bleed that Twinkle lacks (§8.1). | |
| const REPEATED_RH = [48, 48, 48, 48, 55, 55, 48, 48, 52, 52, 48, 48].map((p, i) => [[p], i, 1]); | |
| const REPEATED_LH = [0, 2, 4, 6, 8, 10].map((b) => [[REPEATED_RH[b][0][0] + 12], b, 2]); | |
| // The index-8/index-12 configuration of .accompy_traces/20260915-081347, | |
| // stretched out. G2 (MIDI 43, 98.00 Hz) is the lowest note of the solo part, | |
| // and every one of its audible partials belongs to something else in the piece: | |
| // 2f0 = 196.0 Hz is G3 (MIDI 55, ITSELF a solo pitch), 3f0 = 294.0 Hz is D4 | |
| // (MIDI 62, +2 cents — the same FFT bin at 48 kHz/2048) and 4f0 = 392.0 Hz is | |
| // G4 (MIDI 67, exact); D4 and G4 are the two commonest accompaniment pitches | |
| // here. B2 (123.47 Hz) is the same trap one step up: 3f0 = 370.4 Hz is F#4. | |
| // The accompaniment strikes G4 and D4 under the low notes, including two | |
| // D4+G4 chords, so the bleed component and the solo template compete for the | |
| // same rows — the configuration in which the real session died. Bars 1–2 are | |
| // Twinkle's own opening, which is what the real engine got right (12 clean | |
| // advances in 16.7 s) before it met index 8; from there on half the events are | |
| // G2 or B2. | |
| // | |
| // One ordering is deliberately absent, and it is not a convenience: NO G2 is | |
| // followed by a G3. With the fundamental gone a G2 IS a G3 plus a 294 Hz | |
| // partial, so a G3 fits a starved-G2 template while a G2 does NOT fit a G3 | |
| // template (the 294 Hz is unexplained) — the confusion is one-way. Twinkle | |
| // never writes that interval either (its five G2s are followed by B2 or C3 | |
| // every time), so a scenario that used it would be testing a figure the | |
| // repertoire does not contain. See the note in the header of this file. | |
| const LOWNOTE_RH = [ | |
| 48, 55, 52, 55, 53, 57, 48, 55, // Twinkle bar 1: the beam locks on | |
| 43, 47, 48, 52, 43, 47, 48, 52, // the real trace's index 8–15 | |
| 43, 47, 43, 48, 52, 43, 47, 43, // G2-dense, D4/G4 underneath | |
| 48, 43, 47, 43, | |
| ].map((p, i) => [[p], i, 1]); | |
| const LOWNOTE_LH = [[60], [67], [69], [67], [62], [67], [62], [67], [62, 67], [62], [67], [62], [67], [62, 67]].map((p, i) => [p, i * 2, 2]); | |
| // The note density that broke the engine, taken from the score that broke it: | |
| // .accompy_traces/20260916-113517_cello-concerto-no1-in-c-major-hobviib1-joseph-ha | |
| // (Haydn cello concerto no. 1, 143 solo notes over 120 beats at 60 bpm, recall | |
| // 7 %). `DENSE_PITCHES` and `DENSE_GAPS24` ARE that trace's meta.rh, first 200 | |
| // solo events, read out verbatim — not a fast pattern invented here. Two | |
| // properties are taken from the real score together, because it is the pair | |
| // that makes the passage hard and either one alone is easy: | |
| // | |
| // 1. THE SPACING. Gaps in this prefix: p10 0.125 b, p25 0.125 b, MEDIAN | |
| // 0.250 b, p75 0.500 b; 66 of 199 (33 %) are under 0.25 beat. The whole | |
| // excerpt reads p10 0.125 / median 0.250 with 128 of 350 under 0.25 beat | |
| // (37 %), so the prefix carries the same distribution. At bps 1 that is | |
| // 250 ms median and 125 ms in the fastest decile, against an engine whose | |
| // own end-to-end commit latency on the two reference Twinkles is 175-182 ms | |
| // median and 203-212 ms p90. A third of these notes are therefore OVER | |
| // before the evidence for them has been accumulated — by construction, not | |
| // by bad luck. (Both Twinkles' shortest IOI is 985 ms: nothing in the | |
| // existing suite is within 4x of this.) | |
| // 2. THE PITCH AMBIGUITY. 16 distinct pitches over 200 events, MIDI 60-84, | |
| // with 79/74/76/72 carrying most of them. On the full excerpt one pitch | |
| // leaves a median of 37 candidate positions and it takes a 5-gram before | |
| // the median position is unique. A dense score written out of a scale | |
| // would be localisable from one frame and would test the commit rule | |
| // instead of the search, which is the thing under test here. | |
| // | |
| // Gaps longer than 1.5 beats are CLAMPED to 1.5. The real prefix contains a | |
| // 16-beat and a 103-beat tutti; a long rest is the one thing that hands the | |
| // engine a free re-lock, and this scenario is the runaway player. Clamping | |
| // drops 121 beats of silence, so the piece runs 83 beats instead of 204. | |
| const DENSE_PITCHES = [ | |
| 72, 74, 72, 71, 72, 74, 76, 77, 77, 76, 74, 76, 77, 76, 71, 72, 67, 64, 60, 72, | |
| 71, 67, 74, 72, 72, 74, 72, 71, 72, 74, 76, 77, 77, 76, 74, 69, 81, 79, 77, 76, | |
| 74, 72, 71, 83, 83, 81, 81, 81, 81, 79, 79, 79, 76, 78, 78, 79, 79, 79, 81, 83, | |
| 84, 81, 83, 84, 83, 84, 83, 84, 83, 79, 79, 74, 76, 72, 71, 69, 67, 69, 69, 71, | |
| 69, 71, 69, 71, 69, 71, 67, 79, 79, 84, 84, 79, 82, 82, 81, 80, 81, 79, 77, 76, | |
| 74, 72, 74, 74, 76, 74, 76, 74, 76, 74, 76, 72, 79, 81, 79, 79, 79, 84, 84, 84, | |
| 84, 84, 84, 84, 83, 81, 79, 77, 77, 76, 74, 72, 74, 76, 74, 76, 74, 76, 74, 76, | |
| 72, 72, 72, 79, 81, 79, 78, 79, 81, 83, 84, 84, 83, 81, 83, 84, 83, 78, 79, 79, | |
| 77, 76, 76, 78, 79, 78, 81, 81, 79, 79, 77, 76, 76, 78, 79, 78, 79, 81, 79, 79, | |
| 81, 83, 79, 74, 71, 72, 74, 71, 67, 76, 78, 79, 76, 72, 72, 74, 76, 72, 69, 69, | |
| ]; | |
| // Twenty-fourths of a beat, so the score's own quantisation survives: 3 = 0.125 b | |
| // (x56), 6 = 0.25 b (x55), 12 = 0.5 b (x33), 24 = 1 b (x17), plus the 4s and 9s | |
| // of the triplet and dotted figures. | |
| const DENSE_GAPS24 = [ | |
| 18, 3, 3, 9, 3, 9, 3, 12, 24, 12, 18, 3, 3, 12, 12, 12, 12, 24, 12, 12, | |
| 24, 12, 12, 24, 18, 3, 3, 9, 3, 9, 3, 12, 24, 12, 6, 6, 12, 6, 6, 6, | |
| 6, 24, 36, 12, 36, 12, 36, 12, 36, 12, 12, 12, 30, 6, 6, 6, 30, 6, 6, 6, | |
| 30, 6, 6, 6, 24, 24, 24, 24, 6, 6, 6, 6, 6, 6, 6, 6, 18, 6, 3, 3, | |
| 3, 3, 3, 3, 3, 3, 36, 36, 36, 6, 24, 6, 6, 6, 6, 6, 6, 6, 6, 6, | |
| 6, 18, 6, 3, 3, 3, 3, 3, 3, 3, 3, 12, 24, 24, 12, 24, 30, 6, 6, 6, | |
| 30, 6, 6, 6, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, | |
| 12, 12, 36, 18, 3, 3, 9, 3, 9, 3, 12, 24, 12, 18, 3, 3, 12, 12, 12, 24, | |
| 12, 12, 16, 4, 4, 4, 4, 4, 12, 24, 12, 12, 16, 4, 4, 4, 4, 4, 6, 3, | |
| 3, 6, 6, 6, 3, 3, 6, 6, 6, 3, 3, 6, 6, 6, 3, 3, 6, 6, 6, | |
| ]; | |
| const DENSE_TRANSPOSE = -12; // see REGISTER below | |
| const DENSE_RH = DENSE_PITCHES.map((p, i) => { | |
| let b = 0; for (let k = 0; k < i; k++) b += DENSE_GAPS24[k] / 24; | |
| return [[p + DENSE_TRANSPOSE], +b.toFixed(4)]; | |
| }); | |
| // REGISTER. The solo is transposed DOWN AN OCTAVE and the accompaniment line | |
| // sits above it, which is the one place this scenario departs from the | |
| // recording, so it is stated plainly rather than buried. | |
| // | |
| // The real excerpt writes the solo at MIDI 60-84 over an orchestral reduction | |
| // whose commonest pitches are 72 (x538), 62 (x507), 67 (x477) and 60 (x472) — | |
| // i.e. the accompaniment is mostly BELOW the solo. In the 33..96 bank that | |
| // configuration inverts the partial counts: a MIDI 84 solo note shows TWO | |
| // partials below the bank top (1046 and 2093 Hz, bankTopHz 2154) while a MIDI | |
| // 60 accompaniment note shows eight and a MIDI 55 one shows ten, so the bleed | |
| // component's comb covers every row the solo template owns and a great many | |
| // more. Measured with the accompaniment there: the bleed explained a median | |
| // 0.73 of the frame against the expected solo note's 0.11, `ev` never rose | |
| // above 0 on the committed event, and the scenario read recall 0.10 with the | |
| // accompaniment ON against 0.54 with it OFF. The wide search went with it: | |
| // top-1 error median +4 events, only 6 % within +-1, 25 of 31 scans pointing | |
| // AHEAD of the pianist — which the 1.5-nat margin bar correctly refused every | |
| // single time (31 scans, 31 `ambiguous`), so nothing unsafe happened, but the | |
| // scenario was measuring an inverted-register bleed and not the note density. | |
| // | |
| // That register is ALSO the one part of this bench that has never been | |
| // measured. The RIG profile was taken on Twinkle, where the accompaniment is | |
| // an octave ABOVE the solo, and both other built-in scores keep it there. So | |
| // the choice is between reproducing an unvalidated corner of the synth and | |
| // testing the thing the scenario is named for. It tests the density: the solo | |
| // moves to MIDI 48-72 (Twinkle's own register, where a note has 8-21 visible | |
| // partials) and the accompaniment to a line in 72-79 above it, which is the | |
| // relationship BASE's `bleed` 1.0 was calibrated against. The RHYTHM — the | |
| // only thing under test — is untouched. | |
| // | |
| // What that costs in fidelity is worth naming: with the accompaniment below, | |
| // this scenario reproduces the real session almost exactly (recall 0.10 here | |
| // against 0.07 on the rig). Above, it reads 0.45. The difference is the | |
| // register, not the density, and it is the measurement that says the Haydn's | |
| // remaining 90 % is a BLEED problem in the solo's own register — the same | |
| // conclusion the mic-distance work reached from the other side. Set | |
| // DENSE_TRANSPOSE to 0 and DENSE_LH_LINE back below the solo to re-run it. | |
| const DENSE_LH_LINE = [72, 79, 76, 74, 72, 77, 79, 76, 74, 72, 76, 79, 77, 74, 72, 76]; | |
| const DENSE_LH = (() => { | |
| const out = []; | |
| for (let b = 0; b <= Math.floor(DENSE_RH[DENSE_RH.length - 1][1]); b++) out.push([[DENSE_LH_LINE[b % DENSE_LH_LINE.length]], b, 1]); | |
| return out; | |
| })(); | |
| function loadScore(args) { | |
| if (args.score === 'repeated') return { name: 'repeated', rh: REPEATED_RH, lh: REPEATED_LH, bps: 1 }; | |
| if (args.score === 'lownote') return { name: 'lownote', rh: LOWNOTE_RH, lh: LOWNOTE_LH, bps: 1 }; | |
| if (args.score === 'dense') return { name: 'dense', rh: DENSE_RH, lh: DENSE_LH, bps: 1 }; | |
| const tracePath = args.trace || path.join(ROOT, '.accompy_traces', 'latest.json'); | |
| try { | |
| const tr = JSON.parse(fs.readFileSync(tracePath, 'utf8')); | |
| const m = tr.meta || {}; | |
| if (Array.isArray(m.rh) && m.rh.length) return { name: m.score || path.basename(tracePath), rh: m.rh, lh: Array.isArray(m.lh) ? m.lh : [], bps: m.initialBps || 1 }; | |
| } catch (e) { /* fall through to the built-in copy */ } | |
| return { name: 'twinkle (built-in)', rh: TWINKLE_RH, lh: TWINKLE_LH, bps: 1 }; | |
| } | |
| // --------------------------------------------------------------------------- | |
| // Synthesis (§8.2) — the measured rig, with `--synth legacy` as the fallback | |
| // --------------------------------------------------------------------------- | |
| const midiToFreq = (m) => 440 * 2 ** ((m - 69) / 12); | |
| // --------------------------------------------------------------------------- | |
| // THE MEASURED RIG (§8.2). One block: edit this and nothing else when the rig | |
| // is re-measured. | |
| // --------------------------------------------------------------------------- | |
| // SOURCE: .accompy_traces/20260915-083040_twinkle-twinkle-little-star.json. | |
| // Every verbose follow.frame's quantised `sal` was decoded with the engine's | |
| // own dequantiseSal and re-whitened with the follower's own noise-floor | |
| // parameters as recorded in that trace's follower.init (nfMargin 2, nfDown 0.3, | |
| // nfUp 1.002, floorInitFrames 20, nfSmoothBins 4, compress 0.5); each typed | |
| // input.key gave a (post − pre) mean-POWER spectrum — sustain +160..+340 ms, | |
| // attack +40..+140 ms, pre-roll −350..−100 ms — which was deconvolved against | |
| // the analyser's own toneResponse() columns by NNLS (one column per partial, | |
| // plus free columns for any accompaniment pitch ringing in the span and for the | |
| // sub-fundamental bins). 43 presses with no other key within ±400 ms: MIDI 43 | |
| // ×16 (12 with no accompaniment ringing at all), 55 ×9, 48 ×5, 52 ×5, 47 ×3, | |
| // 50 ×2, 41/53/57 ×1. NNLS R² 0.983–0.9997. Profile script and the full JSON | |
| // (per-pitch a(h) with p25/p75, the noise floor, the overlap tables): | |
| // scratchpad/partial_profile5.mjs → scratchpad/rig_partial_profile.json | |
| // | |
| // Everything below is in the RAW (post − pre) power domain, never the whitened | |
| // one. Whitening divides by the min-statistics floor, which on this session is | |
| // +1.88 dB at row 43 and −13.22 dB at row 89 — a ~15 dB tilt that belongs to | |
| // the mic and the analyser, not to the note. Partials fitted to whitened | |
| // numbers would apply that tilt twice; the sim's own pink noise reproduces it | |
| // (measured floor −3.94 dB/octave in this constant-Q bank against pink's −3.0, | |
| // i.e. right to within ~1 dB — the floor is NOT what the bench got wrong). | |
| // | |
| // WHAT THE OLD SYNTH GOT WRONG — three independent things, and it is worth | |
| // naming them because five attempts at modelling the real rig's upper tail were | |
| // reverted for "regressing" scenarios that could not contain the phenomenon: | |
| // | |
| // 1. TRUNCATION. `for (let h = 1; h <= 8; h++)` stopped every pitch at 8 | |
| // partials, so a synthetic G2 had NOTHING above 784 Hz. The real G2 is a | |
| // near-flat-topped comb running to the top of the 33..96 bank, sitting at | |
| // −7 to −13 dB (re its strongest partial) all the way to h = 20 (1960 Hz, | |
| // row 95). h^-1.3 puts h8 at −11.7 dB and h9+ at −∞; the rig is 20–40 dB | |
| // louder than that over half the bank. The deep raw NULLS in between | |
| // (MIDI 43 h8 at −34.2 dB with h7 at −10.4 and h10 at −7.0) prove this is | |
| // LINE structure, not a broadband hiss a noise floor could stand in for. | |
| // 2. NO PLAYBACK RESPONSE. The exponent was never the problem: alternating | |
| // least squares on L(pitch,h) = C_pitch − 20·alpha·log10(h) + R(f) over all | |
| // nine measured pitches gives alpha = 1.14 (rmse 5.12 dB) against 8.20 dB | |
| // for the same fit with no R, and the per-pitch exponents then agree with | |
| // each other (0.92–1.30). One source law plus ONE rig curve explains every | |
| // pitch; there is no pitch-specific tone. R rises ~22 dB from 110 Hz to | |
| // 1.8 kHz — that rise is what creates the tail, and the old synth had no | |
| // counterpart to it at all. | |
| // 3. THE WRONG LOW END. speakerHpf 180 / speakerOrder 4 takes 21.2 dB off a | |
| // 98 Hz fundamental. Measured, the rig takes 12–14 dB off 98–139 Hz | |
| // relative to its 440–880 Hz plateau — roughly 1st-order with a corner near | |
| // 200–250 Hz, and a TILT rather than a corner. The laptop mic shares a | |
| // chassis with the laptop speaker, so the fundamental arrives | |
| // structure-borne: 1.8 dB (row readout) / 5.2 dB (deconvolved) below the | |
| // strongest partial in a G2's sustain. What buries it in the ENGINE's | |
| // domain is the noise floor's tilt, not the speaker. | |
| // | |
| // Cross-check of the whole chain against numbers already recorded in | |
| // FOLLOWER_DEFAULTS for the real G2 at 15.657 s — expected whitened peak row 83, | |
| // row94 0.70, row95 0.66, row74 0.70, row81 0.53, rows40–47 0.09; the profile | |
| // pipeline reproduces 83 / 0.682 / 0.608 / 0.613 / 0.510 / 0.094. | |
| const RIG = { | |
| // H(m) = floor(bankTopHz / f0): every partial the 33..96 filterbank can see. | |
| // 2154 Hz = midiToFreq(96)·2^(1/24), the top row's upper edge. 24 partials at | |
| // MIDI 41, 21 at G2 (43), 16 at C3, 10 at G3, 8 at C4, 4 at C5. | |
| bankTopHz: 2154, | |
| // Source law a_src(h) = h^-alpha. Measured 1.14 over nine pitches; 1.10 is | |
| // the value the per-pitch medians centre on once R is removed (41:0.92, | |
| // 43:1.08, 47:1.06, 48:1.10, 50:1.22, 52:1.10, 53:1.58, 55:1.12, 57:1.30). | |
| alpha: 1.10, | |
| // Playback response R(f), 1/3-octave bands, dB, with the press count each | |
| // band was averaged over. +8.5 dB resonance at 349 Hz, −4.6 dB dip at 698 Hz, | |
| // +7..+9 dB above 1.1 kHz. Interpolated in log f, clamped to the end values. | |
| // CAVEAT, stated rather than buried: the f0 span of the measurement is only | |
| // 1.3 octaves, so the alpha/R split is under-determined — treat R as a | |
| // measured curve of this laptop, not as physics. | |
| responseDb: [ | |
| [110, -13.56], [139, -12.17], [175, -6.23], [220, -1.63], [277, 3.94], | |
| [349, 8.52], [440, 0.11], [554, -0.34], [698, -4.56], [880, -2.48], | |
| [1109, 3.78], [1397, 7.06], [1760, 9.30], [2217, 8.26], | |
| ], | |
| // Every partial except the fundamental repeats press to press: the measured | |
| // p75−p25 per partial has a median of 1.9 dB at MIDI 43 (16 presses) and | |
| // 0.6–1.3 dB at 48/52/55, so each note draws an independent ±2 dB ripple on | |
| // h ≥ 2 (uniform(−2,2) has an inter-quartile range of 2 dB). | |
| partialRippleDb: 2, | |
| // ...the fundamental alone is stochastic, and only at the bottom of the | |
| // range. Measured p75−p25 of a(1): MIDI 43 (98 Hz, 16 presses) 17.0 dB, | |
| // 52 (165 Hz, 5) 25.4 dB, 48 (131 Hz, 5) 7.6 dB, 47 (123 Hz, 3) 6.3 dB, | |
| // against 0.0 dB at MIDI 55 (196 Hz) over NINE presses, where a(1) is the | |
| // strongest partial every single time. So below `fundamentalSpreadBelowHz` | |
| // the fundamental is drawn with MIDI 43's own quartiles (median −5.2 dB re | |
| // the strongest partial, p25 −18.8, p75 −1.8 → σ = 20.2 dB below the median | |
| // and 5.0 dB above it) and above it the law's own a(1) stands. "The note | |
| // that loses its fundamental" is a per-PRESS event, not a property of the | |
| // pitch, and no scenario produced one before this. | |
| // These are MIDI 43's own quartiles, which is what the profile recommends; | |
| // pooling all 31 presses below 180 Hz (43, 47, 48, 50, 52) weighted by press | |
| // count gives median −8.9 / p25 −20.9 / p75 −6.1 instead, so the choice moves | |
| // the fundamental by under 4 dB and is not load-bearing. Below p25 the normal | |
| // tail is an extrapolation — `min` bounds it at −45 dB, and MIDI 52's | |
| // measured p25 of −39.6 dB says collapses that deep do happen. | |
| fundamentalDb: { median: -5.2, sdLow: 20.2, sdHigh: 5.0, max: 2, min: -45 }, | |
| fundamentalSpreadBelowHz: 180, | |
| // The profile above is a SUSTAIN profile, measured +160..+340 ms after the | |
| // input.key EVENT — and the rig's speaker→mic loop is ~110 ms (the app's own | |
| // measured median on this session, see low-note-lag-over below), so in NOTE | |
| // time that window is +50..+230 ms and its centre is 140 ms. Partial | |
| // amplitudes are referred to t = profileSec, so a rendered note matches the | |
| // measured a(h) in the window a(h) was measured in rather than at t = 0. | |
| // This also reproduces, for free, the measured "partials above h = 15 are | |
| // 5–15 dB louder in the attack than in the sustain" (MIDI 43 h20: rawAttDb | |
| // −6.45 against rawSusDb −17.22). | |
| profileSec: 0.14, | |
| // The player types on the LAPTOP keyboard, a few centimetres from the mic: | |
| // 28 % of the power a G2 press adds in the attack window sits BELOW the | |
| // fundamental, falling to 7 % by the sustain. The old hammer burst was | |
| // band-passed 1–5 kHz and had no low thump at all. | |
| thumpShareAttack: 0.28, | |
| thumpHz: 100, | |
| thumpTauSec: 0.035, | |
| thumpWindowSec: 0.14, | |
| // Inharmonicity B in fh = h·f0·√(1 + B·h²). The old 4e-4 was a piano STRING | |
| // and it was harmless while h stopped at 8 (+1.3 % at h8); at h = 20 it is | |
| // +6.5 %, more than a semitone, so every partial above ~h12 landed in the | |
| // wrong filterbank row. The rig's solo voice is the app's own digital synth | |
| // through a speaker: measured, MIDI 43's partials sit on their harmonic rows | |
| // out to h = 21 (h10 → row 83, h14 → row 89, h20 → row 95). 2e-5 keeps a | |
| // touch of stretch (+7 cents at h20, +10 at h24) without moving rows. | |
| inharmonicity: 2e-5, | |
| }; | |
| // The pre-2026-09-15 synth, kept so every number in this file stays auditable: | |
| // `--synth legacy` (or `synth: 'legacy'` in a scenario mut) restores it exactly | |
| // — 8 partials, h^-1.3, no playback response, no fundamental spread, no thump. | |
| // It is fundamental-dominant by construction (h8 at −11.7 dB, nothing above), | |
| // which is to say it is a picture of the notes the engine's shipped 6-partial | |
| // template already fits well. Do not baseline against it. | |
| const LEGACY_SYNTH = { partials: 8, alpha: 1.3, inharmonicity: 4e-4 }; | |
| // R(f) in dB, log-f interpolation between the measured 1/3-octave bands. | |
| function rigResponseDb(f) { | |
| const B = RIG.responseDb; | |
| if (!(f > B[0][0])) return B[0][1]; | |
| if (f >= B[B.length - 1][0]) return B[B.length - 1][1]; | |
| for (let i = 1; i < B.length; i++) { | |
| if (f <= B[i][0]) { | |
| const k = Math.log(f / B[i - 1][0]) / Math.log(B[i][0] / B[i - 1][0]); | |
| return B[i - 1][1] + k * (B[i][1] - B[i - 1][1]); | |
| } | |
| } | |
| return B[B.length - 1][1]; | |
| } | |
| // Two-sided normal: the fundamental's press-to-press spread is strongly skewed | |
| // (p25 −18.8, median −5.2, p75 −1.8), so one σ per side, both from the quartiles. | |
| function splitNormalDb(rng, { median, sdLow, sdHigh, max, min }) { | |
| const z = rng.normal(0, 1); | |
| return Math.min(max, Math.max(min, median + z * (z < 0 ? sdLow : sdHigh))); | |
| } | |
| // Piano-like additive tone, deliberately NOT the engine's template. Under the | |
| // default `rig` model (see RIG above) it is the laptop speaker + laptop mic | |
| // measured on 20260915-083040: H(m) = floor(2154/f0) partials, a(h) = | |
| // h^-1.10 · R(h·f0) referred to the sustain window, ±3 dB of per-press ripple | |
| // on h ≥ 2, a fundamental drawn with its own 17 dB spread, inharmonicity, | |
| // per-partial decays with random spread, a hammer burst, a keyboard thump | |
| // (solo only — the accompaniment is not typed) and a release tail. Amplitudes | |
| // are normalised so `gain` still means "the strongest partial's amplitude", | |
| // exactly as it did when the strongest partial was always h = 1. | |
| // `legacy: true` restores the old 8-partial h^-1.3 tone. Renders into `mix` at | |
| // `t0` seconds. | |
| function renderNote(mix, sr, rng, { midi, t0, noteOffSec, gain, detuneCents = 0, legacy = false, thumpShare = 0 }) { | |
| const f0 = midiToFreq(midi) * 2 ** (detuneCents / 1200); | |
| const start = Math.max(0, Math.round(t0 * sr)); | |
| const relSec = 0.15; | |
| const endSec = noteOffSec + relSec + 0.05; | |
| const nSamp = Math.min(mix.length - start, Math.ceil(endSec * sr)); | |
| if (nSamp <= 0) return; | |
| const hMax = legacy ? LEGACY_SYNTH.partials : Math.max(1, Math.floor(RIG.bankTopHz / f0)); | |
| const alpha = legacy ? LEGACY_SYNTH.alpha : RIG.alpha; | |
| const B = legacy ? LEGACY_SYNTH.inharmonicity : RIG.inharmonicity; | |
| const parts = []; | |
| for (let h = 1; h <= hMax; h++) { | |
| const fh = h * f0 * Math.sqrt(1 + B * h * h); | |
| if (fh >= sr / 2) break; | |
| const tau = 0.9 * (200 / fh) ** 0.35 * rng.uniform(0.8, 1.2); | |
| // `sus` is the decay already suffered by t = profileSec: dividing it out | |
| // makes the SUSTAIN spectrum equal the measured a(h) instead of the t = 0 | |
| // one, which also reproduces the measured "h ≥ 15 is 5–15 dB louder in the | |
| // attack than in the sustain" for free. | |
| const sus = legacy ? 1 : Math.exp(-RIG.profileSec / tau); | |
| let amp = h ** -alpha; | |
| if (!legacy) amp *= 10 ** ((rigResponseDb(fh) + (h === 1 ? 0 : rng.uniform(-RIG.partialRippleDb, RIG.partialRippleDb))) / 20) / sus; | |
| parts.push({ amp, sus, w: 2 * Math.PI * fh / sr, tau, ph: rng.uniform(0, 2 * Math.PI) }); | |
| } | |
| if (!parts.length) return; | |
| if (!legacy) { | |
| // The fundamental is drawn against the strongest of the OTHER partials, | |
| // which is where it was measured from; for a G2 that strongest partial is | |
| // h3 (294 Hz, on the rig's 349 Hz resonance), never h1. | |
| let peakSus = 0; | |
| for (let i = 1; i < parts.length; i++) peakSus = Math.max(peakSus, parts[i].amp * parts[i].sus); | |
| if (peakSus > 0 && f0 < RIG.fundamentalSpreadBelowHz) parts[0].amp = peakSus * 10 ** (splitNormalDb(rng, RIG.fundamentalDb) / 20) / parts[0].sus; | |
| // `gain` keeps meaning "amplitude of the strongest partial in the sustain". | |
| let peak = 0; | |
| for (const p of parts) peak = Math.max(peak, p.amp * p.sus); | |
| if (peak > 0) for (const p of parts) p.amp /= peak; | |
| } | |
| const attackN = Math.max(1, Math.round(0.004 * sr)); | |
| const offN = Math.round(noteOffSec * sr); | |
| const relN = Math.round(relSec * sr); | |
| for (let i = 0; i < nSamp; i++) { | |
| const t = i / sr; | |
| let env = i < attackN ? i / attackN : 1; | |
| if (i >= offN) { const k = (i - offN) / relN; if (k >= 1) break; env *= 1 - k; } | |
| let v = 0; | |
| for (const p of parts) v += p.amp * Math.exp(-t / p.tau) * Math.sin(p.w * i + p.ph); | |
| mix[start + i] += gain * env * v; | |
| } | |
| // Hammer: 15 ms of band-passed (1–5 kHz) noise at −20 dB relative to the tone. | |
| const hN = Math.round(0.015 * sr); | |
| const bp = biquadBandpass(sr, 1000, 5000); | |
| for (let i = 0; i < hN && start + i < mix.length; i++) { | |
| const n = bp.process(rng.normal(0, 1)) * 0.3; | |
| mix[start + i] += gain * 0.1 * n * (1 - i / hN); | |
| } | |
| // Keyboard thump — the one part of a press that is not a note. Measured: 28 % | |
| // of the power a G2 press adds over the attack window sits below f0. Scaled | |
| // against this note's own tonal power over the same window, so the share is | |
| // what was measured rather than an absolute level. | |
| if (thumpShare > 0 && thumpShare < 1) { | |
| const tN = Math.min(mix.length - start, Math.round(RIG.thumpWindowSec * sr)); | |
| if (tN > 0) { | |
| let msTone = 0; | |
| for (const p of parts) { // mean square of Σ amp·e^{−t/τ}·sin(...) over the window | |
| const r = Math.exp(-2 / (p.tau * sr)); | |
| msTone += 0.5 * p.amp * p.amp * (r === 1 ? tN : (1 - r ** tN) / (1 - r)) / tN; | |
| } | |
| const lp1 = biquadLowpass(sr, RIG.thumpHz), lp2 = biquadLowpass(sr, RIG.thumpHz); | |
| const buf = new Float64Array(tN); | |
| let msBuf = 0; | |
| for (let i = 0; i < tN; i++) { buf[i] = lp2.process(lp1.process(rng.normal(0, 1))) * Math.exp(-(i / sr) / RIG.thumpTauSec); msBuf += buf[i] * buf[i]; } | |
| msBuf /= tN; | |
| if (msBuf > 0 && msTone > 0) { | |
| const g = gain * Math.sqrt(thumpShare / (1 - thumpShare) * msTone / msBuf); | |
| for (let i = 0; i < tN; i++) mix[start + i] += g * buf[i]; | |
| } | |
| } | |
| } | |
| } | |
| // Second-order sections. Butterworth high-pass (Q = 1/√2) for the speaker/mic | |
| // model; a wide band-pass for the hammer burst. | |
| function biquad(b0, b1, b2, a1, a2) { | |
| let x1 = 0, x2 = 0, y1 = 0, y2 = 0; | |
| return { process(x) { const y = b0 * x + b1 * x1 + b2 * x2 - a1 * y1 - a2 * y2; x2 = x1; x1 = x; y2 = y1; y1 = y; return y; } }; | |
| } | |
| function biquadHighpass(sr, fc, Q = Math.SQRT1_2) { | |
| const w = 2 * Math.PI * fc / sr, c = Math.cos(w), s = Math.sin(w), al = s / (2 * Q); | |
| const a0 = 1 + al; | |
| return biquad((1 + c) / 2 / a0, -(1 + c) / a0, (1 + c) / 2 / a0, -2 * c / a0, (1 - al) / a0); | |
| } | |
| // A laptop speaker, not a microphone: almost nothing below ~150–200 Hz reaches | |
| // the room. Two cascaded Butterworth sections roll off as (f/fc)^4, so at | |
| // fc = 180 Hz a G2 loses 21.2 dB of its 98 Hz fundamental and 0.3 dB of its | |
| // 196 Hz second partial — the physics behind the index-12 stall in | |
| // 20260915-081347, where the lowest solo note reached the mic as its harmonics | |
| // and nothing else. `hpf` (the mic's own high-pass) stays separate: this one | |
| // sits in the PLAYBACK path, so it shapes the solo and the accompaniment | |
| // together and leaves the room noise alone. | |
| function speakerChain(sr, fc, order) { | |
| const secs = []; | |
| for (let i = 0; i < Math.max(1, Math.round(order / 2)); i++) secs.push(biquadHighpass(sr, fc)); | |
| return { process(x) { for (const s of secs) x = s.process(x); return x; } }; | |
| } | |
| // Two of these in series make the laptop-chassis keyboard thump: a soft | |
| // low-pass at 100 Hz, i.e. below every solo fundamental in the repertoire. | |
| function biquadLowpass(sr, fc, Q = Math.SQRT1_2) { | |
| const w = 2 * Math.PI * fc / sr, c = Math.cos(w), s = Math.sin(w), al = s / (2 * Q); | |
| const a0 = 1 + al; | |
| return biquad((1 - c) / 2 / a0, (1 - c) / a0, (1 - c) / 2 / a0, -2 * c / a0, (1 - al) / a0); | |
| } | |
| function biquadBandpass(sr, fLo, fHi) { | |
| const fc = Math.sqrt(fLo * fHi), Q = fc / (fHi - fLo); | |
| const w = 2 * Math.PI * fc / sr, c = Math.cos(w), s = Math.sin(w), al = s / (2 * Q); | |
| const a0 = 1 + al; | |
| return biquad(al / a0, 0, -al / a0, -2 * c / a0, (1 - al) / a0); | |
| } | |
| // Pink noise, Voss–McCartney with 16 rows. | |
| function pinkNoise(n, rng) { | |
| const rows = 16, vals = new Float64Array(rows); | |
| let sum = 0; | |
| for (let r = 0; r < rows; r++) { vals[r] = rng.normal(); sum += vals[r]; } | |
| const out = new Float32Array(n); | |
| for (let i = 0; i < n; i++) { | |
| // Row k updates every 2^k samples (trailing-zero count of the counter). | |
| let k = 0, c = i + 1; | |
| while ((c & 1) === 0 && k < rows - 1) { c >>= 1; k++; } | |
| sum -= vals[k]; vals[k] = rng.normal(); sum += vals[k]; | |
| out[i] = (sum + rng.normal()) / Math.sqrt(rows + 1); | |
| } | |
| return out; | |
| } | |
| function rmsOf(buf) { let s = 0; for (let i = 0; i < buf.length; i++) s += buf[i] * buf[i]; return Math.sqrt(s / buf.length); } | |
| // Build the performance: true onset times, which events are played/wrong/ | |
| // skipped, the accompaniment fire list, and the audio mix. | |
| function synthesise(score, cfg, rng) { | |
| const sr = cfg.sr; | |
| const bps = cfg.bps * cfg.tempoScale; | |
| const rubato = cfg.rubato / 100; | |
| // Rubato is a ±rubato TEMPO modulation over a 16-beat cycle, integrated so | |
| // time stays monotonic: dT/dbeat = (1 − rubato·sin(2π·beat/16)) / bps. | |
| const A = rubato * 16 / (2 * Math.PI); | |
| const timeOfBeat = (beat) => (beat - A * (1 - Math.cos(2 * Math.PI * beat / 16))) / bps; | |
| const tempoAtBeat = (beat) => bps / (1 - rubato * Math.sin(2 * Math.PI * beat / 16)); | |
| const solo = normaliseEvents(score.rh); | |
| const acc = normaliseEvents(score.lh); | |
| // Which tone model renders every note below (see RIG / LEGACY_SYNTH above). | |
| const legacy = cfg.synth === 'legacy'; | |
| const thumpShare = legacy ? 0 : RIG.thumpShareAttack; | |
| const preRoll = 1.0; // the mic is open before Play: the floors must learn on noise alone | |
| // Session started at a later event (startAt): the prefix is never played | |
| // and the accompaniment starts from that beat, as in the app. The engine is | |
| // seeked there startLead × IOI before the first note (see runEngine). | |
| const startAt = Math.min(Math.max(0, cfg.startAt || 0), solo.length - 1); | |
| const startBeat = startAt > 0 ? solo[startAt].beat : -Infinity; | |
| // A run of notes that are in the piece nowhere: cfg.wrongInsert = [index, n] | |
| // puts n intruders in front of event `index` and pushes the rest of the piece | |
| // — the solo AND the ideal accompanist with it — n beats later. The pitches | |
| // miss every pitch in the score and every pitch a partial of one would land | |
| // on, so the WRONG absorber is the only thing that can explain those frames | |
| // and takes the mass legitimately: the state the real session entered at | |
| // 17.5 s and never left. | |
| // | |
| // They are INSERTED, not substituted, so that when the pianist recovers he is | |
| // playing the very event the engine is already waiting for. Substituting | |
| // score events would also demand a four-event skip on the way back, which is | |
| // what `skipped-note` measures; this scenario is about whether the beam can | |
| // come back at all once the absorber owns the posterior. | |
| const inPiece = new Set(); | |
| for (const e of solo) for (const p of e.pitches) for (const d of [0, 12, 19, 24, 28]) inPiece.add(p + d); | |
| for (const e of acc) for (const p of e.pitches) for (const d of [0, 12, 19]) inPiece.add(p + d); | |
| // The nearest pitch to `p` that the piece does not contain — and that the | |
| // engine can actually TELL is not in the piece. Below pitchMinMidi (54) an | |
| // off-score pitch is not off-score to the follower: at 48 kHz/2048 rows 40–44 | |
| // are all bin 4, so an A2 played where a G2 is written is the same | |
| // observation and an intruder there would be asking the engine to hear a | |
| // difference that is not in the signal (it cost 18 early advances when this | |
| // scenario first put its intruders at 42/45/46). | |
| const offScore = (p) => { | |
| const q = Math.min(84, Math.max(54, Math.round(p))); | |
| for (let d = 0; d <= 24; d++) for (const s of d ? [1, -1] : [1]) { const m = q + d * s; if (m >= 54 && m <= 84 && !inPiece.has(m)) return m; } | |
| return q; | |
| }; | |
| const ins = cfg.wrongInsert || null; | |
| const insBeat = ins ? solo[Math.min(ins[0], solo.length - 1)].beat : Infinity; | |
| const insDelay = ins ? ins[1] / bps : 0; | |
| const shift = (beat) => (beat >= insBeat ? insDelay : 0); | |
| const events = solo.map((e, k) => { | |
| const ioi = k + 1 < solo.length ? timeOfBeat(solo[k + 1].beat) - timeOfBeat(e.beat) : (e.durBeats ?? 1) / bps; | |
| const T = preRoll + timeOfBeat(e.beat) + shift(e.beat) + rng.normal(0, cfg.jitter / 1000); | |
| let kind = 'played', pitches = e.pitches.slice(); | |
| if (cfg.wrongEvery && (k + 1) % cfg.wrongEvery === 0 && k > 0) { | |
| kind = 'wrong'; | |
| // A fumble must not land on a pitch the score writes NEXT DOOR. Twinkle | |
| // writes B2 at index 9 and C3 at index 10, so the old `p + 1` played | |
| // index 10's own note one beat early and then scored the engine's | |
| // (correct) recognition of it as an early advance. Under the | |
| // fundamental-dominant synth that never bit — a B2 and a C3 arrived as | |
| // nearly the same observation. Under the measured 21-partial comb the | |
| // engine can tell them apart, and the un-guarded mutation cost 1 early | |
| // advance and 12 false ones (recall 1.00 → 0.22) the moment the synth | |
| // became real. `wrongInsert`'s offScore() has carried exactly this guard | |
| // since it was written, for exactly this reason; this is the same rule. | |
| const near = new Set(); | |
| for (let d = -1; d <= 2; d++) { const e2 = solo[k + d]; if (e2) for (const p of e2.pitches) near.add(p); } | |
| const order = rng.next() < 0.5 ? [1, 2, -1, -2, 3, -3] : [2, 1, -2, -1, 3, -3]; | |
| pitches = pitches.map((p) => { for (const d of order) if (!near.has(p + d)) return p + d; return p + order[0]; }); | |
| } | |
| if (cfg.skipEvery && (k + 1) % cfg.skipEvery === 0 && k > 0) { kind = 'skipped'; } | |
| if (cfg.noPlay || k < startAt) kind = 'silent'; | |
| const restrike = cfg.doubleStrike && kind === 'played' && rng.next() < 0.25; | |
| const durSec = Math.min(0.95 * ioi, (e.durBeats ?? ioi * bps) / bps); | |
| return { k, beat: e.beat, T, ioi, kind, pitches, expected: e.pitches, durSec, restrike, tempo: tempoAtBeat(e.beat) }; | |
| }); | |
| const lastEnd = Math.max(...events.map((e) => e.T + e.durSec)) + 1.5; | |
| const n = Math.ceil(lastEnd * sr); | |
| const soloBuf = new Float32Array(n); | |
| for (const e of events) { | |
| if (e.kind === 'skipped' || e.kind === 'silent') continue; | |
| const vel = 0.6 * rng.uniform(0.7, 1.4); | |
| for (const p of e.pitches) renderNote(soloBuf, sr, rng, { midi: p, t0: e.T, noteOffSec: e.durSec, gain: vel, detuneCents: rng.uniform(-3, 3), legacy, thumpShare }); | |
| if (e.restrike) for (const p of e.pitches) renderNote(soloBuf, sr, rng, { midi: p, t0: e.T + 0.09, noteOffSec: Math.max(0.05, e.durSec - 0.09), gain: vel * 0.8, detuneCents: rng.uniform(-3, 3), legacy, thumpShare }); | |
| } | |
| // The intruders, in the n beats the rest of the piece was pushed back by. | |
| const intruders = []; | |
| if (ins) { | |
| const base = solo[Math.min(ins[0], solo.length - 1)]; | |
| for (let j = 0; j < ins[1]; j++) { | |
| const T = preRoll + timeOfBeat(base.beat) + j / bps + rng.normal(0, cfg.jitter / 1000); | |
| // A fumble in the pianist's own register, not down where the filterbank | |
| // gives up: these must be audibly, resolvably not the written note. | |
| const pitches = [offScore(58 + [0, 7, -3, 11, 3, 8][j % 6])]; | |
| const durSec = 0.95 / bps; | |
| intruders.push({ T, pitches, durSec }); | |
| const vel = 0.6 * rng.uniform(0.7, 1.4); | |
| for (const p of pitches) renderNote(soloBuf, sr, rng, { midi: p, t0: T, noteOffSec: durSec, gain: vel, detuneCents: rng.uniform(-3, 3), legacy, thumpShare }); | |
| } | |
| } | |
| // Accompaniment on the true solo timeline of its beat (an ideal accompanist), | |
| // audible bleedLag later; the fire is reported at fireMs, before the loop. | |
| const accBuf = new Float32Array(n); | |
| const fires = []; | |
| for (let k = 0; k < acc.length; k++) { | |
| const a = acc[k]; | |
| if (a.beat < startBeat) continue; | |
| const nextBeat = k + 1 < acc.length ? acc[k + 1].beat : a.beat + (a.durBeats ?? 1); | |
| const durSec = (a.durBeats ?? (nextBeat - a.beat)) / bps; | |
| const fireSec = preRoll + timeOfBeat(a.beat) + shift(a.beat); | |
| fires.push({ pitches: a.pitches, fireSec, durSec, beat: a.beat }); | |
| // Same speaker, therefore the same R(f) and the same partial-count rule; | |
| // no keyboard thump, because the accompanist is not typing. Level: measured | |
| // median −5.0 dB re the solo note it covers (range −2.2 to −27.3 over 22 | |
| // presses), which BASE's bleed 1.0 against the solo's 0.6·uniform(0.7,1.4) | |
| // already brackets — the bleed path is the one part of this bench that | |
| // matched the rig, and it is unchanged. | |
| if (cfg.bleed > 0) for (const p of a.pitches) renderNote(accBuf, sr, rng, { midi: p, t0: fireSec + cfg.bleedLag / 1000, noteOffSec: durSec, gain: 0.6 * cfg.bleed, detuneCents: rng.uniform(-3, 3), legacy }); | |
| } | |
| // PHONE SPEAKER NONLINEARITY (`bleedClip`, off unless a scenario asks). | |
| // A memoryless sigmoidal saturation on the accompaniment ONLY — the solo | |
| // reaches the mic through the air from a real piano and never goes through | |
| // our loudspeaker. This is the Hammerstein front end the AEC literature uses | |
| // for hand-held devices (Hofmann et al., EURASIP JASP 2016:113: "increasingly | |
| // common nonlinear distortions produced by miniaturized amplifiers and | |
| // loudspeakers in modern portable devices"), and it is exactly what the | |
| // ICASSP AEC Challenge applies to 80 % of its far-end signals: "clipping the | |
| // maximum amplitude, using a sigmoidal function ... or applying learned | |
| // distortion functions" (Cutler et al., arXiv:2009.04972). Peak-preserving so | |
| // `bleed` stays the level knob and `bleedClip` is purely the drive: | |
| // y = A·tanh(g·x/A)/tanh(g), A = peak|accBuf|, g = cfg.bleedClip | |
| // g = 0 is the identity (bit-exact skip, so every existing scenario is | |
| // untouched). The residual it injects is measured and printed by | |
| // SIM_DEBUG_MIX=1 as `nl` — see the phone-bleed comment for the number. | |
| let nlResidDb = null; | |
| if (cfg.bleedClip > 0) { | |
| let A = 0; for (let i = 0; i < n; i++) A = Math.max(A, Math.abs(accBuf[i])); | |
| if (A > 0) { | |
| const g = cfg.bleedClip; | |
| // Two passes: shape, then restore the RMS the linear signal had, so | |
| // `bleed` stays the only level knob and `bleedClip` is pure drive. | |
| let l2 = 0, y2 = 0; | |
| for (let i = 0; i < n; i++) { const x = accBuf[i], y = Math.tanh(g * x / A); l2 += x * x; y2 += y * y; } | |
| const k = y2 > 0 ? Math.sqrt(l2 / y2) : 1; | |
| let d2 = 0; | |
| for (let i = 0; i < n; i++) { | |
| const x = accBuf[i], y = k * Math.tanh(g * x / A); | |
| d2 += (y - x) * (y - x); | |
| accBuf[i] = y; | |
| } | |
| nlResidDb = l2 > 0 ? 10 * Math.log10(d2 / l2) : null; | |
| } | |
| } | |
| // The playback path. Under the default `rig` synth the measured response | |
| // R(f) is ALREADY in every partial's amplitude, so this chain is off unless a | |
| // scenario asks for it by name: with speakerHpf set it is the explicit | |
| // `speaker-dead-low` variant — a laptop whose low end is deader than the one | |
| // that was measured — and NOT the model of this rig (see RIG note 3). Under | |
| // `--synth legacy` it is the only low-end model there is. Solo and | |
| // accompaniment leave the SAME speaker, so it applies to both (every | |
| // accompaniment pitch here is ≥ 261 Hz, so in practice it only bites the low | |
| // solo notes). Filtered before the mix so the --snr noise is still measured | |
| // against the solo level the mic actually hears; the room noise itself | |
| // reaches the mic directly and is not filtered. | |
| if (cfg.speakerHpf > 0) { | |
| const spS = speakerChain(sr, cfg.speakerHpf, cfg.speakerOrder ?? 4), spA = speakerChain(sr, cfg.speakerHpf, cfg.speakerOrder ?? 4); | |
| for (let i = 0; i < n; i++) { soloBuf[i] = spS.process(soloBuf[i]); accBuf[i] = spA.process(accBuf[i]); } | |
| } | |
| const mix = new Float32Array(n); | |
| for (let i = 0; i < n; i++) mix[i] = soloBuf[i] + accBuf[i]; | |
| // SIGNAL-TO-ECHO RATIO, measured rather than asserted. The AEC literature's | |
| // mixing parameter is the SER over DOUBLE-TALK frames only (ICASSP AEC | |
| // Challenge: "a signal to echo ratio uniformly sampled from -10 dB to 10 dB"), | |
| // not over the whole file — the accompaniment's duty cycle is far higher than | |
| // the solo's, so a whole-file ratio would flatter it. Measured here over | |
| // 512-sample hops in which BOTH sources are audibly present, as | |
| // 20·log10(median soloRms / median accRms). Reported so every scenario's | |
| // `bleed` gain can be quoted in the field's own units. | |
| let serDb = null; | |
| { | |
| const H = 512, sHop = [], aHop = []; | |
| for (let o = 0; o + H <= n; o += H) { | |
| let ss = 0, aa = 0; | |
| for (let i = o; i < o + H; i++) { ss += soloBuf[i] * soloBuf[i]; aa += accBuf[i] * accBuf[i]; } | |
| sHop.push(Math.sqrt(ss / H)); aHop.push(Math.sqrt(aa / H)); | |
| } | |
| const p90 = (v) => { const q = v.slice().sort((x, y) => x - y); return q.length ? q[Math.min(q.length - 1, Math.floor(0.9 * q.length))] : 0; }; | |
| const sOn = 0.1 * p90(sHop), aOn = 0.1 * p90(aHop); | |
| const sD = [], aD = []; | |
| for (let i = 0; i < sHop.length; i++) if (sHop[i] > sOn && aHop[i] > aOn) { sD.push(sHop[i]); aD.push(aHop[i]); } | |
| const med = (v) => { const q = v.slice().sort((x, y) => x - y); return q.length ? q[Math.floor(q.length / 2)] : 0; }; | |
| if (sD.length > 8 && med(aD) > 0) serDb = 20 * Math.log10(med(sD) / med(aD)); | |
| if (process.env.SIM_DEBUG_MIX) console.log(` mix: bleed ${cfg.bleed} lag ${cfg.bleedLag}ms clip ${cfg.bleedClip} -> SER ${serDb === null ? '-' : serDb.toFixed(1)} dB over ${sD.length}/${sHop.length} double-talk hops (${(100 * sD.length / sHop.length).toFixed(0)}%), nl residual ${nlResidDb === null ? '-' : nlResidDb.toFixed(1)} dB`); | |
| } | |
| // Pink noise at --snr dB below the solo RMS (a silent solo uses the nominal level). | |
| const soloRms = rmsOf(soloBuf) || 0.05; | |
| const noise = pinkNoise(n, rng); | |
| const noiseGain = soloRms / rmsOf(noise) * 10 ** (-cfg.snr / 20); | |
| for (let i = 0; i < n; i++) mix[i] += noiseGain * noise[i]; | |
| if (cfg.reverb) { const d = Math.round(0.04 * sr), g = 10 ** (-12 / 20); for (let i = n - 1; i >= d; i--) mix[i] += g * mix[i - d]; } | |
| if (cfg.hpf > 0) { const hp = biquadHighpass(sr, cfg.hpf); for (let i = 0; i < n; i++) mix[i] = hp.process(mix[i]); } | |
| // Keep the mix inside ±1 like a real capture would. | |
| let peak = 0; for (let i = 0; i < n; i++) peak = Math.max(peak, Math.abs(mix[i])); | |
| if (peak > 0.98) { const g = 0.98 / peak; for (let i = 0; i < n; i++) mix[i] *= g; } | |
| const seekSec = startAt > 0 ? events[startAt].T - (cfg.startLead ?? 0.3) * events[startAt].ioi : null; | |
| return { mix, events, fires, intruders, sr, bps, preRoll, startAt, seekSec, serDb, nlResidDb }; | |
| } | |
| // --------------------------------------------------------------------------- | |
| // Pipeline (§8.3): identical to the worklet | |
| // --------------------------------------------------------------------------- | |
| const SIM_TRANSPORT_MS = 15; // audio → caller clock (models main-thread delivery) | |
| // The app's role: forward-only, maxJump, ack; optional classic debounce mirror. | |
| class FakeTracker { | |
| constructor(score, opts = {}) { | |
| this.score = score; this.position = 0; this.commits = []; this.rejects = 0; | |
| this.debounce = !!opts.debounce; this.bps = opts.bps || 1; | |
| this._lastTime = null; this._lastBeat = null; this._lastPitch = null; | |
| } | |
| advanceTo(idx, { maxJump, inputPitch }, nowSec) { | |
| if (idx < this.position) { this.rejects++; return null; } | |
| if (idx > this.position + maxJump) { this.rejects++; return null; } | |
| if (idx >= this.score.length) { this.rejects++; return null; } | |
| const ev = this.score[idx]; | |
| if (this.debounce && this._lastTime !== null) { | |
| const elapsed = nowSec - this._lastTime; | |
| const beatDelta = Math.max(0, ev.beat - this._lastBeat); | |
| const expected = beatDelta > 0 ? beatDelta / this.bps : 0.18; | |
| const minAdvanceSec = Math.min(0.18, Math.max(0.07, expected * 0.45)); | |
| const minRepeatedSec = Math.min(0.34, Math.max(0.12, expected * 0.65)); | |
| if (elapsed < minAdvanceSec) { this.rejects++; return null; } | |
| if (this._lastPitch !== null && Math.abs(this._lastPitch - inputPitch) <= 1 && elapsed < minRepeatedSec) { this.rejects++; return null; } | |
| } | |
| this._lastTime = nowSec; this._lastBeat = ev.beat; this._lastPitch = inputPitch; | |
| this.position = idx + 1; | |
| return ev.beat; | |
| } | |
| } | |
| function runEngine(perf, score, cfg, hooks = {}) { | |
| const { mix, events, fires, sr } = perf; | |
| const win = cfg.opt.win ?? 2048, hop = cfg.opt.hop ?? 512; | |
| const engineOpts = { ...cfg.opt }; | |
| delete engineOpts.win; delete engineOpts.hop; | |
| const analyzer = new FrameAnalyzer(sr, { win, hop, minMidi: 33, maxMidi: 96, startAt: 0 }); | |
| const follower = new ScoreFollower({ | |
| solo: score.rh, accompaniment: score.lh, bps: cfg.bps, sampleRate: sr, win, hop, | |
| filterbank: analyzer.filterbank, position: 0, | |
| options: { accompFallback: false, ...engineOpts }, | |
| }); | |
| const solo = normaliseEvents(score.rh); | |
| const tracker = new FakeTracker(solo, { debounce: cfg.trackerDebounce, bps: cfg.bps * cfg.tempoScale }); | |
| const gate = cfg.gate ?? 0.001; | |
| const outputs = []; // { tMs, out } for scoring pWrong etc. | |
| const advances = []; | |
| const resyncs = []; // out.resync: the follower's wide-window jumps (follower.js _resyncScan) | |
| const scans = []; // out.resyncScan: EVERY armed wide scan, fired or refused, with its reason | |
| const holds = []; | |
| const bleeds = []; | |
| const states = []; | |
| const frames = []; | |
| let fireIdx = 0; | |
| const chunk = new Float32Array(128); | |
| let seqCheck = -1, lastToIndex = -1, offered = new Set(); | |
| let seeked = perf.seekSec === null; | |
| let seekAudioMs = null; // when the seek below actually fired, so buildTrace can record it (see follow.seek there) | |
| for (let off = 0; off < mix.length; off += 128) { | |
| const nCh = Math.min(128, mix.length - off); | |
| for (let i = 0; i < 128; i++) chunk[i] = i < nCh ? mix[off + i] : 0; | |
| for (const f of analyzer.push(chunk)) { | |
| const audioMs = f.at / sr * 1000; | |
| const nowMs = audioMs + SIM_TRANSPORT_MS; | |
| // Start at a later beat: the app moves the tracker and rebuilds the | |
| // beam there with seek(position, performance.now()) while the engine | |
| // already runs on the open mic. Position 0 never exercises this path | |
| // (the pre-start state is exempt from the future guard). | |
| if (!seeked && audioMs >= perf.seekSec * 1000) { seeked = true; seekAudioMs = audioMs; follower.seek(perf.startAt, nowMs); tracker.position = perf.startAt; } | |
| // Report accompaniment fires whose time has come, exactly as the app does (before the loop delay). | |
| while (fireIdx < fires.length && fires[fireIdx].fireSec * 1000 <= audioMs) { | |
| const fr = fires[fireIdx++]; | |
| const atMs = fr.fireSec * 1000 + SIM_TRANSPORT_MS; | |
| follower.accompanimentFired({ pitches: fr.pitches, atMs, durMs: fr.durSec * 1000, beat: fr.beat }); | |
| hooks.onFire?.({ pitches: fr.pitches, beat: fr.beat, atMs, durMs: fr.durSec * 1000, audioMs: fr.fireSec * 1000 }); | |
| } | |
| const frame = { | |
| type: 'frame', seq: f.seq, at: f.at, sr, win: f.win, hop: f.hop, rms: f.rms, db: f.db, floorDb: f.floorDb, | |
| flux: f.flux, onset: f.onset, hfc: f.hfc, sal: f.sal, peak: f.peak, noiseFloor: null, gated: f.rms < gate, attack: false, | |
| }; | |
| if (cfg.dumpSal) console.log(`${(audioMs / 1000).toFixed(3)}s db=${f.db.toFixed(1)} floor=${f.floorDb.toFixed(1)} onset=${f.onset.toFixed(2)} peak=${f.peak}`); | |
| const out = follower.observe(frame, nowMs); | |
| // §3.3 guarantees, asserted. | |
| if (out.seq !== frame.seq) throw new Error('output.seq mismatch'); | |
| if (seqCheck >= 0 && out.seq !== seqCheck + 1) throw new Error('seq gap in sim'); | |
| seqCheck = out.seq; | |
| // RESYNCHRONISATION (follower 2026-09-16.3). Its own emission, never | |
| // counted as a detection: the app moves the tracker with the engine's | |
| // OWN explicit maxJump (MAX_ACOUSTIC_EVENT_JUMP = 1 would refuse it) and | |
| // then seeks the follower, which is what _acceptOffer does internally on | |
| // the ack. Modelled here so `--replay` measures the same behaviour the | |
| // app will produce. | |
| if (out.resyncScan) scans.push({ ...out.resyncScan, tMs: out.tMs, audioMs }); | |
| if (out.resync) { | |
| const r = out.resync; | |
| const beat = tracker.advanceTo(r.toIndex, { maxJump: r.maxJump, inputPitch: r.pitches[r.pitches.length - 1] }, audioMs / 1000); | |
| follower.ack(r.id, beat !== null); | |
| if (beat !== null) { offered.add(r.toIndex); lastToIndex = r.toIndex; } | |
| resyncs.push({ ...r, accepted: beat !== null, tMs: out.tMs, audioMs: out.tMs - SIM_TRANSPORT_MS }); | |
| } | |
| if (out.advance) { | |
| const adv = out.advance; | |
| if (adv.toIndex < tracker.position) throw new Error(`advance.toIndex ${adv.toIndex} < position ${tracker.position}`); | |
| if (offered.has(adv.toIndex)) throw new Error(`toIndex ${adv.toIndex} offered twice without a refused ack`); | |
| const beat = tracker.advanceTo(adv.toIndex, { maxJump: adv.maxJump, inputPitch: adv.pitches[adv.pitches.length - 1] }, audioMs / 1000); | |
| follower.ack(adv.id, beat !== null); | |
| if (beat !== null) offered.add(adv.toIndex); | |
| advances.push({ ...adv, accepted: beat !== null, tMs: out.tMs, audioMs: out.tMs - SIM_TRANSPORT_MS, mode: out.mode, heardMidi: adv.heardMidi }); | |
| lastToIndex = adv.toIndex; | |
| } else if (out.hold) holds.push({ ...out.hold, tMs: out.tMs, pos: out.position }); | |
| if (out.state) states.push({ ...out.state, tMs: out.tMs, pos: out.position, p: out.best?.p ?? null }); | |
| // The watchdog moved off out.state (it was overwritten by BACKTRACK and | |
| // by the mode change); keep it visible in the states column. | |
| if (out.recovered) states.push({ mode: 'RECOVER', reason: out.recovered.reason, tMs: out.tMs, pos: out.position, p: out.best?.p ?? null }); | |
| if (out.bleed) bleeds.push({ ...out.bleed }); | |
| outputs.push({ tMs: out.tMs, audioMs, pWrong: out.pWrong, best: out.best, informative: out.informative }); | |
| frames.push({ frame, out }); | |
| hooks.onFrame?.(frame, out, follower); | |
| } | |
| } | |
| return { follower, tracker, advances, resyncs, scans, holds, bleeds, states, outputs, frames, events, lastToIndex, seekAudioMs }; | |
| } | |
| // --------------------------------------------------------------------------- | |
| // Scoring (§8.4) | |
| // --------------------------------------------------------------------------- | |
| const quantile = (arr, q) => { | |
| if (!arr.length) return null; | |
| const a = arr.slice().sort((x, y) => x - y); | |
| const pos = (a.length - 1) * q, lo = Math.floor(pos), hi = Math.ceil(pos); | |
| return a[lo] + (a[hi] - a[lo]) * (pos - lo); | |
| }; | |
| const EARLY_MS = 60; // a commit this far before the true onset is an advance AHEAD of the pianist | |
| // A wide-window jump may land this many events BEHIND the pianist's true | |
| // event and no more (see resyncBad in scoreRun for the measurement this comes | |
| // from). THE TOLERANCE IS ONE-SIDED, and the asymmetry is the whole point: a | |
| // jump that lands short is a catch-up the next ordinary advance closes, while | |
| // a jump that lands on an event the pianist has NOT BEGUN is the accompaniment | |
| // playing a note nobody played -- the one direction `early` forbids for | |
| // ordinary advances, and the one the comment above resyncBad says was never | |
| // observed. A symmetric assertion passed exactly that: on `dense-drift | |
| // --seed 1` the jump 13 -> 62 at t 34293 ms, with the pianist's last begun | |
| // event 61 and event 62 starting 161 ms later, read `resyncBad 0` while | |
| // directly causing the run's only `early` (event 64 committed 235 ms before | |
| // its onset, 448 ms after the jump). | |
| const RESYNC_LAND_EVENTS = 1; | |
| // Drift the engine is allowed to carry without it counting as an interval of | |
| // being behind: 1 is what perfect tracking reads, 2 is one note of slack for a | |
| // commit that lands after the next onset — which at this bench's 125 ms fastest | |
| // decile is unavoidable and is not the failure being measured. | |
| const DRIFT_OK = 2; | |
| function scoreRun(res, perf) { | |
| const events = perf.events; | |
| const played = events.filter((e) => e.kind === 'played'); | |
| const hits = new Map(); | |
| const falses = []; | |
| const latencies = [], onsetErrs = [], tempoErrs = []; | |
| for (const adv of res.advances) { | |
| if (!adv.accepted) continue; | |
| const e = events[adv.toIndex]; | |
| const tCommit = adv.audioMs / 1000; | |
| const inWindow = e && e.kind === 'played' && tCommit >= e.T - 0.05 && tCommit <= e.T + 0.4 && !hits.has(adv.toIndex); | |
| if (inWindow) { | |
| hits.set(adv.toIndex, adv); | |
| latencies.push((tCommit - e.T) * 1000); | |
| onsetErrs.push(adv.onsetAtMs - SIM_TRANSPORT_MS - e.T * 1000); | |
| tempoErrs.push(adv.bps - e.tempo); | |
| } else falses.push(adv); | |
| } | |
| const missed = played.filter((e) => !hits.has(e.k)); | |
| // Early advances: any accepted commit more than EARLY_MS before the true | |
| // onset of the event it names, whatever that event's kind. A subset of | |
| // `false`, counted separately because it is the one failure the follower | |
| // exists to eliminate (the accompaniment moving ahead of the pianist) and | |
| // no scenario may tolerate even one of them, including those whose `false` | |
| // target allows a stray late or mis-indexed commit. | |
| const early = res.advances.filter((a) => a.accepted && events[a.toIndex] && a.audioMs / 1000 < events[a.toIndex].T - EARLY_MS / 1000); | |
| // Resync after skips: a hit on one of the next two played events. | |
| let resyncFails = 0; | |
| for (const e of events) if (e.kind === 'skipped') { | |
| const after = events.filter((x) => x.k > e.k && x.kind === 'played').slice(0, 2); | |
| if (after.length && !after.some((x) => hits.has(x.k))) resyncFails++; | |
| } | |
| // EVERY SCENARIO, not only the ones whose target names resync: a wide-window | |
| // jump may only land where the pianist actually is. The Study phase measured | |
| // the search on the real Haydn audio at the shipped 1.5-nat bar — 97 % of | |
| // fires landed exactly, 100 % within one event, 0 % landed AHEAD of the | |
| // player — and on the reference Twinkle every fire was a distance-1 jump the | |
| // ordinary rule would have made anyway. +-1 event is therefore the band the | |
| // mechanism is CLAIMED to hold, so anything outside it is a jump the engine | |
| // should not have made, whatever it does to recall. This is the resync's | |
| // counterpart to `early` and it fails every scenario the same way. | |
| // | |
| // `trueK` is the last event that had BEGUN when the scan fired — including | |
| // wrong and skipped ones, because the pianist's hands are past them either | |
| // way. A scenario in which nothing has been played yet (no-play) leaves it | |
| // null and any accepted jump at all is a failure. | |
| // How far the wide search's top-1 was from where the pianist actually was, on | |
| // EVERY armed scan — fired or refused. This is the calibration number behind | |
| // `resyncMarginNats`: a suite in which the refused scans were right is a | |
| // suite whose bar is too high, and one in which the fired scans were wrong is | |
| // a precision bug. Reported alongside the refusal histogram. | |
| const scanAtTrue = (t) => { let k = null; for (const e of events) if (e.kind !== 'silent' && e.T <= t) k = e.k; return k; }; | |
| const scanErrs = [], scanErrsFired = []; | |
| for (const sc of res.scans || []) { | |
| const k = scanAtTrue(sc.audioMs / 1000); | |
| if (k === null || sc.toIndex < 0) continue; | |
| scanErrs.push(sc.toIndex - k); | |
| if (!sc.refused) scanErrsFired.push(sc.toIndex - k); | |
| } | |
| const resyncBad = []; | |
| for (const r of res.resyncs || []) { | |
| if (!r.accepted) continue; | |
| const t = r.audioMs / 1000; | |
| let trueK = null; | |
| for (const e of events) if (e.kind !== 'silent' && e.T <= t) trueK = e.k; | |
| const err = trueK === null ? null : r.toIndex - trueK; | |
| if (err === null || err > 0 || err < -RESYNC_LAND_EVENTS) resyncBad.push({ to: r.toIndex, at: Math.round(r.audioMs), trueK, err }); | |
| } | |
| // DRIFT — the metric the Haydn failure was measured in (Study phase): how many | |
| // events the pianist is ahead of the engine's committed position, sampled at | |
| // every played onset. An engine tracking perfectly reads 1, because event k's | |
| // commit lands DURING event k and at k's onset the engine still holds k-1; the | |
| // real Haydn session read 8 at t=3.6 s, 57 at t=41 s and 98 at t=82 s and | |
| // never came back. `driftRunSec` is the longest unbroken stretch of time spent | |
| // above DRIFT_OK, i.e. how long the accompaniment is left playing music from | |
| // somewhere else — the quantity the user heard as "completely disorganized". | |
| // Resyncs count towards the committed position exactly as advances do: it is | |
| // the accompaniment's position that matters, not how it got there. | |
| const moves = [...res.advances, ...(res.resyncs || [])].filter((a) => a.accepted) | |
| .map((a) => ({ t: a.audioMs / 1000, to: a.toIndex })).sort((a, b) => a.t - b.t); | |
| // A session that starts at a later event (startAt) has the tracker SEEKED | |
| // there rather than advanced there, so the seek is not in `moves` and the | |
| // prefix it skipped is not drift — start-late read 8 before this line. | |
| let driftMax = 0, driftRunSec = 0, driftFrom = null, mi = 0, committedIdx = (perf.startAt || 0) - 1; | |
| for (const e of played) { | |
| while (mi < moves.length && moves[mi].t <= e.T) committedIdx = Math.max(committedIdx, moves[mi++].to); | |
| const d = e.k - committedIdx; | |
| driftMax = Math.max(driftMax, d); | |
| if (d > DRIFT_OK) { if (driftFrom === null) driftFrom = e.T; driftRunSec = Math.max(driftRunSec, e.T + e.durSec - driftFrom); } | |
| else driftFrom = null; | |
| } | |
| // pWrong while a note the score does not contain is sounding — substituted | |
| // (wrongEvery) or inserted (wrongInsert) alike. | |
| const pWrongs = []; | |
| const wrongWins = [ | |
| ...events.filter((e) => e.kind === 'wrong').map((e) => [e.T * 1000 + 100, e.T * 1000 + 0.9 * e.ioi * 1000]), | |
| ...(perf.intruders || []).map((e) => [e.T * 1000 + 100, (e.T + 0.9 * e.durSec) * 1000]), | |
| ]; | |
| for (const [a, b] of wrongWins) for (const o of res.outputs) if (o.informative && o.audioMs >= a && o.audioMs <= b) pWrongs.push(o.pWrong); | |
| // Longest unbroken run of SOUND in which the WRONG absorber owned the | |
| // posterior. This is the quantity the engine's wrongDwellMs watchdog counts, | |
| // so it is the only way to tell from the outside whether a scenario reaches | |
| // it: in 20260915-081347 the longest legitimate run was 854 ms and the | |
| // failure was 49 523 ms, and a scenario that never passes wrongDwellMs is not | |
| // testing recovery however high its median pWrong looks. | |
| let pWrongRunMs = 0, runMs = 0, runPrev = null; | |
| for (const o of res.outputs) { | |
| if (!o.informative) continue; | |
| if (o.pWrong >= 0.5) { runMs += runPrev === null ? 0 : o.audioMs - runPrev; pWrongRunMs = Math.max(pWrongRunMs, runMs); } else runMs = 0; | |
| runPrev = o.audioMs; | |
| } | |
| // Longest stall: the longest stretch in which the pianist is playing notes the | |
| // engine is supposed to be following and NO advance is accepted. | |
| // | |
| // The old form — the largest gap between consecutive hits — could not see the | |
| // failure this metric exists for. It only measured intervals that ENDED in a | |
| // hit, so the real session (20260915-081347: 28 keys and zero advances over | |
| // the last 45 s, the engine dead and never recovering) would have scored its | |
| // stall from the last hit it ever made and reported nothing. Here the | |
| // timeline is split at accepted advances and each segment is measured from | |
| // the first played onset still waiting to the end of the last one, or to the | |
| // advance that ended the wait — so a segment that never ends is the whole | |
| // remaining piece, which is what a dead engine deserves. | |
| // | |
| // Wrong and skipped events are not counted as waiting: holding through a note | |
| // the score does not contain is correct behaviour, not a stall. What that | |
| // leaves in a wrong-note scenario is exactly the recovery time — the gap from | |
| // the first CORRECT note after the run to the advance that re-locks on it. | |
| const advT = res.advances.filter((a) => a.accepted).map((a) => a.audioMs / 1000).sort((a, b) => a - b); | |
| let stall = 0, segFrom = -Infinity; | |
| for (const bound of [...advT, Infinity]) { | |
| const waiting = played.filter((e) => e.T > segFrom && e.T < bound); | |
| if (waiting.length) { | |
| const last = waiting[waiting.length - 1]; | |
| stall = Math.max(stall, Math.min(bound, last.T + last.durSec) - waiting[0].T); | |
| } | |
| segFrom = bound; | |
| } | |
| const holdsByReason = {}; | |
| for (const h of res.holds) holdsByReason[h.reason] = (holdsByReason[h.reason] || 0) + 1; | |
| return { | |
| played: played.length, hits: hits.size, recall: played.length ? hits.size / played.length : 1, | |
| false: falses.length, | |
| // `lateMs` is how far past the named event's own onset the commit landed. | |
| // On a dense score most of the `false` list is not a mis-indexed commit at | |
| // all but the RIGHT event claimed after the 400 ms hit window had closed — | |
| // the same failure `drift` measures, seen from the other end. Printed so | |
| // the two can be told apart without re-running. | |
| falseList: falses.map((a) => ({ to: a.toIndex, at: Math.round(a.audioMs), lateMs: events[a.toIndex] ? Math.round(a.audioMs - events[a.toIndex].T * 1000) : null, kind: events[a.toIndex]?.kind, repeatLike: a.repeatLike, ev: +a.ev.toFixed(2), p: +a.p.toFixed(2) })), | |
| missed: missed.length, missedList: missed.map((e) => e.k), | |
| early: early.length, earlyList: early.map((a) => ({ to: a.toIndex, at: Math.round(a.audioMs), aheadMs: Math.round(events[a.toIndex].T * 1000 - a.audioMs), mode: a.mode })), | |
| latencyMedian: quantile(latencies, 0.5), latencyP90: quantile(latencies, 0.9), | |
| onsetErrMedian: quantile(onsetErrs, 0.5), onsetErrP90: quantile(onsetErrs, 0.9), | |
| tempoRmse: tempoErrs.length ? Math.sqrt(tempoErrs.reduce((s, v) => s + v * v, 0) / tempoErrs.length) : null, | |
| rejects: res.tracker.rejects, stall, pWrongMedian: quantile(pWrongs, 0.5), pWrongRunMs, resyncFails, holdsByReason, | |
| resyncs: (res.resyncs || []).filter((r) => r.accepted).length, resyncBad: resyncBad.length, resyncBadList: resyncBad, driftMax, driftRunSec, | |
| scans: (res.scans || []).length, scansByReason: (res.scans || []).reduce((a, x) => (a[x.refused || 'fired'] = (a[x.refused || 'fired'] || 0) + 1, a), {}), | |
| scanMarginMed: quantile((res.scans || []).map((x) => x.marginNats).filter((v) => v !== null && Number.isFinite(v)), 0.5), | |
| scanMarginP90: quantile((res.scans || []).map((x) => x.marginNats).filter((v) => v !== null && Number.isFinite(v)), 0.9), | |
| scanLeadMed: quantile((res.scans || []).map((x) => x.leadNats).filter((v) => v !== null && Number.isFinite(v)), 0.5), | |
| scanDistMed: quantile((res.scans || []).map((x) => x.distance), 0.5), | |
| scanErrMed: quantile(scanErrs, 0.5), scanErrAbs1: scanErrs.length ? scanErrs.filter((e) => Math.abs(e) <= 1).length / scanErrs.length : null, | |
| scanErrAbs2: scanErrs.length ? scanErrs.filter((e) => Math.abs(e) <= 2).length / scanErrs.length : null, | |
| // "did a jump that ACTUALLY FIRED pick a place the pianist had not | |
| // reached?" — over the fired scans only, and at e > 0, not e > 1. Over all | |
| // scans and at e > 1 it printed `ahead 0` for the dense-drift seed 1 run | |
| // whose accepted jump to event 62 preceded that event's onset by 161 ms, | |
| // i.e. it read 0 on exactly the run it exists to catch. | |
| scanErrAhead: scanErrsFired.filter((e) => e > 0).length, scanErrFiredList: scanErrsFired, | |
| bleedLagMedian: quantile(res.bleeds.map((b) => b.lagMs), 0.5), states: res.states.map((s) => `${s.mode}@${Math.round(s.tMs)}`), | |
| }; | |
| } | |
| // --------------------------------------------------------------------------- | |
| // Scenarios and targets (§8.4) | |
| // --------------------------------------------------------------------------- | |
| // `synth: 'rig'` is the measured laptop-speaker/laptop-mic model (see RIG); | |
| // `'legacy'` is the pre-2026-09-15 8-partial h^-1.3 tone, kept for audit only. | |
| const BASE = { bleed: 1.0, snr: 30, hpf: 0, jitter: 25, rubato: 8, bleedLag: 58, bleedClip: 0, tempoScale: 1.0, score: null, synth: 'rig' }; | |
| // 2026-09-15 RE-BASELINE against the measured rig synth (see RIG above). | |
| // Nothing in the engine changed and no target below was touched: the synth | |
| // stopped being a fundamental-dominant 8-partial piano and became the | |
| // 21-partial comb this laptop speaker actually produces, so every number moved. | |
| // `--synth legacy` reproduces the "before" column below exactly, press for | |
| // press (the legacy path draws the same random numbers in the same order), so | |
| // any line here can be re-checked in one command. | |
| // | |
| // BEFORE (legacy synth) RIG SYNTH, engine .13 RIG SYNTH, engine .14 | |
| // clean 0.96 f0 e0 lat 68/90 ok 0.98 f0 e0 lat 75/152 ok 0.98 f0 e0 ok | |
| // bleed 1.00 f0 e0 stall 0.14 ok 0.87 f0 e0 stall 3.90 FAIL 0.98 f0 e0 ok | |
| // bleed-loud 0.98 f0 e0 ok 0.00 f21 e0 stall 5.84 FAIL 0.91 f0 e0 ok | |
| // noisy 0.98 f0 e0 ok 0.89 f0 e0 ok 0.98 f0 e0 ok | |
| // no-fundamental 1.00 f0 e0 ok 0.93 f0 e0 ok 0.93 f0 e0 ok | |
| // double-strike 0.98 f0 e0 ok 0.96 f0 e0 ok 0.96 f0 e0 ok | |
| // wrong-note 1.00 f0 e0 ok 1.00 f0 e0 ok 1.00 f0 e0 ok (bench bug fixed, see below) | |
| // skipped-note 1.00 f0 e0 ok 0.95 f1 e0 FAIL 0.92 f2 e0 FAIL | |
| // repeated-notes 1.00 f0 e0 ok 0.92 f0 e0 ok 0.92 f0 e0 ok | |
| // no-play – f0 e0 ok – f0 e0 ok – f0 e0 ok | |
| // fast 0.93 f0 e0 ok 0.91 f1 e0 ok 0.96 f0 e0 ok | |
| // rubato-heavy 1.00 f0 e0 ok 0.96 f0 e0 ok 0.96 f0 e0 ok | |
| // bleed-lag-sweep 0.98 f0 e0 ok 0.91 f1 e1 FAIL 0.91 f1 e1 FAIL | |
| // sr44 0.91 f0 e0 ok 0.89 f0 e0 FAIL 0.91 f0 e0 ok | |
| // start-late 0.97 f0 e0 stall 1.12 ok 0.87 f0 e0 stall 5.99 FAIL 0.93 f0 e0 ok | |
| // low-note-weak 0.93 f0 e0 ok 0.86 f1 e0 FAIL 0.89 f0 e0 ok | |
| // low-note-lag-over 0.89 f0 e0 ok 0.89 f0 e0 ok 0.89 f0 e0 ok | |
| // wrong-lock-recovery 0.98 f0 e0 ok 0.98 f0 e0 ok 0.98 f0 e0 ok | |
| // (seed 1 throughout; f = false, e = early. No target was changed in either | |
| // step. Seed 2 under engine .14: everything ok except double-strike 0.91 f1 | |
| // and start-late 0.95 f1, both of which read f1 under engine .13 as well.) | |
| // | |
| // ENGINE .16 IS BEHAVIOUR-IDENTICAL TO .15 on this bench, line for line — it | |
| // only adds FOLLOWER_DEFAULTS.rigResponse, which ships null. Re-measured after | |
| // that change, so the seed-2 column above has current numbers next to it: | |
| // bleed-loud seed 1 0.91 f0 ok seed 2 0.83 f1 FAIL (recall < 0.85 too) | |
| // double-strike seed 1 0.96 f0 ok seed 2 0.93 f1 FAIL | |
| // skipped-note seed 1 0.92 f2 FAIL seed 2 1.00 f0 ok | |
| // All five of those `false`s are LATE commits of notes the player really did | |
| // play — +414, +483, +994 and +2017 ms against the scorer's +400 ms window | |
| // (scoreRun) — and `early` is 0 in every one of them. None of them is the | |
| // accompaniment moving ahead of the pianist; they are the follower catching up | |
| // out of a stall, and two of the four are within 20 % of the bar. The two | |
| // cold-start ones (skipped-note #0, bleed-loud #1 after #0 is lost) are the | |
| // index-0 collapsed-fundamental story already named above, still unsolved. | |
| // | |
| // THE ENGINE STEP (follower 2026-09-15.14) is two changes, both of which this | |
| // bench is what found: | |
| // * the ACCOMPANIMENT's template now runs to the top of the bank | |
| // (FOLLOWER_DEFAULTS upperWeight, _extWeights). Its six-partial truncation | |
| // was the same bug as the solo one and it bites harder, because the | |
| // accompaniment is an octave above the solo and therefore covers the solo | |
| // note's EVEN partials: what identifies a C3 under a C4 is C3's odd | |
| // partials, and from the 7th up neither template could describe them. In | |
| // bleed-loud seed 1 the bleed explained 0.91-0.97 of every frame with | |
| // index 0's own share at 0.00 and the piece never locked. | |
| // * the future guard (§ 'nothing committed ahead of the newest evidence') | |
| // now measures from the onset the last ACCEPTED commit asserted, not from | |
| // whichever hypothesis at the committed index is heaviest. The pre-start | |
| // state spawns a rival for the committed event on the NEXT note's onset; | |
| // with the rig synth it regularly outweighed the committed state, so the | |
| // guard read "event j is a whole IOI away" and refused the child that | |
| // onset belonged to (bleed seed 1: index 1 at p 0.98, ev 6, held | |
| // 'future' with ahead 984 / span 1000 for a second; indices 1-4 lost). | |
| // The rule is unchanged and `early` is still 0 everywhere it was. | |
| // | |
| // WHAT THE ENGINE STEP DID NOT FIX, stated plainly: the SOLO template is | |
| // still truncated at six partials, so the G2 stall the replay was built to | |
| // measure is still there — the replay reads the same 28 hits it did before | |
| // (at a better latency: p90 339 -> 336 ms, index 0 committed +178 ms instead | |
| // of +371 ms). Every way of extending the solo side was measured and every | |
| // one costs more than it buys; the numbers are in FOLLOWER_DEFAULTS above | |
| // `harmonicWeights`, and 2026-09-15.15 adds three more measured dead ends | |
| // there as off-by-default knobs (soloUpperFrom, xTilt, wrongPartialMax) so the | |
| // seventh attempt is a one-line sweep rather than a rebuild. One of them is | |
| // not quite a dead end and is worth knowing about: `--opt wrongPartialMax=6` | |
| // bars WRONG from the 6th partial of an expected pitch and DOES commit the | |
| // index-12 G2 that no shipped build has committed — it just cannot be scored | |
| // on this recording, for the reason under the `--replay` line below. | |
| // skipped-note and bleed-lag-sweep were the two scenarios | |
| // still red. bleed-lag-sweep is now GREEN (0.91 f1 e1 -> 0.93 f0 e0): its | |
| // `early` turned out NOT to be the collapsed fundamental but one onset | |
| // claiming two events, and two hold-only gates fixed it — see the scenario's | |
| // own comment. skipped-note is still red at f2 (index 43 as well as index 0), | |
| // the bleed tail's cost, declared rather than hidden; index 0 is the | |
| // still-unsolved first-note-in-LISTENING collapsed fundamental. Measured, the | |
| // tail is worth its one false: `--opt upperWeight=0` takes skipped-note to | |
| // 0.95 f1 but bleed-loud seed 1 to 0.00 with 21 false, so removing it from | |
| // the commit path is a net loss and was not taken. | |
| // | |
| // The `--replay` line on the real session: replay bypasses the SYNTH, not the | |
| // ENGINE — it re-runs the recorded frames through the live follower, so hits | |
| // and latency can and did move with the .14 step (see p90 339 -> 336 above). | |
| // What is untouched is what the contract asks for, `hits 28` and `false 0`: | |
| // keys 56 hits 28 recall 0.50 false 0 latency med 188 p90 336 ms. | |
| // | |
| // READ THE SECOND LINE BEFORE THE FIRST. 2026-09-15.15 makes `--replay` print | |
| // the CEILING of its own metric, and on this session it is 30 of 56 keys (35 | |
| // under the ±12 rule the scorer actually uses). "recall 0.50" was never 0.50 | |
| // of what is achievable: 24 of the 28 unscored keys are G2 presses made where | |
| // the score asks for C3 or B2, and no follower may advance on those. The | |
| // headroom this recording can demonstrate is two keys. Five solo-template | |
| // rewrites were reverted on differences of five and eleven hits inside that | |
| // band — see replayCeiling for what those differences actually are. | |
| // | |
| // WHAT MOVED, and why. Attributed by rebuilding each scenario with ONE part of | |
| // the new synth switched off: | |
| // | |
| // * The UPPER TAIL is what costs recall. Capping partials at 784 Hz (the old | |
| // h8 of a G2) and changing nothing else restores bleed 0.87 → 0.98 and | |
| // bleed-loud 0.00 → 0.91. That is the shipped 6-partial template failing to | |
| // explain rows 74–96 and the WRONG absorber taking them — the exact | |
| // real-session pathology, which no scenario could reproduce before because | |
| // no synthetic note had anything up there. These are NOT regressions of the | |
| // engine; they are the bench finally containing the failure it was built to | |
| // measure, and the engine genuinely cannot do it yet. | |
| // * The FUNDAMENTAL DRAW costs the first note. bleed-lag-sweep's `early 1` | |
| // needs BOTH the tail and the draw: with either switched off it goes back to | |
| // 0. It is index 0's C3 arriving with a collapsed fundamental in LISTENING | |
| // mode, read as index 1's G3 (C3's h3/h6/h9 are G3's h2/h4/h6) and committed | |
| // 585 ms early. Same story for skipped-note (index 0 committed 1.0 s late, | |
| // scored false) and for bleed-loud on seed 1, where index 0 is lost and the | |
| // whole piece then runs ~6 s late; seeds 2 and 3 of bleed-loud give 0.98 and | |
| // 0.91. A press that loses its fundamental is measured, not invented | |
| // (MIDI 43: p25 −18.8 dB re the strongest partial over 16 presses), and no | |
| // scenario produced one before. | |
| // * start-late and sr44 lose their margin, not their behaviour: start-late | |
| // stalls 5.99 s across indices 11–18 (against a 5 s bound) and sr44 misses | |
| // five instead of four. Both are the same thin-margin story. | |
| // * wrong-note's collapse was a BENCH BUG, and it is fixed above rather than | |
| // re-baselined: `wrongEvery` perturbed a pitch by +1/+2 with no guard, so at | |
| // index 9 it played index 10's own written C3. The fundamental-dominant | |
| // synth could not tell B2 from C3 and nothing happened; the measured comb | |
| // can, and the engine's correct recognition scored as 1 early and 12 false | |
| // advances (recall 1.00 → 0.22). With the guard the scenario reads 1.00 f0 | |
| // e0 under BOTH synths. `wrongInsert` has always had that guard. | |
| // | |
| // NOT re-baselined, and worth saying plainly: the bench is still 25–45 dB | |
| // cleaner than the rig in the only domain the engine sees. Per-row note-to-floor | |
| // on a synthetic G2 is 40–63 dB against the rig's measured 3–18 dB, so the | |
| // whitening's (sal/2·floor − 1)^0.5 barely bites and the simulated G2's | |
| // WHITENED peak is still its own h3 (row 62) where the rig's is row 89. The RAW | |
| // (post − pre) spectrum now matches the rig to 5.9 dB rmse over h ≥ 2 — the | |
| // same order as the profile's own model rmse of 5.12 dB — and peaks on row 62 | |
| // exactly as the rig does, which is what makes a 7..21-partial template | |
| // testable here at all. Lowering --snr does not fix the whitened domain | |
| // (measured at 10, −5 and −17 dB: it flattens the whole spectrum toward the | |
| // noise instead of reshaping it). The cause is that this bench has real silence | |
| // between notes and a dry room, so its min-statistics floor falls back to the | |
| // pink noise in every gap, while the rig's floor rides on a continuously | |
| // sounding speaker: the rig's own session-mean salience is only 3.4 dB above | |
| // its floor at row 43 and 10.3 dB at row 89. That is a FOURTH bench error, one | |
| // the phase-1 profile's "keep pink at the current SNR" did not catch, and it is | |
| // the next thing to fix here. | |
| const SCENARIOS = { | |
| 'clean': { mut: { bleed: 0, snr: 40, rubato: 0 }, tgt: { recall: 0.95, false: 0, latMed: 120, latP90: 250 } }, | |
| // 2026-09-15: 1.00 → 0.87 under the rig synth, FAILING its 0.90 — capping | |
| // the synth's partials at 784 Hz restored 0.98, so the loss was the engine's | |
| // 6-partial template against the measured tail. Engine work, and it was | |
| // done: follower 2026-09-15.14 reads 0.98 f0 e0 (seed 2: 0.20 f14 → 0.98). | |
| // The target is untouched. | |
| 'bleed': { mut: {}, tgt: { recall: 0.90, false: 0, latMed: 150 } }, | |
| // 2026-09-15: 0.98 → 0.00 with 21 false on seed 1 under the rig synth, where | |
| // index 0's C3 draws a collapsed fundamental, is never committed, and the | |
| // piece runs ~6 s late from there. Seeds 2 and 3 read 0.98 and 0.91; capping | |
| // partials at 784 Hz gave 0.91 on seed 1. Tail + first-note collapse | |
| // together — and this scenario is what identified the ACCOMPANIMENT's | |
| // truncated template as the larger half of the tail problem (the bleed | |
| // explained 0.91-0.97 of every frame while index 0's own share was 0.00). | |
| // follower 2026-09-15.14 reads 0.91 f0 e0. The target is untouched. | |
| 'bleed-loud': { mut: { bleed: 2.0 }, tgt: { recall: 0.85, false: 0 } }, | |
| // ------------------------------------------------------------------------- | |
| // phone-bleed / phone-bleed-lag-wrong — THE MOBILE CASE (added 2026-09-16). | |
| // BOTH ARE RED TODAY, ON PURPOSE. They are the acceptance test for the | |
| // mobile bleed work, not a picture of something that already passes. | |
| // | |
| // WHY THEY EXIST. Every bleed scenario above models a LAPTOP: the | |
| // accompaniment leaves a laptop speaker, crosses a room, and arrives at a | |
| // laptop mic 58–130 ms later at a level BELOW the solo. On a phone or tablet | |
| // the speaker and the microphone are inches apart in one body, so the | |
| // accompaniment arrives LOUDER than the soloist and almost immediately, and | |
| // partly through the case rather than only through the air. The product | |
| // direction is webapp first, phone second, and nothing here measured that. | |
| // | |
| // EVERY NUMBER, AND WHERE IT COMES FROM. | |
| // | |
| // bleed 3.0 -> MEASURED SER −6.4 dB (SIM_DEBUG_MIX=1, over the 94 % of hops | |
| // in which both sources sound). The field's mixing parameter is the | |
| // signal-to-echo ratio over DOUBLE-TALK frames, and the ICASSP 2021/2022 | |
| // AEC Challenges sample it "uniformly ... from -10 dB to 10 dB" over | |
| // 10 000+ real devices (Cutler et al., arXiv:2009.04972, arXiv:2202.13290). | |
| // −6.4 dB is inside that range and on its adverse half, which is where the | |
| // 2022 challenge puts mobile: it reports mobile scoring 0.75 MOS BELOW | |
| // desktop in the double-talk degradation category — its largest gap of any | |
| // category — "because in mobile devices, the loudspeaker is closer to the | |
| // microphone, so the signal-to-echo ratio in these devices is lower on | |
| // average". For calibration the existing scenarios measure SER +3.7 dB | |
| // (`bleed`) and −2.3 dB (`bleed-loud`); +3.7 dB matches the rig's own | |
| // "median −5.0 dB re the solo note it covers" to within 1.3 dB, which is | |
| // what validates the metric. phone-bleed is therefore 10.1 dB louder than | |
| // `bleed` and 4.1 dB louder than `bleed-loud`. | |
| // | |
| // bleedLag 6 ms -> the direct + structure-borne path, NOT a room path. A | |
| // phone's speaker-to-mic spacing is 1–15 cm = 0.03–0.44 ms of air, and the | |
| // case-borne path is faster still; what is left is the platform's own | |
| // output buffer, which the traces bound at meta.latency.measuredOutputMs | |
| // 18.3–33.3 ms. 6 ms is the coupling alone (the app's fire report already | |
| // buffer-compensated); the buffer-inclusive case is covered by the 30 ms | |
| // row of the ladder below. Do NOT confuse this with the challenge's "RT60 | |
| // ranges from 200 ms to 1200 ms" — that is the reverb TAIL, a different | |
| // quantity from the direct-path delay the scalar `bleedLagMs` models. | |
| // | |
| // bleedClip 2 -> MEASURED distortion residual −19.4 dB re the linear | |
| // accompaniment (10.7 % RMS): "mild", and applied to the accompaniment | |
| // only, since the solo reaches the mic from a real piano and never passes | |
| // through our loudspeaker. Small loudspeakers are strongly nonlinear | |
| // (Hofmann et al., EURASIP JASP 2016:113) and the AEC Challenge applies a | |
| // nonlinearity to 80 % of its far-end signals, naming "clipping the maximum | |
| // amplitude, using a sigmoidal function ... or applying learned distortion | |
| // functions"; the sigmoid is the one used here. --bleed-clip 3 and 5 give | |
| // −15.1 and −10.9 dB. The shaping is RMS-preserving, so `bleed` and | |
| // `bleedClip` are orthogonal (SER moves 1.0 dB from clip 0 to clip 5). | |
| // | |
| // WHAT THE SHIPPED ENGINE ACTUALLY DOES, MEASURED (engine 2026-09-16.10). | |
| // | |
| // 1. THE NONLINEARITY IS FREE. At a level the engine survives (bleed 1.0, | |
| // lag 6, engine seeded 6) clip 0 / 2 / 5 all read 0.98 (45/46) f0 e0 — | |
| // identical hits, only p90 latency moves (128/115/107 ms). That is the | |
| // predicted result and not a lucky one: a memoryless nonlinearity driven | |
| // by a harmonic tone produces mostly that tone's OWN harmonics, and the | |
| // bleed template is already a harmonic comb on those rows. What a comb | |
| // cannot cover is intermodulation between two simultaneous accompaniment | |
| // pitches, which this scenario does contain and which is evidently small. | |
| // Nonlinear-AEC work is therefore NOT where the mobile effort should go. | |
| // | |
| // 2. THE LEVEL IS THE KILLER, AND IT IS A CLIFF, NOT A SLOPE. Level ladder | |
| // at the room lag 58 with the engine seeded truthfully, seed 1: | |
| // bleed 2.00 SER −2.3 dB recall 0.91 (42/46) f0 e0 | |
| // bleed 2.05 SER −2.5 dB recall 0.00 ( 0/46) f10 stall 9.80s | |
| // bleed 2.25 SER −3.3 dB recall 0.00 ( 0/46) f18 stall 7.29s | |
| // bleed 3.00 SER −5.8 dB recall 0.00 ( 0/46) f11 stall 12.08s | |
| // ONE DECIBEL between 0.91 and 0.00. Seed 2 puts the cliff further out | |
| // (bleed 2.25 -> 1.00 f0; bleed 3.00 -> 0.89 f1), so the cliff's position | |
| // is the first-note draw and its existence is not. Read the seed-1 0.00 | |
| // correctly: `early` is 0 in EVERY cell, so the engine never advances | |
| // ahead of the pianist. Index 0 is lost, the piece then runs 5.7–13.0 s | |
| // late, and the bench scores those late commits as `false`. This is the | |
| // cold-start cascade the `bleed`/`wrong-note` comments above already | |
| // describe, now reachable 10 dB earlier. | |
| // | |
| // 3. THE SHORT DELAY IS GENUINELY HARDER THAN THE ROOM DELAY AT THE SAME | |
| // LEVEL. Phone mix, seed 2, engine seeded 58, estimator live: | |
| // true lag 110 ms (room) recall 1.00 (46/46) f0 estimate 131 ms | |
| // true lag 30 ms recall 0.87 (40/46) f0 estimate 46 ms | |
| // true lag 6 ms (phone) recall 0.85 (39/46) f1 estimate 25 ms | |
| // Same SER, 0.15 recall and the first false bought purely by collapsing | |
| // the loop delay. Two reasons, both structural: the estimate can never | |
| // reach 6 ms because follower.js:4880 folds samples in as | |
| // clamp(sample, 20, 250) — 20 ms is a FLOOR, and 25 ms is where the EMA | |
| // settles from any seed — and at a 6 ms loop the accompaniment's onset and | |
| // the soloist's onset land in the SAME frame, so the | |
| // bleedOnsetWindowMs [−30, 90] suppression around atMs + 25 ms covers | |
| // −5…+115 ms after the fire, which is exactly where the soloist's own | |
| // attack lives when both are on the beat. | |
| // | |
| // 4. ON A PHONE THE LAG SEED STOPS MATTERING, AND THAT IS NOT GOOD NEWS. | |
| // phone-bleed with opt bleedLagMs seeded 6 / 58 / 106 (a 0, +52 and | |
| // +100 ms error) reads 0.00 f16 on seed 1 and 0.85 f1 on seed 2 in ALL | |
| // THREE cases, latency 93 vs 94 ms — because the bleed is now loud enough | |
| // that _calibrateBleed's 2× band test trips on nearly every fire and the | |
| // 0.3 EMA reaches 25 ms within a few events whatever it started from. | |
| // Freezing the estimator outright (--opt bleedMinBand=1e9) confirms it: | |
| // 0.85 / 0.83 / 0.85 across the same 100 ms swing. | |
| // | |
| // 5. THE ESTIMATOR IS BLIND AT LAPTOP LEVEL — the trace pathology, reproduced | |
| // on the bench for the first time. bleed 1.0, clip 2, engine seeded 58: | |
| // true lag 6 ms -> estimate 25 ms true lag 58 ms -> estimate 36 ms | |
| // true lag 15 ms -> estimate 35 ms true lag 110 ms -> estimate 37 ms | |
| // true lag 30 ms -> estimate 36 ms | |
| // A 104 ms range of truths maps to a 12 ms range of estimates. The 2× | |
| // band-energy test at follower.js:4878 is a Geigel detector with no | |
| // reference correlation, so at this level it trips on the SOLOIST's own | |
| // energy, not on the echo's arrival — which is the near-end sample cluster | |
| // under 20 ms that holds 7–65 % of samples per session in the real traces, | |
| // and the reason the recorded assumptions read 58 vs a measured 112, 132 | |
| // vs 236, 236 vs 99. | |
| // | |
| // 6. AND THE BLINDNESS ONLY COSTS SOMETHING WHEN THE BLEED SITS ON THE | |
| // SOLO'S OWN ROWS. Over a 100 ms swing in a FROZEN assumed lag, Twinkle | |
| // moves by at most one event (0.93 -> 0.96 at true lag 110; 0.98 flat at | |
| // true lag 6) with false 0 everywhere — because Twinkle's accompaniment is | |
| // written an octave above its solo (see the score comment above) and the | |
| // two barely share rows. On the `lownote` score, where the accompaniment | |
| // strikes the very partials the solo's fundamentals are missing, the same | |
| // swing is the difference between working and not. See | |
| // phone-bleed-lag-wrong. | |
| // | |
| // phone-bleed gives the engine the TRUE lag (opt bleedLagMs 6) BY DESIGN: it | |
| // isolates the shipped bleed MODEL from the shipped bleed ESTIMATOR, so | |
| // "how far does the model get when the delay is right" can be told apart from | |
| // "what the delay estimator costs". The estimator's cost is item 6's job. | |
| // MEASURED: seed 1 recall 0.00 (0/46) f16 e0 stall 6.64s, missing all 46, | |
| // six LOST states, drift 15 events / 44.9 s, estimate 25 ms; | |
| // seed 2 recall 0.85 (39/46) f1 e0 stall 3.05s, missing | |
| // [0,1,2,3,4,5,12] — the first six events and then a recovery. | |
| // The target is the GOAL, taken from `bleed-loud`'s 0.85 because that is the | |
| // nearest scenario in kind and there is no reason a phone should be allowed | |
| // to be worse than a loud laptop. false 0 is not negotiable on any scenario. | |
| 'phone-bleed': { mut: { bleed: 3.0, bleedLag: 6, bleedClip: 2, opt: { bleedLagMs: 6 } }, tgt: { recall: 0.85, false: 0 } }, | |
| // phone-bleed-lag-wrong — THE DELAY, ISOLATED, WHERE IT ACTUALLY BITES. | |
| // The `lownote` score (whose accompaniment strikes the solo's own partial | |
| // rows) under the phone mix, with the estimator FROZEN at a wrong value. | |
| // | |
| // WHY FROZEN. With the estimator live this cannot be tested at all: item 4 | |
| // above measures 0.85 / 0.85 / 0.85 across seeds of 6, 58 and 106 ms, because | |
| // the estimator overwrites the seed within a few fires. Freezing is done from | |
| // the outside with `bleedMinBand: 1e9` — follower.js:4878 accepts a sample | |
| // only when `e >= 2 * a.ref && e >= o.bleedMinBand`, so an unreachable | |
| // bleedMinBand admits none and `_bleedLagMs` stays at the seed. No engine | |
| // change, and `bleedLag med` prints `-` to prove no sample was folded in. | |
| // This is the same fault injection `low-note-lag-over` already does with | |
| // bleedLagMs 130, taken one step further so the injection actually holds. | |
| // | |
| // WHY IT IS A LEGITIMATE FAULT AND NOT A STRAW MAN: item 5 shows the shipped | |
| // estimator reading 25–37 ms for every true lag from 6 to 110 ms at laptop | |
| // level, i.e. a frozen-wrong lag is what a blind estimator PRODUCES. The | |
| // traces agree — assumed 236 ms against a measured median of 99, assumed 132 | |
| // against 236 — and the report prints 78–100 ms misses routinely. | |
| // | |
| // MEASURED, seed 1, phone mix (bleed 3.0 / lag 6 / clip 2) on `lownote`: | |
| // reference: low-note-weak as it ships recall 0.89 (25/28) f0 e0 stall 1.18s | |
| // frozen lag 6 ms (correct) recall 0.61 (17/28) f0 e0 stall 4.71s | |
| // frozen lag 58 ms (+52, shipped seed) recall 0.61 (17/28) f0 e0 stall 4.72s | |
| // frozen lag 106 ms (+100) recall 0.00 ( 0/28) f6 e0 stall 9.16s | |
| // estimator LIVE from either seed recall 0.61 (17/28) f0 e0, estimate 25 ms | |
| // So the phone MIX alone costs 0.89 -> 0.61, a +52 ms lag error costs | |
| // nothing further, and a +100 ms error costs everything that is left — the | |
| // template is switched on 100 ms after the energy it is supposed to explain | |
| // has already been attributed to the expected note. `early` stays 0 in every | |
| // cell: the six falses at +100 ms are late commits, not advances ahead of | |
| // the pianist. The sweep's worst point is the +100 ms one, which is what the | |
| // scenario reports. | |
| // The stall bound is the one from low-note-weak (4 s) for the same reason it | |
| // is there: a low note the engine cannot identify costs one advance, a low | |
| // note that takes the wrong absorber with it costs the rest of the piece. | |
| 'phone-bleed-lag-wrong': { sweep: [ | |
| { score: 'lownote', speakerHpf: 180, speakerOrder: 4, jitter: 30, bleed: 3.0, bleedLag: 6, bleedClip: 2, opt: { bleedLagMs: 58, bleedMinBand: 1e9 } }, | |
| { score: 'lownote', speakerHpf: 180, speakerOrder: 4, jitter: 30, bleed: 3.0, bleedLag: 6, bleedClip: 2, opt: { bleedLagMs: 106, bleedMinBand: 1e9 } }, | |
| ], tgt: { recall: 0.85, false: 0, stall: 4 } }, | |
| 'noisy': { mut: { snr: 10 }, tgt: { recall: 0.85, false: 0 } }, | |
| 'no-fundamental': { mut: { hpf: 180 }, tgt: { recall: 0.90, false: 0, latMed: 180 } }, | |
| 'double-strike': { mut: { doubleStrike: true }, tgt: { recall: 0.90, false: 0 } }, | |
| 'wrong-note': { mut: { wrongEvery: 5 }, tgt: { recall: 0.90, false: 0, pWrong: 0.5 } }, | |
| // 2026-09-15: 1.00 f0 → 0.95 f1 under the rig synth. The one false is index | |
| // 0 committed at 2.05 s against a 1.0 s onset — the first note again, not | |
| // the skips (every deliberately skipped event is still correctly withheld). | |
| // STILL RED at follower 2026-09-15.14, and one commit worse: 0.92 f2, index | |
| // 43 joining index 0. Both are LATE commits landing after the next onset | |
| // (`early` 0); the extra one is the price of the accompaniment tail, and it | |
| // is declared rather than papered over. Seed 2 reads 1.00 f0 e0. The | |
| // unsolved case is the first note in LISTENING with a collapsed | |
| // fundamental; widening the fundamental/overtone split to every pitch the | |
| // rig loses (< 180 Hz, RIG.fundamentalSpreadBelowHz) was tried and fixes | |
| // bleed-lag-sweep's `early` but takes bleed-loud back to 0.00, because the | |
| // same freedom lets index 0's template fit the loud octave bleed. | |
| // Dropping the accompaniment tail out of the commit path was measured too | |
| // and is the same trade: `--opt upperWeight=0` gives 0.95 f1 here (index 43 | |
| // clears, index 0 does not) and 0.00 f21 on bleed-loud seed 1. So index 43 | |
| // is the tail's price and it is worth paying; index 0 is the open case, and | |
| // it is NOT the f0/overtone split — at 48 kHz semitoneBins(48) = 0.332, so | |
| // a C3 is above f0UnresolvedBins 0.3 and never takes the lowSplit path. | |
| 'skipped-note': { mut: { skipEvery: 6 }, tgt: { recall: 0.90, false: 0, resync: true } }, | |
| 'repeated-notes': { mut: { score: 'repeated' }, tgt: { recall: 0.85, false: 1, latP90: 300 } }, | |
| 'no-play': { mut: { noPlay: true }, tgt: { false: 0 } }, | |
| 'fast': { mut: { tempoScale: 1.8 }, tgt: { recall: 0.85, false: 1 } }, | |
| 'rubato-heavy': { mut: { jitter: 60, rubato: 20 }, tgt: { recall: 0.85, false: 1 } }, | |
| // 2026-09-15: 0.98 f0 e0 → 0.91 f1 e1. The early is index 0's C3 read as | |
| // index 1's G3 585 ms ahead in LISTENING (C3's h3/h6/h9 ARE G3's h2/h4/h6); | |
| // it needs both the tail and the collapsed fundamental — switch either off | |
| // and early goes back to 0. | |
| // Was STILL RED at follower 2026-09-15.14 (0.91 f1 e1 at bleedLag 120; the | |
| // other two lags are clean, and seed 2 is clean at all three) — the one | |
| // place in the suite where `early` was not 0. | |
| // NOW GREEN, 0.93 f0 e0, and NOT by a target change: the early was not the | |
| // collapsed fundamental after all. Index 1 was committed at t 1387 with | |
| // aheadMs 649 in LISTENING while index 0's OWN child, born on the same | |
| // 1044 ms onset (the C3's), was still live and audible — one onset claiming | |
| // two events, which gate 12 (`future`) cannot catch in LISTENING because | |
| // _spanMs is Infinity for a pre-start anchor. Two spawn/commit gates were | |
| // added for it, both hold-only: the `same-onset` commit reason (a skip may | |
| // not share its onset with the event it skips) and an onset-driven child's | |
| // own 60 ms spawn refractory from birth (an index-0 child born at t 1050 | |
| // fathered an index-1 child 48 ms later off the same attack, against | |
| // ioiMinMs 150). 0.91 f1 e1 -> 0.93 f0 e0 here; bleed-loud, the counterweight | |
| // named above, is unchanged at 0.91 f0 e0. | |
| 'bleed-lag-sweep': { sweep: [20, 58, 120].map((lag) => ({ bleedLag: lag })), tgt: { recall: 0.85, false: 0 } }, | |
| // 2026-09-15: 0.91 → 0.89 under the rig synth, five misses instead of four — | |
| // margin, not behaviour (seed 2 was the sharp one: 0.02 with 14 false). | |
| // follower 2026-09-15.14 reads 0.91 f0 e0 on seed 1 and 0.98 on seed 2. | |
| 'sr44': { mut: { sr: 44100 }, tgt: { recall: 0.90, false: 0, latMed: 150 } }, | |
| // Start at a later beat; the first note follows the seek by 0.2–0.4 × IOI. | |
| // 2026-09-15: 0.97 → 0.87 under the rig synth, with a 5.99 s stall over | |
| // indices 11–18 (bound 5 s). follower 2026-09-15.14 reads 0.93 f0 e0 stall | |
| // 1.15 s on seed 1; seed 2 keeps the f1 it had under .13. | |
| 'start-late': { sweep: [{ startAt: 1, startLead: 0.2 }, { startAt: 1, startLead: 0.4 }, { startAt: 6, startLead: 0.3 }], tgt: { recall: 0.90, false: 0, latMed: 150 } }, | |
| // The two scenarios below reproduce .accompy_traces/20260915-081347, in which | |
| // the engine advanced 12 times in 16.7 s and then stalled dead at index 12 | |
| // (G2) while the pianist played 28 more notes over 45 s — precision 100 %, | |
| // recall 29 %. Neither failure mode had a scenario before. | |
| // | |
| // low-note-weak: the lowest solo notes through a laptop speaker (−21 dB on | |
| // G2's fundamental) with the accompaniment striking the very pitches its | |
| // partials land on. The stall bound is the point: a G2 the engine cannot | |
| // identify costs one advance, and that is what `recall` is for — a G2 that | |
| // takes the WRONG absorber with it costs the rest of the piece. | |
| // | |
| // 2026-09-15: under the rig synth this is now explicitly the `speaker-dead-low` | |
| // variant. R(f) already takes 13.6 dB off 98 Hz, so speakerHpf 180 / order 4 | |
| // adds another 21.2 on top — a laptop deader at the bottom than the one that | |
| // was measured, which is exactly the case this scenario is for, but it is no | |
| // longer a picture of THIS rig. Re-baselined 0.93 f0 → 0.86 f1; the one false | |
| // was index 12 (G2) committed 1.2 s late, and 0/8/12/27 were missed. | |
| // follower 2026-09-15.14 reads 0.89 f0 e0 (seed 2: 0.96 f0 e0). | |
| 'low-note-weak': { mut: { score: 'lownote', speakerHpf: 180, speakerOrder: 4, jitter: 30 }, tgt: { recall: 0.85, false: 0, stall: 4 } }, | |
| // low-note-lag-over: the same rig with the engine's ASSUMED speaker→mic loop | |
| // 72 ms LONGER than the real one (130 ms against BASE's 58). That is the | |
| // sign the app gets wrong in practice — 20260915-081347 started from | |
| // measuredOutputMs + 25 = 58 ms against a measured median of 112 ms, and | |
| // 20260915-081347's own fundamental-starved trim believed 145.7 ms against | |
| // 101 ms — and it opens a window in which accompaniment energy is already in | |
| // the mic while _envA still reports zero. Nothing covered it: on | |
| // low-note-weak even --opt bleedLagMs=250 stays green, because the trim read | |
| // _bleedLive, which by construction is empty for exactly those frames. | |
| // Measured at 130 ms over seeds 1-6: worst-seed recall 0.93 reading | |
| // _bleedLive against 0.89 reading _maskAcc — the four extra misses are G2s | |
| // the engine now declines to claim on rows a D4/G4 bleed owns, and false | |
| // stays 0, which is the trade this scenario exists to hold in place. | |
| 'low-note-lag-over': { mut: { score: 'lownote', speakerHpf: 180, speakerOrder: 4, jitter: 30, opt: { bleedLagMs: 130 } }, tgt: { recall: 0.85, false: 0, stall: 4 } }, | |
| // wrong-lock-recovery: eight notes in a row that are in the score nowhere — | |
| // long enough for the absorber to saturate, since the longest LEGITIMATE run | |
| // of pWrong ≥ 0.5 in the real session was 854 ms and the failure was | |
| // 49 523 ms — and then the pianist resumes the written part on the very event | |
| // the engine was waiting for. Three targets, each pulling a different way: | |
| // `pWrong` says the absorber must really take the mass (otherwise the | |
| // scenario is not testing recovery at all), `pWrongRun` says it must then | |
| // give it back — measured 7.0 s of sound with the wrongDwellMs watchdog | |
| // disabled against 2.5 s with it, so this is the target that holds that | |
| // watchdog in place — and `stall` measures the re-lock itself, because the | |
| // intruders are excluded from it. | |
| // | |
| // The intruders are inserted at index 12 rather than at index 8, and that is | |
| // a statement about what is knowable, not a choice of an easy spot. Twinkle | |
| // writes G2 at index 8 and again at index 12, four beats apart. Insert eight | |
| // beats in front of index 8 and the pianist's next G2 is BOTH the note the | |
| // engine is waiting for and exactly where its tempo clock now points (index | |
| // 12) — pitch and clock agree on the wrong answer, and no evidence in the | |
| // audio separates "the pianist played eight unwritten beats" from "the engine | |
| // missed indices 8–11". Measured: 18 advances up to 8.7 s ahead of the | |
| // pianist. At index 12 the eight-beat skip lands on index 20 (C3), the pitch | |
| // gate refuses it, and the question reduces to the one being asked. | |
| 'wrong-lock-recovery': { mut: { wrongInsert: [12, 8] }, tgt: { recall: 0.80, false: 0, pWrong: 0.5, pWrongRun: 4.0, stall: 4 } }, | |
| // dense-drift: the failure of | |
| // .accompy_traces/20260916-113517_cello-concerto-no1-in-c-major-hobviib1-joseph-ha | |
| // (143 solo notes over 120 beats, recall 7 %, the accompaniment 40 s adrift) | |
| // reproduced synthetically. 200 events of that excerpt's OWN score at its own | |
| // spacing — median 250 ms, fastest decile 125 ms, 66 of 199 gaps under | |
| // 0.25 beat — with the long tutti rests clamped out, so the pianist never | |
| // stops and the engine never gets a free re-lock. See DENSE_RH for the | |
| // provenance of every number and for the one deliberate departure (register). | |
| // | |
| // WHAT IT REPRODUCES. The drift is monotone and it is the density that | |
| // produces it, not the noise: `snr` is BASE's 30 dB and the solo is in | |
| // Twinkle's own register. Measured on the shipped engine (2026-09-16.9), | |
| // `--trace /dev/null`, one seed per command: | |
| // seed 1 recall 0.39 (78/200) false 14 early 0 drift 47 / 31.7 s stall 11.2 s | |
| // seed 2 recall 0.55 (109/200) false 9 early 0 drift 25 / 6.2 s stall 7.9 s | |
| // against Twinkle's 0.93-0.98 on the same synth. THE SCENARIO IS RED AND IS | |
| // DECLARED RED (see TARGETS below); these numbers are what it does, not what | |
| // it has to do. Latency where the engine IS tracking is 76 ms median / 155 ms | |
| // p90 — under the 125 ms fastest decile at the median, i.e. the engine CAN | |
| // claim a 125 ms note — and it dies in the 125 ms passages: seed 1 loses | |
| // events 14-88 outright and again 92-117, seed 2 the runs at #168 on. Nothing | |
| // else in the suite contains a 125 ms passage; both Twinkles' shortest IOI is | |
| // 985 ms. | |
| // | |
| // WHERE THE `false` COUNT COMES FROM, measured rather than assumed: every one | |
| // of the 14 (seed 1) and 9 (seed 2) is the RIGHT event committed late — 410 ms | |
| // to 24.2 s late, see `lateMs` in the false list. Zero are mis-indexed, zero | |
| // land on an unplayed event, and `early` is 0 on both seeds. On this scenario | |
| // `false` is `drift` seen from the other end, and the precision that matters | |
| // is intact. | |
| // | |
| // THE RESYNC IS CORRECT HERE AND IT IS NOT ENOUGH. 8 armed wide scans per | |
| // seed, 3 fired and 5 refused `ambiguous` on both; `resyncBad` is 0 on both, | |
| // i.e. no jump landed on an event the pianist had not begun. The `ahead 1` in | |
| // the scans line is the ALIGNMENT's own winner, not the landing: the search | |
| // picks one event past the pianist (`top-1 err med 1`, `|err|<=1 1.00`) and | |
| // `resyncLandBack` is what turns that into a landing one event short. Read | |
| // the two together — `ahead` says what the search chose, `resyncBad` says | |
| // where the accompaniment went. | |
| // | |
| // But a jump needs `resyncContext` 16 onsets plus two LOST episodes to arm, | |
| // which is ~2-4 s of music, while a 16-note 125 ms run puts the engine 16 | |
| // events behind in 2 s. The mechanism closes a gap it cannot prevent. | |
| // | |
| // WHAT WAS MEASURED AND NOT SHIPPED, so it is not re-tried blind: | |
| // - Loosening the dense-passage accumulation gate (`denseMinEvNats` 2.5->1.5, | |
| // `denseMinEvNatsSoft` 5->3, `denseMinCommitGapMs` 70->40, all of which | |
| // apply ONLY where the score's rolling 5-event median IOI is under | |
| // 250 ms) makes this scenario WORSE, not better: 0.45 -> 0.20, false | |
| // 16 -> 27, and `early` 0 -> 1. Accumulation speed is not the binding gate | |
| // at 125 ms and buying it costs the one thing that may not be traded. Same | |
| // conclusion the engine owner reached on the Haydn replay, now with a | |
| // bench that can see it. | |
| // - `resyncArmLostEpisodes` 2 -> 1 (arm on the FIRST lost episode rather | |
| // than the second) is the single constant that moves this scenario: | |
| // recall 0.45 -> 0.56, false 16 -> 8, drift 28 -> 23, drift run | |
| // 10.3 -> 7.7 s, with all three fires still exact and none ahead. Both | |
| // reference Twinkle replays stay bit-identical (39/42 and 38/42, false 0, | |
| // resync 0) because `resyncArmOnsets` 8 alone excludes them — they never | |
| // exceed 3 onsets between commits. It is NOT shipped here for one measured | |
| // reason: the Haydn replay's false count goes 3 -> 4 (a third jump fires | |
| // at t 83.0 s, 118 -> 131), and `2` is the value whose justification is | |
| // written into the engine as "the measured populations do not overlap". | |
| // Trading a real-trace precision point for a synthetic recall point on the | |
| // strength of a scenario written the same afternoon is the wrong way round. | |
| // It belongs to whoever owns the engine, with the rig run to check it. | |
| // - Removing the jump prior altogether (`resyncMarginNats` 0, | |
| // `resyncPenaltyNats` 0, `resyncMinNewShare` 0, arm on everything, no rate | |
| // limit) DOES reach the recall target — 0.60 (120/200), drift 28 -> 15, | |
| // false 16 -> 5 — and pays for it exactly where Nakamura's s_j sweep says | |
| // it will: `early` 0 -> 1 and one jump landing two events past the pianist | |
| // (#120 while he was on #118). That is the whole argument for the shipped | |
| // 1.5-nat bar in one command, and it doubles as the self-test that the | |
| // `resyncBad` assertion below actually binds: it is the only configuration | |
| // found that trips it. | |
| // | |
| // TARGETS. These are the brief's, and they are a statement of what the tool | |
| // has to do rather than a record of what it does — this scenario is RED and | |
| // is expected to stay red until the detection side of the resync can arm | |
| // without waiting for two LOST episodes. `skipped-note` carries the same | |
| // kind of declared-red target (see its note). None of them may be lowered. | |
| // - recall 0.60. Justified from this bench's own measurements, not chosen to | |
| // pass: the engine's commit latency in the stretches where it IS tracking | |
| // here is 76 ms median / 155 ms p90, at or below the 125 ms fastest decile | |
| // at the median, so there is no structural reason a dense note cannot be | |
| // claimed; and seed 2 already holds 109/200 (0.55) as shipped and 113/200 | |
| // (0.56) with the one arming change described above. 0.60 is the nearest | |
| // round number above what a single arming change already reaches. | |
| // - drift 4 events and drift run 4 s are the LOAD-BEARING targets, not | |
| // recall. The product point is that the accompaniment is in the right | |
| // place: an engine that misses half the notes but stays within four | |
| // events is doing its job, and one that catches every third note sixty | |
| // events late is what the user heard as "completely disorganized". 4 | |
| // events is ~1 s at this spacing; perfect tracking reads 1 (see DRIFT_OK). | |
| // - false 0 and early 0 are the safety pair and are never relaxed. `early` | |
| // is 0 on both seeds as shipped and must stay there. It has been 1 once: | |
| // before `resyncLandBack`, seed 1 read `early 1` (event 64 committed | |
| // 235 ms BEFORE its onset, 448 ms after a jump that landed on event 62 | |
| // while the pianist's last begun event was 61), and `--opt | |
| // resyncMaxJump=0` took it back to 0 — i.e. the jump was what enabled it. | |
| // That is why the landing is now one event short and why `resyncBad` is | |
| // one-sided; if either is ever loosened, re-run this seed first. | |
| 'dense-drift': { mut: { score: 'dense' }, tgt: { recall: 0.60, false: 0, drift: 4, driftRun: 4.0 } }, | |
| }; | |
| // Every scenario, not only the two that name it: the pianist may never be left | |
| // playing for this long with the engine standing still. 5 s is ~3.5 beats at | |
| // the rig's 60 bpm and 1/9 of the real session's stall. | |
| const STALL_MAX_SEC = 5; | |
| function evaluate(m, tgt) { | |
| const fails = []; | |
| if (tgt.recall !== undefined && m.recall < tgt.recall) fails.push(`recall ${m.recall.toFixed(2)} < ${tgt.recall}`); | |
| if (tgt.false !== undefined && m.false > tgt.false) fails.push(`false ${m.false} > ${tgt.false}`); | |
| // Every scenario: no advance ahead of the pianist, ever (see EARLY_MS). | |
| if (m.early > 0) fails.push(`early ${m.early} > 0`); | |
| if (tgt.latMed !== undefined && (m.latencyMedian === null || m.latencyMedian > tgt.latMed)) fails.push(`lat med ${fmt(m.latencyMedian)} > ${tgt.latMed}`); | |
| if (tgt.latP90 !== undefined && (m.latencyP90 === null || m.latencyP90 > tgt.latP90)) fails.push(`lat p90 ${fmt(m.latencyP90)} > ${tgt.latP90}`); | |
| if (tgt.pWrong !== undefined && (m.pWrongMedian === null || m.pWrongMedian < tgt.pWrong)) fails.push(`pWrong ${fmt(m.pWrongMedian, 2)} < ${tgt.pWrong}`); | |
| if (tgt.resync && m.resyncFails > 0) fails.push(`resync failed ${m.resyncFails}×`); | |
| // Every scenario: no jump the engine should not have made (see resyncBad). | |
| if (m.resyncBad > 0) fails.push(`resync landed wrong ${m.resyncBad}×`); | |
| if (tgt.drift !== undefined && m.driftMax > tgt.drift) fails.push(`drift ${m.driftMax} > ${tgt.drift} events`); | |
| if (tgt.driftRun !== undefined && m.driftRunSec > tgt.driftRun) fails.push(`drift run ${fmt(m.driftRunSec, 1)}s > ${tgt.driftRun}s`); | |
| const stallMax = tgt.stall ?? STALL_MAX_SEC; | |
| if (m.stall > stallMax) fails.push(`stall ${fmt(m.stall, 2)}s > ${stallMax}s`); | |
| if (tgt.pWrongRun !== undefined && m.pWrongRunMs / 1000 > tgt.pWrongRun) fails.push(`pWrong run ${fmt(m.pWrongRunMs / 1000, 1)}s > ${tgt.pWrongRun}s`); | |
| return fails; | |
| } | |
| const fmt = (v, d = 0) => (v === null || v === undefined || Number.isNaN(v) ? '-' : Number(v).toFixed(d)); | |
| function buildCfg(args, mut) { | |
| const cfg = { ...BASE, ...mut, sr: mut.sr ?? args.sr, opt: { ...(mut.opt || {}), ...args.opt }, trackerDebounce: args.trackerDebounce, reverb: args.reverb, dumpSal: args.dumpSal }; | |
| // Explicit CLI flags override the scenario mutation (they are the user's experiment). | |
| if (args.bleed !== undefined) cfg.bleed = args.bleed; | |
| if (args.snr !== undefined) cfg.snr = args.snr; | |
| if (args.hpf !== undefined) cfg.hpf = args.hpf; | |
| if (args.jitter !== undefined) cfg.jitter = args.jitter; | |
| if (args.rubato !== undefined) cfg.rubato = args.rubato; | |
| if (args.bleedLag !== undefined) cfg.bleedLag = args.bleedLag; | |
| if (args.bleedClip !== undefined) cfg.bleedClip = args.bleedClip; | |
| if (args.tempoScale !== undefined) cfg.tempoScale = args.tempoScale; | |
| if (args.synth !== undefined) cfg.synth = args.synth; | |
| return cfg; | |
| } | |
| function runOne(args, scenarioName, mut, seed, hooks) { | |
| const cfg = buildCfg(args, mut); | |
| const score = loadScore({ ...args, score: cfg.score || args.score }); | |
| cfg.bps = args.bpm ? args.bpm / 60 : score.bps; | |
| const rng = makeRng(seed * 7919 + 17); | |
| const perf = synthesise(score, cfg, rng); | |
| const res = runEngine(perf, score, cfg, hooks); | |
| const metrics = scoreRun(res, perf); | |
| return { cfg, score, perf, res, metrics }; | |
| } | |
| // Worst run over seeds: the metric that would fail hardest wins. | |
| function worstOf(runs, tgt) { | |
| let worst = runs[0]; | |
| for (const r of runs) { | |
| const f = evaluate(r.metrics, tgt), fw = evaluate(worst.metrics, tgt); | |
| if (f.length > fw.length) worst = r; | |
| else if (f.length === fw.length && (r.metrics.early > worst.metrics.early || r.metrics.recall < worst.metrics.recall || r.metrics.false > worst.metrics.false || r.metrics.stall > worst.metrics.stall || r.metrics.driftMax > worst.metrics.driftMax)) worst = r; | |
| } | |
| return worst; | |
| } | |
| // Per-event timeline: what the engine did around each true onset. | |
| function printTimeline(run) { | |
| const { perf, res } = run; | |
| const acc = res.advances.filter((a) => a.accepted); | |
| for (const e of perf.events) { | |
| const win = acc.filter((a) => a.toIndex === e.k); | |
| const t0 = e.T * 1000; | |
| const holds = {}; | |
| for (const h of res.holds) if (h.tMs - SIM_TRANSPORT_MS >= t0 - 50 && h.tMs - SIM_TRANSPORT_MS <= t0 + 450 && h.index === e.k) holds[h.reason] = (holds[h.reason] || 0) + 1; | |
| const hit = win.map((a) => `${Math.round(a.audioMs - t0)}ms${a.repeatLike ? ' rep' : ''} p${a.p.toFixed(2)} ev${a.ev.toFixed(1)}`).join('; '); | |
| const pitches = e.pitches.map(pitchName).join('+'); | |
| console.log(` #${String(e.k).padStart(2)} ${pitches.padEnd(6)} beat ${String(e.beat).padStart(3)} T ${(e.T).toFixed(2)}s ${e.kind.padEnd(7)} ${hit ? 'commit +' + hit : 'MISS'} holds ${JSON.stringify(holds)}`); | |
| } | |
| } | |
| // --------------------------------------------------------------------------- | |
| // Debug outputs (§8.5) | |
| // --------------------------------------------------------------------------- | |
| function writeWav(file, mix, sr) { | |
| const n = mix.length, buf = Buffer.alloc(44 + n * 2); | |
| buf.write('RIFF', 0); buf.writeUInt32LE(36 + n * 2, 4); buf.write('WAVE', 8); | |
| buf.write('fmt ', 12); buf.writeUInt32LE(16, 16); buf.writeUInt16LE(1, 20); buf.writeUInt16LE(1, 22); | |
| buf.writeUInt32LE(sr, 24); buf.writeUInt32LE(sr * 2, 28); buf.writeUInt16LE(2, 32); buf.writeUInt16LE(16, 34); | |
| buf.write('data', 36); buf.writeUInt32LE(n * 2, 40); | |
| for (let i = 0; i < n; i++) buf.writeInt16LE(Math.max(-32768, Math.min(32767, Math.round(mix[i] * 32767))), 44 + i * 2); | |
| fs.writeFileSync(file, buf); | |
| } | |
| const r1 = (v) => (v === null || v === undefined ? null : Math.round(v * 10) / 10); | |
| const r2 = (v) => (v === null || v === undefined ? null : Math.round(v * 100) / 100); | |
| const r3 = (v) => (v === null || v === undefined ? null : Math.round(v * 1000) / 1000); | |
| const NOTE_NAMES = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B']; | |
| const pitchName = (m) => (Number.isFinite(m) ? NOTE_NAMES[((m % 12) + 12) % 12] + (Math.floor(m / 12) - 1) : '?'); | |
| // NPTrace-shaped file so scripts/trace_report.py renders sim runs unchanged (§8.5). | |
| function buildTrace(run, args) { | |
| const { cfg, score, perf, res } = run; | |
| const t0 = perf.preRoll * 1000; // trace t = ms from piece start | |
| const events = []; | |
| const log = (t, type, data) => events.push({ t: Math.round((t - t0) * 10) / 10, type, ...data }); | |
| const solo = normaliseEvents(score.rh); | |
| // One key per EVENT with its lead pitch (the rig types one key per event and | |
| // the follower emits one mic.note per event; a key per chord pitch made the | |
| // report's ground truth steal the next event's note as a wrong pitch). | |
| for (const e of perf.events) if (e.kind !== 'skipped' && e.kind !== 'silent') { | |
| const lead = solo[e.k]?.lead ?? e.pitches[e.pitches.length - 1]; | |
| log(e.T * 1000, 'input.key', { midi: lead, name: pitchName(lead), pitches: e.pitches, src: 'sim', index: e.k, kind: e.kind }); | |
| } | |
| // The intruders are keys the pianist really pressed: they belong in the | |
| // ground truth even though no advance should ever name them. | |
| for (const e of perf.intruders || []) log(e.T * 1000, 'input.key', { midi: e.pitches[e.pitches.length - 1], name: pitchName(e.pitches[e.pitches.length - 1]), pitches: e.pitches, src: 'sim', index: null, kind: 'intruder' }); | |
| const hookFires = run.fires || []; | |
| for (const f of hookFires) log(f.audioMs, 'accomp.fire', { pitches: f.pitches, beat: f.beat }); | |
| // atMs on the trace clock (same as the app): --replay passes it straight to accompanimentFired. | |
| for (const f of hookFires) log(f.audioMs, 'follow.accomp', { pitches: f.pitches, beat: f.beat, atMs: Math.round(f.atMs - SIM_TRANSPORT_MS - t0), durMs: Math.round(f.durMs) }); | |
| // The sim's own seek (runEngine), recorded the way app.js:6522 records the | |
| // app's. Without it --replay finds no follow.seek, falls back to seekPos 0 | |
| // and replays a DIFFERENT session: start-late seed 1 reports recall 0.97 live | |
| // but 0.38 (keys 40, hits 15) replayed from its own --out trace; with the | |
| // event it replays back to 0.97 / false 0. | |
| if (res.seekAudioMs !== null && res.seekAudioMs !== undefined) { | |
| log(res.seekAudioMs, 'follow.seek', { position: perf.startAt, atMs: Math.round(res.seekAudioMs - t0) }); | |
| } | |
| let lastBest = null, lastHoldKey = new Map(); | |
| for (const { frame, out } of res.frames) { | |
| const audioMs = out.tMs - SIM_TRANSPORT_MS; | |
| const bestChanged = (out.best?.i ?? null) !== lastBest; lastBest = out.best?.i ?? null; | |
| // Every frame, verbose (quantised `sal` + `pk`), the app's FOLLOWER_TRACE 'frames' | |
| // format: that is what `--replay` consumes, so a sim trace replays into itself. | |
| { | |
| const P = new Map(out.posterior.map((p) => [p.i, p.p])); | |
| log(audioMs, 'follow.frame', { | |
| engine: 'follower', k: out.seq, at: frame.at, mode: out.mode, pos: out.position, best: out.best?.i ?? null, p: r3(out.best?.p), | |
| pcom: r3(P.get(out.committed) || 0), pcur: r3(P.get(out.committed + 1) || 0), pnext: r3(P.get(out.committed + 2) || 0), pw: r3(out.pWrong), | |
| ev: r2(out.advance?.ev ?? out.hold?.ev ?? null), db: r1(frame.db), on: r2(out.onset.ratio), peak: frame.peak, inf: out.informative, | |
| sal: Array.from(salience.quantiseSal(frame.sal)), pk: r1(10 * Math.log10(Math.max(...frame.sal) + 1e-20)), | |
| g: frame.gated ? 1 : 0, a: frame.attack ? 1 : 0, fl: r1(frame.floorDb), | |
| ur: out.maskRows || 0, gr: r2(out.bleedRef || 0), | |
| }); | |
| } | |
| if (out.state) log(audioMs, 'follow.state', { engine: 'follower', mode: out.state.mode, reason: out.state.reason, pos: out.position, p: r3(out.best?.p) }); | |
| if (out.recovered) log(audioMs, 'follow.recover', { engine: 'follower', mode: out.recovered.mode, reason: out.recovered.reason, pos: out.position, pw: r3(out.pWrong) }); | |
| if (out.bleed) log(audioMs, 'follow.bleed', { engine: 'follower', pitches: out.bleed.pitches, atMs: Math.round(out.bleed.atMs), seenMs: Math.round(out.bleed.seenMs), lagMs: Math.round(out.bleed.lagMs), strength: r2(out.bleed.strength) }); | |
| // THE WIDE JUMP, in its own event types, beside the advance and never | |
| // inside it (see trace_report.py's follow.resync renderer: an advance is | |
| // "the player played this note", a resync is "the player is not here at | |
| // all", and precision may only ever be computed from the first). Without | |
| // these two arms a --out trace showed the tracker teleporting with nothing | |
| // to explain it: `--scenario dense-drift --seed 1 --out <path>` wrote a | |
| // type histogram of follow.advance 84 / tracker 84 and ZERO follow.resync | |
| // for a run that accepted three jumps (13->62, 91->111, 119->144). | |
| // Field names follow app.js traceFollowerResync / the resyncScan log, so | |
| // one report renders a sim trace and a session trace the same way. | |
| if (out.resyncScan) { | |
| const sc = out.resyncScan; | |
| log(audioMs, 'follow.resyncScan', { | |
| engine: 'follower', fromIndex: sc.fromIndex, toIndex: sc.toIndex, distance: sc.distance, refused: sc.refused ?? null, | |
| contextOnsets: sc.contextOnsets, contextMs: sc.contextMs, windowSize: sc.windowSize, reach: sc.reach, | |
| marginNats: r2(sc.marginNats), leadNats: r2(sc.leadNats), meanNewShare: r2(sc.meanNewShare), | |
| mode: sc.mode, lostEpisodes: sc.lostEpisodes, onsetsSinceAccept: sc.onsetsSinceAccept, | |
| }); | |
| } | |
| if (out.resync) { | |
| const rs = out.resync, rec = res.resyncs.find((r) => r.id === rs.id); | |
| const accepted = !!rec?.accepted; | |
| log(audioMs, 'follow.resync', { | |
| engine: 'follower', id: rs.id, accepted, reason: accepted ? null : 'tracker refused', | |
| // As in app.js: `fromIndex` is the tracker's convention (the next event | |
| // expected), `engineFrom` the engine's committed one. | |
| fromIndex: rs.fromIndex + 1, toIndex: rs.toIndex, engineFrom: rs.fromIndex, | |
| beat: rs.beat, jump: rs.toIndex - (rs.fromIndex + 1), | |
| onsetsConfirmed: rs.onsetsConfirmed, contextMs: rs.contextMs, | |
| marginNats: r2(rs.marginNats), leadNats: r2(rs.leadNats), meanNewShare: r2(rs.meanNewShare), | |
| windowSize: rs.windowSize, reach: rs.reach, | |
| sinceOnsetEvidenceMs: Math.round(rs.sinceOnsetEvidenceMs), mode: rs.mode, | |
| nInSession: res.resyncs.filter((r) => r.id <= rs.id && r.accepted).length, | |
| expected: rs.pitches, | |
| }); | |
| // The tracker moved, so the tracker event has to say so — `resync: true` | |
| // is what tells the report this row is not an ordinary advance. | |
| const rev = solo[rs.toIndex], expEv = solo[rs.fromIndex + 1] || null; | |
| log(audioMs, 'tracker', { | |
| src: 'follower', resync: true, input: rev.pitches, inputName: rev.pitches.map(pitchName).join(' '), | |
| posBefore: rs.fromIndex + 1, posAfter: accepted ? rs.toIndex + 1 : rs.fromIndex + 1, | |
| expected: expEv ? expEv.pitches : [], expectedName: expEv ? expEv.pitches.map(pitchName).join(' ') : '', expectedBeat: expEv ? expEv.beat : null, | |
| result: accepted ? 'match' : 'reject', beat: accepted ? rs.beat : null, | |
| engine: 'follower', ev: null, sinceOnsetMs: null, lagMs: Math.round(rs.lagMs), bps: r3(rs.bps), mode: out.mode, | |
| }); | |
| } | |
| if (out.advance) { | |
| const adv = out.advance, rec = res.advances.find((a) => a.id === adv.id); | |
| const ev = solo[adv.toIndex], lead = ev.lead; | |
| log(audioMs, 'mic.note', { midi: lead, name: pitchName(lead), engine: 'follower', reason: 'follower', matched: false, clarity: null, freq: null, calibrating: false, | |
| heardMidi: adv.heardMidi, heardName: pitchName(adv.heardMidi), p: r3(adv.p), margin: r3(adv.margin), ev: r2(adv.ev), | |
| sinceOnsetMs: Math.round(adv.sinceOnsetMs), lagMs: Math.round(adv.lagMs), onsetDriven: adv.onsetDriven, repeatLike: adv.repeatLike }); | |
| // Same bag as app.js traceTrackerResult (the report reads `result`, `inputName`, `expectedName`, `posAfter`). | |
| const accepted = !!rec?.accepted, expEv = solo[adv.fromIndex + 1] || null; | |
| log(audioMs, 'tracker', { | |
| src: 'follower', input: ev.pitches, inputName: ev.pitches.map(pitchName).join(' '), | |
| posBefore: adv.fromIndex + 1, posAfter: accepted ? adv.toIndex + 1 : adv.fromIndex + 1, | |
| expected: expEv ? expEv.pitches : [], expectedName: expEv ? expEv.pitches.map(pitchName).join(' ') : '', expectedBeat: expEv ? expEv.beat : null, | |
| result: accepted ? 'match' : 'reject', beat: accepted ? adv.beat : null, | |
| engine: 'follower', p: r3(adv.p), margin: r3(adv.margin), ev: r2(adv.ev), sinceOnsetMs: Math.round(adv.sinceOnsetMs), lagMs: Math.round(adv.lagMs), bps: r3(adv.bps), mode: out.mode, repeatLike: adv.repeatLike, | |
| }); | |
| log(audioMs, 'follow.advance', { engine: 'follower', id: adv.id, fromIndex: adv.fromIndex, toIndex: adv.toIndex, beat: adv.beat, accepted: !!rec?.accepted, p: r3(adv.p), margin: r3(adv.margin), ev: r2(adv.ev), | |
| sinceOnsetMs: Math.round(adv.sinceOnsetMs), onsetAtMs: Math.round(adv.onsetAtMs), lagMs: Math.round(adv.lagMs), bps: r3(adv.bps), | |
| onsetDriven: adv.onsetDriven, repeatLike: adv.repeatLike, onsetScore: adv.onsetScore, heardMidi: adv.heardMidi, | |
| explained: { bleed: r2(adv.explained.bleed), prev: r2(adv.explained.prev), new: r2(adv.explained.new), other: r2(adv.explained.other) }, | |
| hyps: adv.hyps.map((h) => ({ i: h.i, tOn: Math.round(h.tOnMs), bps: r3(h.bps), w: r3(h.w), ev: r2(h.ev) })) }); | |
| } else if (out.hold) { | |
| const key = out.hold.reason + ':' + out.hold.index, last = lastHoldKey.get(key); | |
| if (last === undefined || audioMs - last >= 250) { | |
| lastHoldKey.set(key, audioMs); | |
| const h = out.hold; | |
| log(audioMs, 'follow.hold', { engine: 'follower', reason: h.reason, index: h.index, pos: out.position, p: r3(h.p), margin: r3(h.margin), ev: r2(h.ev), onsetSeen: h.onsetSeen, dwellMs: Math.round(h.dwellMs) }); | |
| if (h.onsetSeen) { | |
| const exp = solo[h.index]; | |
| log(audioMs, 'mic.drop', { engine: 'follower', reason: 'held:' + h.reason, expMidi: exp?.lead ?? null, expName: exp ? pitchName(exp.lead) : null, index: h.index, p: r3(h.p), margin: r3(h.margin), ev: r2(h.ev) }); | |
| } | |
| } | |
| } | |
| } | |
| events.sort((a, b) => a.t - b.t); | |
| const rhDur = normaliseEvents(score.rh).map((e, i, arr) => e.durBeats ?? (i + 1 < arr.length ? arr[i + 1].beat - e.beat : 1)); | |
| return { | |
| version: 1, app: 'notepilot', startedAt: new Date().toISOString(), | |
| meta: { inputMode: 'mic', micEngine: 'follower', followMode: 'leader', score: score.name, initialBps: cfg.bps, rh: score.rh, lh: score.lh, rhDur, | |
| sim: { scenario: run.scenario, seed: run.seed, cfg: { ...cfg, opt: cfg.opt } }, | |
| // No `tag`: that is the app's ?v= cache-buster for /follower.js, and the | |
| // sim imports the module directly, so any value here is a guess that goes | |
| // stale (it was two bumps behind). version is the real identity. | |
| follower: { version: FOLLOWER_VERSION, sr: cfg.sr, win: cfg.opt.win ?? 2048, hop: cfg.opt.hop ?? 512, minMidi: 33, maxMidi: 96, options: res.follower.options } }, | |
| events, | |
| }; | |
| } | |
| // --replay: feed a verbose session's follow.frame events through a fresh engine (§8.5). | |
| function replay(args) { | |
| const tr = JSON.parse(fs.readFileSync(args.replay, 'utf8')); | |
| const meta = tr.meta || {}; | |
| const fmeta = meta.follower || {}; | |
| const sr = fmeta.sr || 48000, win = fmeta.win || 2048, hop = fmeta.hop || 512; | |
| const frames = tr.events.filter((e) => e.type === 'follow.frame' && Array.isArray(e.sal)); | |
| if (!frames.length) { console.error('replay: no verbose follow.frame events (sal) in ' + args.replay); process.exit(2); } | |
| const engineOpts = { ...(fmeta.options || {}), ...args.opt }; delete engineOpts.win; delete engineOpts.hop; | |
| const follower = new ScoreFollower({ solo: meta.rh, accompaniment: meta.lh || [], bps: meta.initialBps || 1, sampleRate: sr, win, hop, position: 0, options: { ...engineOpts, accompFallback: false } }); | |
| const solo = normaliseEvents(meta.rh); | |
| const tracker = new FakeTracker(solo, { bps: meta.initialBps || 1 }); | |
| const keys = tr.events.filter((e) => e.type === 'input.key'); | |
| const accomp = tr.events.filter((e) => e.type === 'follow.accomp'); | |
| let accIdx = 0; | |
| // Auto-skips are part of the session, not noise: skipCurrentNote (app.js:6008) | |
| // moves the tracker AND calls _scoreFollower.seek(state.tracker.position), | |
| // which rebuilds the beam at the new index. A replay that drops them keeps | |
| // arguing for the event the live engine stepped over, so the two engines are | |
| // no longer running the same session. Measured on 20260916-154809 (7 skips, | |
| // all `auto`): without this the replay reads 212 advances / last index 241 / | |
| // 1 spurious resync and diverges at advance #1; with it, 230 / 252 / 0 and | |
| // the first divergence is at advance #153, against the live 237 / 254 / 0. | |
| // `skip.toIndex` IS the `state.tracker.position` app.js passes to seek(). | |
| // reason 'out-of-bank' (app.js:7788) is the one skip path that does NOT seek | |
| // the follower — it only walks the tracker — so it must not seek here either. | |
| const skips = tr.events.filter((e) => e.type === 'skip' && Number.isFinite(e.toIndex)); | |
| let skIdx = 0; | |
| // The app does TWO things between `new ScoreFollower` and the first frame | |
| // (resetScoreFollower: seek() then seedFollowerAccompaniment()), and a replay | |
| // that skips them is not replaying the same engine. Without the seek the | |
| // committed state is unstamped, so it looks like it has been sounding since | |
| // the page loaded; without the seed the notes already ringing when the engine | |
| // started are missing from the bleed model. Measured on 20260915-083040: | |
| // unpatched, index 0 committed at t=191ms — 1141ms before the first key and | |
| // 1523ms before the live engine's own commit — on frames peaking at MIDI 60, | |
| // i.e. the seeded C4; the replay reported recall 0.45 with `false` 2 for a | |
| // session whose recorded precision is 100 %. With both steps it commits at | |
| // t=1628ms (86ms from the live 1714ms) and reports recall 0.46 / false 1 — | |
| // the live figures — and 0.48 / false 0 once `fl` is used as well. | |
| const seekEv = tr.events.find((e) => e.type === 'follow.seek'); | |
| const seedEv = tr.events.find((e) => e.type === 'follow.accomp.seed'); | |
| const t0 = frames[0].t; | |
| const seekPos = seekEv && Number.isFinite(seekEv.position) ? seekEv.position : 0; | |
| follower.seek(seekPos, seekEv && Number.isFinite(seekEv.atMs) ? seekEv.atMs : t0); | |
| tracker.position = seekPos; | |
| // Pre-`follow.accomp.seed` traces (before follower 2026-09-15.10) still carry | |
| // the information: an accomp.fire with no follow.accomp beside it is a note | |
| // that sounded before the engine existed, which is exactly what the seed is. | |
| const seedList = seedEv ? (seedEv.list || []) : (() => { | |
| const firstAcc = accomp.length ? accomp[0].t : Infinity; | |
| const durMs = accomp.length ? quantile(accomp.map((a) => a.durMs).filter(Number.isFinite), 0.5) : 1000 / (meta.initialBps || 1); | |
| // "No follow.accomp beside it", not merely "before the first one": the fire | |
| // and the engine's notification are logged microseconds apart (2422.7 vs | |
| // 2422.9 ms in 20260915-083040), so a plain t < firstAcc test seeds the | |
| // first reported fire a second time and doubles its bleed. | |
| const reported = (e) => accomp.some((a) => Math.abs(a.t - e.t) <= 100 && String(a.pitches) === String(e.pitches)); | |
| return tr.events.filter((e) => e.type === 'accomp.fire' && e.t < firstAcc && !reported(e)) | |
| .map((e) => ({ pitches: e.pitches, atMs: e.t, durMs, beat: e.beat })); | |
| })(); | |
| if (seedList.length) follower.seedAccompaniment(seedList); | |
| const hopMs = hop / sr * 1000; | |
| let Lprev = null; const fluxHist = []; | |
| let floorDb = null; | |
| // The level floor comes from the frame's own `fl` (app.js records it for | |
| // exactly this). Only pre-`fl` traces fall back to recomputing it from the | |
| // logged `db` with the analyzer's own rise rate: floorDb drives | |
| // lambda = clamp((db - floorDb - gateDb) / rangeDb, 0, 1), the weight behind | |
| // `informative`, the onset bar and every evidence term, and on | |
| // 20260915-083040 the reconstruction was off by 0.39 dB mean / 1.78 dB max | |
| // over 5750 frames — up to 15 % of rangeDb = 12. Not cosmetic: on that trace | |
| // it moves the replay from recall 0.46 / false 1 / p90 313 ms to 0.48 / 0 / | |
| // 361 ms. | |
| const floorRise = new FrameAnalyzer(sr, { win, hop }).floorRiseDbPerSec * hop / sr; | |
| const advances = [], resyncs = []; | |
| for (const fe of frames) { | |
| while (skIdx < skips.length && skips[skIdx].t <= fe.t) { | |
| const sk = skips[skIdx++]; | |
| if (sk.reason !== 'out-of-bank') follower.seek(sk.toIndex, sk.t); | |
| tracker.position = sk.toIndex; | |
| } | |
| while (accIdx < accomp.length && accomp[accIdx].t <= fe.t) { const a = accomp[accIdx++]; follower.accompanimentFired({ pitches: a.pitches, atMs: a.atMs, durMs: a.durMs, beat: a.beat }); } | |
| const sal = salience.dequantiseSal(Uint8Array.from(fe.sal), fe.pk ?? 0); // pk = peak salience power in dB | |
| const db = fe.db ?? -60; | |
| floorDb = Number.isFinite(fe.fl) ? fe.fl : (floorDb === null ? db : Math.min(floorDb + floorRise, db)); | |
| let flux = 0; const L = new Float32Array(sal.length); | |
| for (let b = 0; b < sal.length; b++) { L[b] = Math.log(sal[b] + 1e-10); if (Lprev) { const d = L[b] - Lprev[b]; if (d > 0) flux += d; } } | |
| Lprev = L; | |
| let onset = 0; | |
| if (fluxHist.length >= 8) { const s = fluxHist.slice().sort((a, b) => a - b); const med = s.length & 1 ? s[s.length >> 1] : 0.5 * (s[(s.length >> 1) - 1] + s[s.length >> 1]); onset = flux / (med + 1e-6); } | |
| fluxHist.push(flux); if (fluxHist.length > 64) fluxHist.shift(); | |
| // The onset ratio comes from the frame's own `on` (app.js records it, like | |
| // `fl` above, for exactly this); the reconstruction beside it is only for | |
| // traces that predate the field. `on` is the ONLY frame field observe() | |
| // reads besides sal/db/floorDb/gated/attack, and reconstructing it from | |
| // the recorded salience cannot be exact: `sal` is quantised to half-dB | |
| // steps against a 0.1 dB frame peak (quantiseSal), and the ratio is a | |
| // sum of 64 LOG differences over a 64-frame median, so the quantisation | |
| // does not average out. Measured over both sessions the error is tiny — | |
| // mean |d| 0.024, p95 0.06 — and that is exactly why it was not caught: | |
| // only 19 frames of 15604 on 20260915-204851 cross the level-scaled flux | |
| // bar at all (onsetThreshRepeat + (onsetThresh - onsetThreshRepeat)*λ), | |
| // and ONE of them disagrees. That one frame is k10074 at 4919 ms, live | |
| // ratio 3.39 against a bar of 3.375 at λ 0.35, reconstructed 3.31: it is | |
| // the onset evidence that confirms index 0, so without it the replay held | |
| // `no-onset-evidence` through the whole first phrase and committed index 0 | |
| // at 54.9 s instead of the live engine's 4.99 s. The rest of the session | |
| // followed from there: hits 6 either way, but every posterior after the | |
| // first minute belonged to a session the user never played. With `on` the | |
| // replay reproduces the live commits to the frame (i0 4994 vs 4995 ms, | |
| // i1 8994 vs 8996, i2 10178 vs 10179), which is what a replay is for. | |
| if (Number.isFinite(fe.on)) onset = fe.on; | |
| const rms = 10 ** (db / 20); | |
| // `g`/`a` are the worklet's gate and attack flags as recorded (older verbose traces lack them: treated as false). | |
| const frame = { type: 'frame', seq: fe.k, at: fe.at ?? Math.round(fe.t / 1000 * sr), sr, win, hop, rms, db, floorDb, flux, onset, hfc: 0, sal, peak: 33 + sal.indexOf(Math.max(...sal)), noiseFloor: null, gated: !!fe.g, attack: !!fe.a }; | |
| const out = follower.observe(frame, fe.t); | |
| // See the resync block in runEngine: its own emission, its own explicit | |
| // maxJump, never scored as a detection. | |
| if (out.resync) { | |
| const beat = tracker.advanceTo(out.resync.toIndex, { maxJump: out.resync.maxJump, inputPitch: 0 }, fe.t / 1000); | |
| follower.ack(out.resync.id, beat !== null); | |
| if (beat !== null) resyncs.push({ ...out.resync, tMs: out.tMs }); | |
| } | |
| if (out.advance) { | |
| const beat = tracker.advanceTo(out.advance.toIndex, { maxJump: out.advance.maxJump, inputPitch: 0 }, fe.t / 1000); | |
| follower.ack(out.advance.id, beat !== null); | |
| if (beat !== null) advances.push({ ...out.advance, tMs: out.tMs }); | |
| } | |
| } | |
| // Score against typed keys: same hit rule as the sim (−50..+400 ms), match on midi or ±12. | |
| let hits = 0; const used = new Set(); const lat = []; | |
| for (const k of keys) { | |
| const cand = advances.find((a) => !used.has(a.id) && a.tMs >= k.t - 50 && a.tMs <= k.t + 400 && a.pitches.some((p) => p === k.midi || Math.abs(p - k.midi) === 12)); | |
| if (cand) { used.add(cand.id); hits++; lat.push(cand.tMs - k.t); } | |
| } | |
| // GROUND TRUTH WITHOUT A KEYBOARD. `hits`/`falses` above are scored against | |
| // typed keys, and a MICROPHONE session has none: 20260916-154809 carries 0 | |
| // `input.key` events, so the unguarded `advances.length - used.size` read | |
| // `false 212` for a session whose recorded precision is 237 advances with | |
| // ZERO false ones — a phantom precision collapse, and the exact reading this | |
| // file's header warns about. When there are no keys, score the replay against | |
| // what the LIVE engine did instead: the trace's own accepted `follow.advance` | |
| // records. Same index, within ±2 s of the recorded commit, each record used | |
| // once and in order; recall is then "how much of the live session did this | |
| // engine reproduce" and `false` is "advances the live engine never made". | |
| let falses = keys.length ? advances.length - used.size : null; | |
| let recall = keys.length ? hits / keys.length : null; | |
| let truth = 'keys'; | |
| if (!keys.length) { | |
| const live = tr.events.filter((e) => e.type === 'follow.advance' && e.accepted !== false); | |
| if (live.length) { | |
| const usedA = new Set(); | |
| let matched = 0; | |
| for (const rec of live) { | |
| const cand = advances.find((a) => !usedA.has(a.id) && a.toIndex === rec.toIndex && Math.abs(a.tMs - rec.t) <= 2000); | |
| if (cand) { usedA.add(cand.id); matched++; lat.push(cand.tMs - rec.t); } | |
| } | |
| hits = matched; | |
| falses = advances.length - usedA.size; | |
| recall = matched / live.length; | |
| truth = 'follow.advance x' + live.length; | |
| } | |
| } | |
| const ceil = replayCeiling(keys, normaliseEvents(meta.rh)); | |
| // SINGLE NOTES AND CHORDS, SCORED SEPARATELY. A two-note event is a different | |
| // problem from a one-note event — the fit has a voice BALANCE to get right as | |
| // well as a pitch (see chordVoices in follower.js) — and one recall number | |
| // over a score that is 95 % single notes hides it completely: on | |
| // 20260916-154809 the session that reads 95 % overall is 95 % on its 241 | |
| // single notes and 64 % on its 14 chords. "Detected" is "some advance landed | |
| // on that index", over the events up to the furthest one reached, which is | |
| // the same population the engine had a chance at. | |
| const det = new Set(advances.map((a) => a.toIndex)); | |
| const reached = advances.length ? Math.max(...advances.map((a) => a.toIndex)) : -1; | |
| let nS = 0, hS = 0, nC = 0, hC = 0; const missC = []; | |
| for (let i = 0; i <= reached; i++) { | |
| const ps = solo[i] ? solo[i].pitches : []; | |
| if (ps.length > 1) { nC++; if (det.has(i)) hC++; else missC.push(`${i}[${ps.join(',')}]`); } | |
| else if (ps.length === 1) { nS++; if (det.has(i)) hS++; } | |
| } | |
| // PRECISION WITHOUT A KEYBOARD. `false` above counts advances the live engine | |
| // did not make at the same time, and most of those are the SAME event | |
| // committed earlier or later than the live session managed — not a note the | |
| // player never played. The failure that actually matters is the engine | |
| // getting AHEAD of the player, so this reports the worst the replay's | |
| // committed index ever ran over the live session's, that session's own | |
| // precision being the reference (20260916-154809: 237 advances, zero false). | |
| let lead = null; | |
| if (truth !== 'keys') { | |
| const liveAdv = tr.events.filter((e) => e.type === 'follow.advance' && e.accepted !== false).slice().sort((a, b) => a.t - b.t); | |
| let li = 0, lc = -1, ri = 0, rc = -1; | |
| lead = -Infinity; | |
| for (const t of [...new Set(liveAdv.map((a) => a.t).concat(advances.map((a) => a.tMs)))].sort((a, b) => a - b)) { | |
| while (li < liveAdv.length && liveAdv[li].t <= t) lc = liveAdv[li++].toIndex; | |
| while (ri < advances.length && advances[ri].tMs <= t) rc = advances[ri++].toIndex; | |
| if (rc - lc > lead) lead = rc - lc; | |
| } | |
| } | |
| const m = { keys: keys.length, hits, recall, false: falses, truth, advances: advances.length, latencyMedian: quantile(lat, 0.5), latencyP90: quantile(lat, 0.9), ceiling: ceil.exact, ceilingOctave: ceil.octave, resyncs: resyncs.length, | |
| reached, singles: `${hS}/${nS}`, chords: `${hC}/${nC}`, chordRate: nC ? hC / nC : null, leadOverLive: Number.isFinite(lead) ? lead : null }; | |
| if (args.json) console.log(JSON.stringify(m)); | |
| else { | |
| console.log(`replay ${path.basename(args.replay)}: keys ${m.keys} hits ${hits} recall ${fmt(m.recall, 2)} false ${fmt(falses, 0)} adv ${advances.length} latency med ${fmt(m.latencyMedian)} p90 ${fmt(m.latencyP90)} ms resync ${resyncs.length}`); | |
| if (truth !== 'keys') console.log(` no keyboard ground truth in this trace (0 input.key); scored against the session's own ${truth} records, so recall = share of the live commits this engine reproduced`); | |
| console.log(` reached event ${reached} singles ${m.singles} (${fmt(100 * hS / Math.max(1, nS))}%) CHORDS ${m.chords} (${nC ? fmt(100 * hC / nC) : '-'}%)${missC.length ? ' missed: ' + missC.join(' ') : ''}`); | |
| if (m.leadOverLive !== null) console.log(` worst lead over the live engine's committed index: ${m.leadOverLive >= 0 ? '+' : ''}${m.leadOverLive} events`); | |
| for (const r of resyncs) console.log(` resync t ${(r.tMs / 1000).toFixed(1)}s ${r.fromIndex} -> ${r.toIndex} (+${r.distance}) margin ${fmt(r.marginNats, 2)} lead ${fmt(r.leadNats, 2)} new ${fmt(r.meanNewShare, 2)} ctx ${r.contextOnsets}/${r.contextMs}ms ${r.mode}`); | |
| // The ceiling is a statement about TYPED KEYS (see the note below); with no | |
| // keys there is nothing to take a ceiling of, and printing 0/0 reads as a | |
| // failure rather than an absence. | |
| if (keys.length) console.log(` ceiling ${ceil.exact}/${keys.length} keys are reachable in score order (${ceil.octave} under the scorer's own ±12 rule); hits ${hits} = ${fmt(100 * hits / Math.max(1, ceil.octave))}% of it`); | |
| } | |
| } | |
| // THE CEILING, and why the line above exists. `recall` here is hits over TYPED | |
| // KEYS, and a typed key is not a thing a score follower can always answer: it | |
| // may be a note the score does not contain at that point, and the engine is | |
| // RIGHT to refuse it. On 20260915-083040 that is not a detail — 24 of the 28 | |
| // keys the shipped engine "misses" are G2 presses made while the score asks | |
| // for C3 or B2 (the player held G2 down 15.7-21.5 s and again 38.5-53.7 s, | |
| // testing the very note this workflow is about), so they are unreachable by | |
| // anything that does not advance on notes the player did not play. | |
| // | |
| // The bound below is generous on purpose: the longest subsequence of keys that | |
| // can be matched to score events in increasing order, one event per key. It | |
| // ignores timing, ignores the onset gates and lets the engine skip ahead for | |
| // free, so nothing real can beat it. On 20260915-083040 it is 30 of 56 keys | |
| // (35 if octave answers are allowed, which is what the ±12 hit rule does) — | |
| // i.e. "recall 0.50" against a reachable 0.54/0.63, not against 1.00, and the | |
| // headroom this session can show is TWO keys, not twenty-eight. Five template | |
| // rewrites were judged on the difference between 28 and 23; that difference is | |
| // within the alignment noise of a session where the scored hits include a jump | |
| // of five events credited to a G2 because the event landed on was its octave. | |
| function replayCeiling(keys, events) { | |
| const K = keys.map((k) => k.midi), E = events.map((e) => e.pitches); | |
| const lcs = (match) => { | |
| const n = K.length, m = E.length; | |
| let next = new Int32Array(m + 1), cur = new Int32Array(m + 1); | |
| for (let i = n - 1; i >= 0; i--) { | |
| cur = new Int32Array(m + 1); | |
| for (let j = m - 1; j >= 0; j--) { | |
| let best = Math.max(next[j], cur[j + 1]); | |
| if (E[j].some((p) => match(K[i], p))) best = Math.max(best, 1 + next[j + 1]); | |
| cur[j] = best; | |
| } | |
| next = cur; | |
| } | |
| return cur[0]; | |
| }; | |
| return { exact: lcs((k, p) => k === p), octave: lcs((k, p) => k === p || Math.abs(k - p) === 12) }; | |
| } | |
| // --------------------------------------------------------------------------- | |
| // Main | |
| // --------------------------------------------------------------------------- | |
| function main() { | |
| const args = parseArgs(process.argv.slice(2)); | |
| if (args.replay) { replay(args); return; } | |
| const names = args.all ? Object.keys(SCENARIOS) : [args.scenario || 'bleed']; | |
| for (const n of names) if (!SCENARIOS[n]) { console.error('unknown scenario ' + n + '; known: ' + Object.keys(SCENARIOS).join(', ')); process.exit(2); } | |
| const seeds = []; for (let s = 0; s < Math.max(1, args.seeds); s++) seeds.push(args.seed + s); | |
| const summary = {}; | |
| const rows = []; | |
| let anyFail = false; | |
| for (const name of names) { | |
| const sc = SCENARIOS[name]; | |
| const variants = sc.sweep ? sc.sweep : [sc.mut]; | |
| const runs = []; | |
| for (const mut of variants) for (const seed of seeds) { | |
| const fires = []; | |
| // SIM_DEBUG=t0,t1 (seconds of audio) prints one line per frame in that window. | |
| const dbg = process.env.SIM_DEBUG ? process.env.SIM_DEBUG.split(',').map(Number) : null; | |
| const onFrame = dbg ? (frame, out, follower) => { | |
| const t = (out.tMs - SIM_TRANSPORT_MS) / 1000; | |
| if (t < dbg[0] || t > dbg[1]) return; | |
| const post = out.posterior.map((p) => `${p.i}:${p.p.toFixed(2)}`).join(' '); | |
| const ex = out.explained ? `b${out.explained.bleed.toFixed(2)} p${out.explained.prev.toFixed(2)} n${out.explained.new.toFixed(2)} o${out.explained.other.toFixed(2)}` : '-'; | |
| let hj = ''; | |
| if (process.env.SIM_DEBUG_H && (out.hold || out.advance)) { | |
| const idx = out.hold ? out.hold.index : out.advance.toIndex; | |
| const h = follower._hyps.filter((q) => q.i === idx).sort((a, b) => b.logW - a.logW)[0]; | |
| const par = follower._hyps.filter((q) => q.i === follower._committed).sort((a, b) => b.logW - a.logW)[0]; | |
| if (h) hj = ` H[dist${(h.distinct || 0).toFixed(3)} mask${(() => { try { const m = follower._distinctMask(h.i); const rows = []; for (let b = 0; b < m.length; b++) if (m[b]) rows.push(b + 33); return rows.join('/'); } catch (e) { return '?'; } })()} cap${h.pvCap === Infinity ? 'inf' : h.pvCap.toFixed(0)} gPv${h.gPv.toFixed(0)} gNw${h.gNw.toFixed(0)} born${((h.born - SIM_TRANSPORT_MS) / 1000).toFixed(2)} tOn${((h.tOn - SIM_TRANSPORT_MS) / 1000).toFixed(2)} ${h.onsetDriven ? 'on' : 'soft'}]`; | |
| if (h && par && process.env.SIM_DEBUG_ELL) { | |
| let X2 = 0; for (const v of follower._x) X2 += v * v; | |
| const Bs = follower._bleedVectors(out.tMs); | |
| const rh = follower._hypLikelihood(h, follower._x, X2, Bs), rp = follower._hypLikelihood(par, follower._x, X2, Bs); | |
| hj += ` acc[${follower._accomp.map((a) => a.pitches.join('+') + '@' + ((a.atMs - SIM_TRANSPORT_MS) / 1000).toFixed(2) + (follower._envA(a, out.tMs) > 0.05 ? '*' : '')).join(' ')}] nB${Bs.length} gH[${Array.from(rh.gains || []).map((g) => g.toFixed(0)).join(',')}] gP[${Array.from(rp.gains || []).map((g) => g.toFixed(0)).join(',')}]`; | |
| hj += ` ell H${rh.ell.toFixed(2)} P${rp.ell.toFixed(2)} rssH${(rh.rss / X2).toFixed(3)} rssP${(rp.rss / X2).toFixed(3)} exH n${rh.explained.new.toFixed(2)} p${rh.explained.prev.toFixed(2)} logW H${h.logW.toFixed(1)} P${par.logW.toFixed(1)}`; | |
| } | |
| if (process.env.SIM_DEBUG_RES && follower._residual) { | |
| const res = follower._residual, x = follower._x; | |
| let X2 = 0; for (const v of x) X2 += v * v; | |
| const top = Array.from(res).map((v, b) => [v * v / X2, b + 33]).sort((a, b) => b[0] - a[0]).slice(0, 8); | |
| hj += ` RES[${top.map(([e, r]) => r + ':' + (e * 100).toFixed(1) + '%').join(' ')}]`; | |
| const hc = follower._hyps.filter((q) => q.i === follower._committed).sort((a, b) => b.logW - a.logW)[0]; | |
| if (hc && hc.res) hj += ` C[${hc.res.comps.map((c, k) => c.name + '=' + hc.res.gains[k].toFixed(0)).join(' ')} caps f0${hc.nwCapF0 === Infinity ? 'inf' : hc.nwCapF0.toFixed(0)} ov${hc.nwCapOv === Infinity ? 'inf' : hc.nwCapOv.toFixed(0)}]`; | |
| const xt = Array.from(x).map((v, b) => [v * v / X2, b + 33]).sort((a, b) => b[0] - a[0]).slice(0, 8); | |
| hj += ` X[${xt.map(([e, r]) => r + ':' + (e * 100).toFixed(1) + '%').join(' ')}]`; | |
| } | |
| if (h && h.res) { let X2 = 0; for (const v of follower._x) X2 += v * v; hj += ` pitchΔ${follower._pitchCheck(h, follower._x, X2, follower._bleedNow).toFixed(2)}`; } | |
| // The leading alternatives of the pitch gate (q:accumulated nats), so a 'pitch' hold names its rival. | |
| if (h && h.alt && h.alt.size) hj += ` alt[${[...h.alt.entries()].sort((a, b) => b[1].acc - a[1].acc).slice(0, 3).map(([q, v]) => pitchName(q) + ':' + v.acc.toFixed(2) + '/n' + (h.altN - v.n0)).join(' ')} n${h.altN}]`; | |
| hj += ` os${follower._committed + 1 < follower._N ? follower._onsetScore(follower._committed + 1, out.tMs).toFixed(2) : '-'}`; | |
| } | |
| // The committed state's caps on every frame (not only on holds): a cap that | |
| // never armed shows up as 'inf' long before the note it fails to bound. | |
| if (process.env.SIM_DEBUG_H) { | |
| const par = follower._hyps.filter((q) => q.i === follower._committed).sort((a, b) => b.logW - a.logW)[0]; | |
| if (par) hj += ` P[cap${par.pvCap === Infinity ? 'inf' : par.pvCap.toFixed(0)} L${par.pvL.toFixed(0)} gPv${par.gPv.toFixed(0)} gNw${par.gNw.toFixed(0)} capF0${par.nwCapF0 === Infinity ? 'inf' : par.nwCapF0.toFixed(0)} ex n${par.lastExplained ? par.lastExplained.new.toFixed(2) : '-'} p${par.lastExplained ? par.lastExplained.prev.toFixed(2) : '-'} o${par.lastExplained ? par.lastExplained.other.toFixed(2) : '-'}]`; | |
| } | |
| // SIM_DEBUG_BEAM=1: every live hypothesis (index, weight, evidence, birth, parent) per frame. | |
| if (process.env.SIM_DEBUG_BEAM) { | |
| const beam = follower._hyps.slice().sort((a, b) => b.logW - a.logW).map((h) => `${h.i}${h.repeatLike ? 'r' : ''}${h.onsetDriven ? '' : 's'}<${h.from ?? '-'} w${h.logW.toFixed(1)} ev${h.ev.toFixed(1)} n${h.lastExplained ? h.lastExplained.new.toFixed(2) : '-'} b${((h.born - SIM_TRANSPORT_MS) / 1000).toFixed(2)}`); | |
| hj += ` BEAM[${beam.join(' | ')}] W${follower._wrong.logW.toFixed(1)}`; | |
| } | |
| if (process.env.SIM_DEBUG_X) { | |
| const x = follower._x; const b = follower._best(); | |
| const tpl = b && b.i >= 0 && b.i < follower._N ? follower._ev[b.i].template : null; | |
| const row = (v) => Array.from(v).map((q, i) => q > 0.05 ? `${i + 33}:${q.toFixed(2)}` : null).filter(Boolean).join(' '); | |
| console.log(' x ', row(x)); if (tpl) console.log(' Nw ', row(tpl)); if (b && follower._pv[b.i]) console.log(' Pv ', row(follower._pv[b.i])); | |
| } | |
| console.log(`${t.toFixed(3)} ${out.informative ? 'I' : '.'} λ${out.lambda.toFixed(2)} db${frame.db.toFixed(0)} on${out.onset.ratio.toFixed(1)}${out.onset.hit ? '*' : ' '} r${out.onset.rise.toFixed(1)}${out.onset.evidence ? '!' : ' '} pk${frame.peak} best${out.best ? out.best.i : '-'} [${post}] pW${out.pWrong.toFixed(3)} ex ${ex}${out.hold ? ' HOLD ' + out.hold.reason + '@' + out.hold.index + ' p' + out.hold.p.toFixed(2) + ' m' + out.hold.margin.toFixed(2) + ' ev' + out.hold.ev.toFixed(1) + (out.hold.aheadMs !== null ? ' ahead' + Math.round(out.hold.aheadMs) + '/' + Math.round(out.hold.spanMs) + ' bps' + out.hold.bps.toFixed(2) : '') : ''}${out.advance ? ' ADV->' + out.advance.toIndex + ' ev' + out.advance.ev.toFixed(1) + ' new' + out.advance.explained.new.toFixed(2) : ''}${out.state ? ' STATE ' + out.state.mode : ''}${hj}`); | |
| } : null; | |
| const run = runOne(args, name, mut, seed, { onFire: (f) => fires.push(f), onFrame }); | |
| run.fires = fires; run.scenario = name; run.seed = seed; run.mut = mut; | |
| runs.push(run); | |
| } | |
| const worst = worstOf(runs, sc.tgt); | |
| const fails = evaluate(worst.metrics, sc.tgt); | |
| if (fails.length) anyFail = true; | |
| const m = worst.metrics; | |
| summary[name] = { recall: r3(m.recall), false: m.false, early: m.early, missed: m.missed, latencyMedian: r1(m.latencyMedian), latencyP90: r1(m.latencyP90), onsetErrMedian: r1(m.onsetErrMedian), tempoRmse: r3(m.tempoRmse), pass: fails.length === 0, seed: worst.seed, variant: worst.mut }; | |
| rows.push({ name, m, fails, worst }); | |
| if (!args.quiet && !args.json) { | |
| const label = sc.sweep ? `${name} (${Object.entries(worst.mut).map(([k, v]) => k + ' ' + (v && typeof v === 'object' ? JSON.stringify(v) : v)).join(' ')})` : name; | |
| console.log(`${(fails.length ? 'FAIL' : 'ok ')} ${label.padEnd(24)} recall ${fmt(m.recall, 2)} (${m.hits}/${m.played}) false ${m.false} early ${m.early} miss ${m.missed} lat ${fmt(m.latencyMedian)}/${fmt(m.latencyP90)} ms onset ${fmt(m.onsetErrMedian)}/${fmt(m.onsetErrP90)} tempo ${fmt(m.tempoRmse, 3)} rej ${m.rejects} stall ${fmt(m.stall, 2)}s drift ${m.driftMax}/${fmt(m.driftRunSec, 1)}s resync ${m.resyncs}${m.resyncBad ? '!' + m.resyncBad : ''} pW ${fmt(m.pWrongMedian, 2)}/${fmt(m.pWrongRunMs / 1000, 1)}s seed ${worst.seed}${fails.length ? ' <- ' + fails.join('; ') : ''}`); | |
| if (fails.length || process.env.SIM_VERBOSE) { | |
| if (m.falseList.length) console.log(' false:', JSON.stringify(m.falseList)); | |
| if (m.earlyList.length) console.log(' early:', JSON.stringify(m.earlyList)); | |
| if (m.resyncBadList.length) console.log(' resync landed wrong:', JSON.stringify(m.resyncBadList)); | |
| if (m.missedList.length) console.log(' missed:', JSON.stringify(m.missedList)); | |
| console.log(' holds:', JSON.stringify(m.holdsByReason), ' states:', m.states.join(' '), ' bleedLag med', fmt(m.bleedLagMedian)); | |
| // Every armed wide scan and why it did or did not fire — the resync's | |
| // own audit line (follower.js out.resyncScan), so a scenario that | |
| // drifts can be told from one whose search was refused. | |
| console.log(' wide scans:', m.scans, JSON.stringify(m.scansByReason), ' margin med/p90', fmt(m.scanMarginMed, 2), '/', fmt(m.scanMarginP90, 2), ' lead med', fmt(m.scanLeadMed, 2), ' dist med', fmt(m.scanDistMed), | |
| ' top-1 err med', fmt(m.scanErrMed), ' |err|<=1', fmt(m.scanErrAbs1, 2), ' |err|<=2', fmt(m.scanErrAbs2, 2), ' ahead', m.scanErrAhead); | |
| } | |
| } | |
| if (args.timeline) printTimeline(worst); | |
| if (args.wav && names.length === 1) writeWav(args.wav, worst.perf.mix, worst.cfg.sr); | |
| if (args.out && names.length === 1) fs.writeFileSync(args.out, JSON.stringify(buildTrace(worst, args))); | |
| } | |
| if (args.json) console.log(JSON.stringify(summary, null, 1)); | |
| else if (!args.quiet) { | |
| const passed = rows.filter((r) => !r.fails.length).length; | |
| console.log(`${passed}/${rows.length} scenarios pass (seeds ${seeds.join(',')}; engine ${FOLLOWER_VERSION})`); | |
| } | |
| process.exit(anyFail ? 1 : 0); | |
| } | |
| main(); | |