Spaces:
Sleeping
Sleeping
| // The mic scope is a VIEW, so its failure mode is silent: one NaN coordinate | |
| // or a zero-height pitch axis produces a blank canvas and no error. This drives | |
| // the shipped drawing code against a recording 2D context and asserts every | |
| // coordinate it emits is finite and on-canvas, for the edge cases that actually | |
| // occur -- an empty buffer, a buffer of nothing but "no candidate", a single | |
| // repeated pitch, and pitches at the very ends of the keyboard. | |
| import assert from 'node:assert/strict'; | |
| import fs from 'node:fs'; | |
| import vm from 'node:vm'; | |
| const app = fs.readFileSync(new URL('../static/app.js', import.meta.url), 'utf8'); | |
| const source = app.slice(app.indexOf('const SCOPE_MAX_MS'), app.indexOf('function publishBlindPitch')); | |
| assert(source.includes('function _drawMicScope'), 'scope source not found'); | |
| const W = 600, H = 132; | |
| function rig({ expected = [], light = false } = {}) { | |
| const calls = []; | |
| const ctx = new Proxy({}, { | |
| get(_, k) { | |
| if (k === 'canvas') return null; | |
| return (...args) => { calls.push({ op: String(k), args }); }; | |
| }, | |
| set(_, k, v) { calls.push({ op: 'SET:' + String(k), args: [v] }); return true; }, | |
| }); | |
| const canvas = { clientWidth: W, clientHeight: H, width: 0, height: 0, getContext: () => ctx }; | |
| const els = { 'mic-scope': canvas, 'mic-scope-freeze': { classList: { toggle() {} }, textContent: '' } }; | |
| const context = vm.createContext({ | |
| document: { hidden: false, getElementById: (id) => els[id] || null, | |
| body: { classList: { contains: () => light } } }, | |
| window: { devicePixelRatio: 2 }, | |
| performance: { now: () => 0 }, | |
| FOLLOWER_OPTIONS: { win: 2048 }, | |
| FOLLOWER_VERSION_TAG: 'test', | |
| Blob: class { constructor(p) { this.size = String(p[0]).length; } }, | |
| URL: { createObjectURL: () => 'blob:x', revokeObjectURL() {} }, | |
| Date, | |
| state: { tracker: { position: 0, score: [[expected, 0]] } }, | |
| eventPitches: (ev) => ev[0], | |
| }); | |
| vm.runInContext(source + ` | |
| this.push = _scopePush; this.mark = _scopeMarkAdvance; this.draw = _drawMicScope; | |
| this.pushSal = (now, sal, frame) => { | |
| // a session starts in a quiet room: prime the per-row floor once | |
| if (!_scopeNoiseMean) _scopeRemoveRoom(new Float32Array(64).fill(1e-9), now - 1, false); | |
| return _scopePushSal(now, sal, frame); | |
| }; | |
| this.span = setMicScopeSpan; this.freeze = toggleMicScopeFreeze; | |
| this.axis = () => [_scopeLo, _scopeHi]; | |
| this.useTemplates = (t, w) => { _scopeTemplates = t; _scopeTemplateEvidence = w || null; _scopeTemplatesTried = true; }; | |
| this.dump = micScopeData;`, context); | |
| return { calls, ...context }; | |
| } | |
| /** Every numeric argument the drawing code emits must be finite and on-canvas. */ | |
| function assertSane(calls, label) { | |
| let drew = 0; | |
| for (const { op, args } of calls) { | |
| for (const a of args) { | |
| if (typeof a !== 'number') continue; | |
| assert.ok(Number.isFinite(a), `${label}: ${op} got a non-finite argument (${a})`); | |
| } | |
| if (op === 'fillRect' || op === 'clearRect') { | |
| const [x, y, w, h] = args; | |
| assert.ok(w >= 0 && h >= 0, `${label}: ${op} has negative size ${w}x${h}`); | |
| assert.ok(x >= -1 && x <= W + 1, `${label}: ${op} x=${x} is off-canvas`); | |
| assert.ok(y >= -1 && y <= H + 1, `${label}: ${op} y=${y} is off-canvas`); | |
| if (op === 'fillRect') drew++; | |
| } | |
| if (op === 'arc') { | |
| const [cx, cy, r] = args; | |
| assert.ok(r > 0, `${label}: arc radius ${r}`); | |
| assert.ok(cx >= -1 && cx <= W + 1 && cy >= -1 && cy <= H + 1, `${label}: arc off-canvas`); | |
| } | |
| } | |
| return drew; | |
| } | |
| const sample = (t, midiFloat, extra = {}) => ({ t, midiFloat, valid: true, ...extra }); | |
| // ── 1. The degenerate buffers, which are what a blank canvas comes from ─── | |
| { | |
| const r = rig(); | |
| r.draw(0, true); | |
| assertSane(r.calls, 'empty buffer'); | |
| const [lo, hi] = r.axis(); | |
| assert.ok(hi - lo >= 1, `empty buffer collapsed the pitch axis to ${hi - lo} semitones`); | |
| } | |
| { | |
| const r = rig(); | |
| // 200 frames in which the observer had no candidate at all -- the F2 case. | |
| for (let i = 0; i < 200; i++) r.push(i * 10, { midiFloat: null, valid: false }); | |
| r.draw(2000, true); | |
| assertSane(r.calls, 'all-null buffer'); | |
| assert.ok(r.axis()[1] - r.axis()[0] >= 1, 'all-null buffer collapsed the axis'); | |
| } | |
| { | |
| // A single pitch repeated: the axis must not collapse to zero height, which | |
| // would make every y() a division by zero. | |
| const r = rig(); | |
| for (let i = 0; i < 100; i++) r.push(i * 10, { midiFloat: 41, valid: true }); | |
| for (let i = 0; i < 40; i++) r.draw(1000, true); // let the smoothing settle | |
| assertSane(r.calls, 'single pitch'); | |
| const [lo, hi] = r.axis(); | |
| assert.ok(hi - lo >= 17, `single pitch gave only ${(hi - lo).toFixed(1)} semitones of axis`); | |
| assert.ok(lo < 41 && hi > 41, 'the played pitch must be inside the axis'); | |
| } | |
| // ── 2. Keyboard extremes must stay on-canvas ────────────────────────────── | |
| for (const m of [21, 24, 33, 41, 60, 96, 105, 108]) { | |
| const r = rig(); | |
| for (let i = 0; i < 60; i++) r.push(i * 10, { midiFloat: m, valid: true }); | |
| for (let i = 0; i < 40; i++) r.draw(600, true); | |
| assertSane(r.calls, `pitch ${m}`); | |
| const [lo, hi] = r.axis(); | |
| assert.ok(hi - lo >= 1, `pitch ${m} collapsed the axis`); | |
| } | |
| // ── 3. A realistic intermittent low note actually puts marks on screen ──── | |
| // This is the user's F2: resolved on some windows, blank on others. | |
| { | |
| const r = rig({ expected: [41] }); | |
| for (let i = 0; i < 400; i++) { | |
| const heard = i % 7 < 2; // fires on 2 of every 7 windows | |
| r.push(i * 10, heard ? { midiFloat: 41.1, valid: true, method: 'yin-4096-lowband' } | |
| : { midiFloat: null, valid: false }); | |
| } | |
| r.mark(3200, 41); | |
| r.draw(4000, true); | |
| const drew = assertSane(r.calls, 'intermittent F2'); | |
| assert.ok(drew > 50, `expected the heard windows to be drawn, got ${drew} fillRects`); | |
| assert.ok(r.calls.some((c) => c.op === 'arc'), 'the committed advance was not marked'); | |
| assert.ok(r.calls.some((c) => c.op === 'stroke'), 'no gridlines or advance lines drawn'); | |
| } | |
| // ── 4. Freeze holds the window still; Live resumes ──────────────────────── | |
| { | |
| const r = rig(); | |
| for (let i = 0; i < 100; i++) r.push(i * 10, { midiFloat: 60, valid: true }); | |
| r.freeze(); | |
| const before = r.calls.length; | |
| r.draw(50_000, true); // far past every sample | |
| assertSane(r.calls.slice(before), 'frozen'); | |
| r.freeze(); // back to live | |
| r.draw(1000, true); | |
| assertSane(r.calls, 'after unfreeze'); | |
| } | |
| // ── 5. Every offered span works ─────────────────────────────────────────── | |
| { | |
| for (const ms of [4000, 8000, 15000, 30000]) { | |
| const r = rig({ expected: [43, 60] }); | |
| for (let i = 0; i < 600; i++) r.push(i * 50, { midiFloat: 43 + (i % 20), valid: i % 3 !== 0 }); | |
| r.span(String(ms)); | |
| r.draw(30_000, true); | |
| assertSane(r.calls, `span ${ms}`); | |
| } | |
| } | |
| // ── 6. The ring buffer stays bounded ────────────────────────────────────── | |
| { | |
| const r = rig(); | |
| for (let i = 0; i < 20000; i++) r.push(i * 10, { midiFloat: 60, valid: true }); | |
| r.draw(200_000, true); | |
| assertSane(r.calls, 'long session'); | |
| } | |
| // ── 7. Real strikes, through the harmonic projection the scope actually uses ─ | |
| // The heat layer plots a PITCH salience, not the analyser bank: the bank's rows | |
| // are a semitone spectrum, so drawn raw a note's partials are as bright as the | |
| // note (on the chord below the brightest raw row was F4, which nobody played). | |
| { | |
| const sal = await import('file://' + new URL('../static/salience.js', import.meta.url).pathname); | |
| const fb = sal.buildFilterbank(48000, 2048, 33, 96); | |
| const templates = [], evidence = new Float32Array(64); | |
| for (let m = 33; m <= 96; m++) { | |
| templates[m - 33] = sal.harmonicTemplate(fb, m); | |
| evidence[m - 33] = Math.min(1, sal.pitchInBank(fb, m) / 3); | |
| } | |
| const trace = new URL('../.accompy_traces/20260921-184144_twinkle-twinkle-little-star.json', import.meta.url); | |
| const d = JSON.parse(fs.readFileSync(trace, 'utf8')); | |
| const at = (e) => e.sessionTimeMs ?? e.t ?? 0; | |
| const frames = d.events.filter((e) => e.type === 'follow.frame' && e.sal).sort((a, b) => at(a) - at(b)); | |
| /** Peak opacity the heat layer paints per pitch row, for one strike. */ | |
| function heatOf(t0) { | |
| const seg = frames.filter((e) => at(e) >= t0 + 180 && at(e) < t0 + 650); | |
| assert.ok(seg.length > 8, `not enough sustain frames at ${t0}`); | |
| const r = rig(); | |
| r.useTemplates(templates, evidence); | |
| for (const e of seg) { | |
| r.pushSal(at(e) - t0, sal.dequantiseSal(Uint8Array.from(e.sal)), { sampleRate: 48000, rms: 0.05, noiseFloor: 0.001 }); | |
| r.push(at(e) - t0, { midiFloat: null, valid: false }); | |
| } | |
| for (let i = 0; i < 39; i++) r.draw(650, true); | |
| r.calls.length = 0; | |
| r.draw(650, true); // measure one settled frame | |
| const [lo, hi] = r.axis(), HP = H - 4, TOP = 2; | |
| const bright = new Map(); | |
| let fill = null; | |
| for (const { op, args } of r.calls) { | |
| if (op === 'SET:fillStyle') { fill = String(args[0]); continue; } | |
| if (op !== 'fillRect' || args[2] !== 3) continue; | |
| const m = Math.round(lo + (1 - (args[1] - TOP) / HP) * (hi - lo)); | |
| const a = Number((fill.match(/,([\d.]+)\)$/) || [])[1] || 0); | |
| bright.set(m, Math.max(bright.get(m) || 0, a)); | |
| } | |
| assertSane(r.calls, `heat ${t0}`); | |
| return bright; | |
| } | |
| const maxOf = (h) => Math.max(...h.values()); | |
| const ownOf = (h, m) => Math.max(...[m - 1, m, m + 1].map((x) => h.get(x) || 0)); | |
| // A solo note must be as bright as anything on the strip. All 46 solo strikes | |
| // in this recording project as clean local maxima at 0.77-1.00 of the frame | |
| // peak; these four span the register, and include C3 -- the note the chord | |
| // case below loses -- so "C3 is just weak on this rig" is ruled out here. | |
| for (const [t0, midi] of [[3590, 48], [7700, 52], [14800, 43], [16020, 47]]) { | |
| const h = heatOf(t0); | |
| assert.ok(ownOf(h, midi) >= 0.9 * maxOf(h), | |
| `solo MIDI ${midi} painted at ${ownOf(h, midi).toFixed(3)} against a max of ${maxOf(h).toFixed(3)}`); | |
| } | |
| // The chord: two bands, which is what the layer exists for. The upper note is | |
| // full brightness and the lower one about half -- NOT equal, and the test says | |
| // so rather than pretending otherwise. Projecting each template independently | |
| // lets the upper note claim energy the two share, and at win=2048 this | |
| // register resolves to roughly three semitones. Both limits are in CLAUDE.md. | |
| for (const t0 of [21540, 60860]) { | |
| const h = heatOf(t0), mx = maxOf(h); | |
| assert.ok(ownOf(h, 52) >= 0.9 * mx, `chord ${t0}: E3 at ${ownOf(h, 52).toFixed(3)}`); | |
| assert.ok(ownOf(h, 48) >= 0.35 * mx, | |
| `chord ${t0}: C3 at ${ownOf(h, 48).toFixed(3)} is too dim to read as a second bar`); | |
| assert.ok(ownOf(h, 48) < 0.9 * mx, | |
| `chord ${t0}: C3 unexpectedly equals E3 -- if the fit improved, retune this`); | |
| } | |
| } | |
| // ── 7a. Degenerate high templates must not win ─────────────────────────── | |
| // Above MIDI 78 a harmonic template keeps fewer than three of its six partials | |
| // inside the bank, and from 88 up only one -- three non-zero rows. A band that | |
| // narrow correlates with any bright row near it, and the upper partials of the | |
| // notes actually played land there with no other template to claim them. On | |
| // 20260922-083545, A#6 (MIDI 94) came out the brightest row of five separate | |
| // chords played two to three octaves below it. | |
| { | |
| const salm = await import('file://' + new URL('../static/salience.js', import.meta.url).pathname); | |
| const fbx = salm.buildFilterbank(48000, 2048, 33, 96); | |
| const tpl = [], ev = new Float32Array(64); | |
| for (let m = 33; m <= 96; m++) { | |
| tpl[m - 33] = salm.harmonicTemplate(fbx, m); | |
| ev[m - 33] = Math.min(1, salm.pitchInBank(fbx, m) / 3); | |
| } | |
| const trace = new URL('../.accompy_traces/20260922-083545_twinkle-twinkle-little-star.json', import.meta.url); | |
| const d2 = JSON.parse(fs.readFileSync(trace, 'utf8')); | |
| const at2 = (e) => e.sessionTimeMs ?? e.t ?? 0; | |
| const frames2 = d2.events.filter((e) => e.type === 'follow.frame' && e.sal).sort((a, b) => at2(a) - at2(b)); | |
| let spurious = 0; | |
| for (const [t0, played] of [[4050, [50, 53]], [18490, [43, 53]], [19480, [43, 53]], | |
| [23240, [43, 53]], [24470, [43, 53]]]) { | |
| const seg = frames2.filter((e) => at2(e) >= t0 + 180 && at2(e) < t0 + 650); | |
| assert.ok(seg.length > 8, `no sustain frames at ${t0}`); | |
| const r = rig(); | |
| r.useTemplates(tpl, ev); | |
| for (const e of seg) { | |
| r.pushSal(at2(e) - t0, salm.dequantiseSal(Uint8Array.from(e.sal)), | |
| { sampleRate: 48000, rms: e.rms, noiseFloor: e.noiseFloorRms, gated: e.g === true }); | |
| r.push(at2(e) - t0, { midiFloat: null, valid: false }); | |
| } | |
| for (let i = 0; i < 39; i++) r.draw(650, true); | |
| r.calls.length = 0; | |
| r.draw(650, true); | |
| const [lo, hi] = r.axis(), HP = H - 4, TOP = 2; | |
| const bright = new Map(); | |
| let fill = null; | |
| for (const { op, args } of r.calls) { | |
| if (op === 'SET:fillStyle') { fill = String(args[0]); continue; } | |
| if (op !== 'fillRect' || args[2] !== 3) continue; | |
| const m = Math.round(lo + (1 - (args[1] - TOP) / HP) * (hi - lo)); | |
| const a = Number((fill.match(/,([\d.]+)\)$/) || [])[1] || 0); | |
| bright.set(m, Math.max(bright.get(m) || 0, a)); | |
| } | |
| const top = [...bright.entries()].sort((a, b) => b[1] - a[1])[0][0]; | |
| if (top > 85 && !played.some((p) => Math.abs(p - top) <= 2)) spurious++; | |
| } | |
| assert.equal(spurious, 0, | |
| `${spurious} of 5 chords were topped by a degenerate high row nobody played`); | |
| } | |
| // ── 7b. NOISE MUST NOT PAINT AS NOTES ──────────────────────────────────── | |
| // Each column is normalised to its own peak, so without a level check a frame | |
| // of pure room noise paints exactly as brightly as a struck chord -- every | |
| // frame has a peak. That is what made a laptop fan read as a solid band across | |
| // the bass, and the noise-gate slider did nothing about it because the heat | |
| // never consulted the gate at all. | |
| { | |
| const noisy = () => Float32Array.from({ length: 64 }, (_, b) => 0.4 + 0.6 * Math.abs(Math.sin(b * 2.3))); | |
| const heatRects = (r) => r.calls.filter((c) => c.op === 'fillRect' && c.args[2] === 3).length; | |
| // A gated frame paints nothing, however loud the bank looks. | |
| { | |
| const r = rig(); | |
| for (let i = 0; i < 60; i++) { | |
| r.pushSal(i * 10, noisy(), { rms: 0.9, noiseFloor: 0.001, gated: true }); | |
| r.push(i * 10, { midiFloat: null, valid: false }); | |
| } | |
| r.draw(600, true); | |
| assert.equal(heatRects(r), 0, 'a gated frame must paint no heat'); | |
| } | |
| // A frame sitting at the room floor paints nothing. | |
| { | |
| const r = rig(); | |
| for (let i = 0; i < 60; i++) { | |
| r.pushSal(i * 10, noisy(), { rms: 0.00102, noiseFloor: 0.001, gated: false }); | |
| r.push(i * 10, { midiFloat: null, valid: false }); | |
| } | |
| r.draw(600, true); | |
| assert.equal(heatRects(r), 0, 'a frame at the noise floor must paint no heat'); | |
| } | |
| // A real note well over the floor still paints. | |
| { | |
| const r = rig(); | |
| for (let i = 0; i < 60; i++) { | |
| r.pushSal(i * 10, noisy(), { rms: 0.05, noiseFloor: 0.001, gated: false }); | |
| r.push(i * 10, { midiFloat: null, valid: false }); | |
| } | |
| r.draw(600, true); | |
| assert.ok(heatRects(r) > 50, 'a frame well over the floor must still paint'); | |
| } | |
| // ...and it fades in between rather than snapping on. | |
| { | |
| const dim = (db) => { | |
| const r = rig(); | |
| for (let i = 0; i < 60; i++) { | |
| r.pushSal(i * 10, noisy(), { rms: 0.001 * 10 ** (db / 20), noiseFloor: 0.001, gated: false }); | |
| r.push(i * 10, { midiFloat: null, valid: false }); | |
| } | |
| r.draw(600, true); | |
| let fill = null, peak = 0; | |
| for (const { op, args } of r.calls) { | |
| if (op === 'SET:fillStyle') { fill = String(args[0]); continue; } | |
| if (op !== 'fillRect' || args[2] !== 3) continue; | |
| peak = Math.max(peak, Number((fill.match(/,([\d.]+)\)$/) || [])[1] || 0)); | |
| } | |
| return peak; | |
| }; | |
| const quiet = dim(5), loud = dim(20); | |
| assert.ok(quiet > 0 && quiet < loud, `5 dB over the floor (${quiet}) must be dimmer than 20 dB (${loud})`); | |
| } | |
| } | |
| // ── 7c. A FAN IS NOT A CHORD ─────────────────────────────────────────────── | |
| // Steady rumble in the bottom rows must be learned as noise, and then neither | |
| // paint nor be decomposed into notes, while a real note on top of it still | |
| // paints. The rig seeds the estimator with digital SILENCE, which is both the | |
| // worst case and a real one -- the first frames of a getUserMedia stream are | |
| // often silent -- so this also covers the escape hatch: seeded that low, every | |
| // frame looks loud and the estimator would never learn without it. | |
| { | |
| const rumble = () => Float32Array.from({ length: 64 }, (_, b) => (b < 8 ? 0.6 - 0.05 * b : 0.02) * (0.85 + 0.3 * Math.abs(Math.sin(b * 7.1)))); | |
| const r = rig(); | |
| const feed = (from, to, sal, frame) => { for (let i = from; i < to; i++) r.pushSal(i * 10, sal(), frame); }; | |
| const quiet = { rms: 0.004, noiseFloor: 0.001, gated: false, blindPitch: { valid: false } }; | |
| // The columns already drawn keep whatever they held, so each stage is judged | |
| // on a 4 s window containing only the columns that stage produced. | |
| r.span('4000'); | |
| // before the escape fires the rumble is still painted: the estimator is stranded | |
| feed(0, 300, rumble, quiet); | |
| r.calls.length = 0; r.draw(3000, true); | |
| assert.ok(r.calls.filter((c) => c.op === 'fillRect' && c.args[2] === 3).length > 0, | |
| 'a stranded estimator should still be painting the rumble before the escape fires'); | |
| // past SCOPE_NOISE_STUCK_MS it adopts the room; a window entirely after that | |
| // adoption must be empty | |
| feed(300, 900, rumble, quiet); | |
| r.calls.length = 0; r.draw(9000, true); | |
| const heat = r.calls.filter((c) => c.op === 'fillRect' && c.args[2] === 3).length; | |
| assert.equal(heat, 0, `learned rumble must paint no heat (painted ${heat})`); | |
| const dump = r.dump(); | |
| assert.equal(dump.detected.frames.filter((f) => f.t > 5000).length, 0, 'learned rumble must yield no detected notes'); | |
| // MUSIC MUST NOT BE ADOPTED AS THE ROOM. Notes that keep arriving hold the | |
| // level high for far longer than the escape's window, but they do not hold it | |
| // STEADY, so the escape must not fire and the notes must keep painting. | |
| { | |
| const m = rig(); | |
| m.span('4000'); | |
| for (let i = 0; i < 1200; i++) { | |
| const phase = i % 120; // a note every 1.2 s, decaying | |
| const amp = Math.exp(-phase / 30); | |
| const f = rumble(); | |
| f[27] += 40 * amp; f[39] += 12 * amp; | |
| m.pushSal(i * 10, f, { rms: 0.004 + 0.05 * amp, noiseFloor: 0.001, gated: false, blindPitch: { valid: false } }); | |
| } | |
| m.calls.length = 0; m.draw(12000, true); | |
| assert.ok(m.calls.filter((c) => c.op === 'fillRect' && c.args[2] === 3).length > 20, | |
| 'repeated notes must not be adopted as the room and subtracted away'); | |
| } | |
| // a note on top of the rumble still paints | |
| const note = rumble(); note[27] += 40; note[39] += 12; // C4 and its 2nd partial | |
| feed(900, 960, () => note, { rms: 0.05, noiseFloor: 0.001, gated: false, blindPitch: { valid: true, midi: 60 } }); | |
| r.calls.length = 0; r.draw(9600, true); | |
| assert.ok(r.calls.filter((c) => c.op === 'fillRect' && c.args[2] === 3).length > 20, 'a note over the rumble must still paint'); | |
| } | |
| // ── 8. The export carries the whole screen ──────────────────────────────── | |
| { | |
| const r = rig({ expected: [48, 52] }); | |
| for (let i = 0; i < 50; i++) { | |
| r.pushSal(i * 10, Float32Array.from({ length: 64 }, (_, b) => (b === 15 ? 1 : 0.01)), { sampleRate: 48000, rms: 0.05, noiseFloor: 0.001 }); | |
| r.push(i * 10, { midiFloat: i % 2 ? 48.2 : null, valid: true, method: 'yin-4096-lowband' }); | |
| } | |
| r.mark(400, 48); | |
| const dump = r.dump(); | |
| assert.equal(dump.kind, 'notepilot-mic-scope'); | |
| assert.equal(dump.heat.frames.length, 50, 'every heat frame must be exported'); | |
| assert.equal(dump.heat.minMidi, 33); | |
| assert.equal(dump.blind.length, 25, 'every blind candidate must be exported'); | |
| assert.ok(dump.blind[0].lowBand === true, 'the low-band flag must survive export'); | |
| assert.equal(dump.advances.length, 1); | |
| assert.deepEqual(dump.expected, [48, 52]); | |
| assert.ok(JSON.stringify(dump).length > 500, 'export looks empty'); | |
| } | |
| console.log('PASS: mic scope draws finite, on-canvas geometry for empty, all-null, ' | |
| + 'single-pitch, keyboard-extreme, intermittent, frozen and long-session buffers; ' | |
| + 'real solo strikes are the brightest row; a real C3+E3 lights both notes; export is complete'); | |