Spaces:
Sleeping
Sleeping
| // Audible browser → speaker → real microphone test. Requires an existing | |
| // NotePilot Chrome tab with CDP on :9222. Outputs a NEW file, never latest.json. | |
| import fs from 'node:fs'; | |
| import path from 'node:path'; | |
| import { parseArgs } from 'node:util'; | |
| import { connectNotePilot, nextAttempt, retryAlreadyCommitted, summariseRun } from './mic_loop_support.mjs'; | |
| const { values: args } = parseArgs({ options: { | |
| part: { type: 'string', default: '1' }, beats: { type: 'string', default: '30' }, | |
| seconds: { type: 'string', default: '120' }, bpm: { type: 'string', default: '60' }, | |
| 'settle-seconds': { type: 'string', default: '8' }, | |
| mic: { type: 'string', default: 'default' }, | |
| speaker: { type: 'string', default: 'default' }, | |
| volume: { type: 'string', default: '0.5' }, out: { type: 'string' }, | |
| 'max-retries': { type: 'string', default: '6' }, | |
| opt: { type: 'string', multiple: true, default: [] }, | |
| 'no-calibrate': { type: 'boolean', default: false }, | |
| 'allow-hidden': { type: 'boolean', default: false }, | |
| 'record-reference': { type: 'boolean', default: false }, | |
| 'reference-role': { type: 'string', default: 'accompaniment' }, | |
| reference: { type: 'boolean', default: false }, | |
| 'solo-only': { type: 'boolean', default: false }, | |
| help: { type: 'boolean', default: false }, | |
| } }); | |
| if (args.help) { | |
| console.log('node scripts/mic_loop.mjs --part 1 --beats 30 --out /tmp/left.json [--reference --solo-only] [--volume 0.5] [--settle-seconds 8] [--no-calibrate] [--allow-hidden] [--record-reference --reference-role solo|accompaniment] [--opt win=4096]'); | |
| process.exit(0); | |
| } | |
| const outPath = path.resolve(args.out || ''); | |
| if (!args.out || fs.existsSync(outPath) || outPath.includes(`${path.sep}.accompy_traces${path.sep}`)) { | |
| throw Error('--out must name a new scratch file outside .accompy_traces'); | |
| } | |
| const part = Number(args.part), beats = Number(args.beats), bpm = Number(args.bpm); | |
| const seconds = Number(args.seconds), volume = Number(args.volume), settleSeconds = Number(args['settle-seconds']), maxRetries = Number(args['max-retries']); | |
| if (![part, beats, bpm, seconds, volume, settleSeconds].every(Number.isFinite) | |
| || !Number.isInteger(part) || part < 0 || !(beats > 0) || !(seconds > 0) | |
| || !(bpm > 0) || !(settleSeconds >= 0) || !Number.isFinite(volume) || volume < 0 || volume > 1 || !Number.isInteger(maxRetries) || maxRetries < 0) throw Error('Invalid run settings'); | |
| if (!['solo', 'accompaniment'].includes(args['reference-role'])) throw Error('--reference-role must be solo or accompaniment'); | |
| const overrides = {}; | |
| for (const item of args.opt) { | |
| const eq = item.indexOf('='); | |
| if (eq < 1) throw Error('Use --opt name=value'); | |
| overrides[item.slice(0, eq)] = JSON.parse(item.slice(eq + 1)); | |
| } | |
| const sleep = ms => new Promise(r => setTimeout(r, ms)); | |
| const c = await connectNotePilot(); | |
| const ev = c.evaluate; | |
| let started = false, recording = false; | |
| try { | |
| const before = await ev('({playing:state.playing, trace:NPTrace.toObject()})'); | |
| if (before.playing) throw Error('An existing performance is active; end it before running the harness'); | |
| // Preserve the page's last take before a hard reload, including an unsaved one. | |
| if (before.trace) fs.writeFileSync(outPath + '.previous.json', JSON.stringify(before.trace), { flag: 'wx' }); | |
| await c.send('Page.bringToFront'); | |
| await c.send('Page.reload', { ignoreCache: true }); | |
| await sleep(1500); | |
| let ready = false; | |
| for (let i = 0; i < 60; i++) { | |
| ready = await ev('typeof state !== "undefined" && !!state.current').catch(() => false); | |
| if (ready) break; | |
| await sleep(500); | |
| } | |
| if (!ready) throw Error('Open a score in NotePilot before running the harness'); | |
| await ev(`setSelectedPartIndices([${part}])`); | |
| await sleep(1500); | |
| // The calibration sweep builds its filterbank from these options too. | |
| // Apply them before calibration so the rig and performance share a window. | |
| await ev(`Object.assign(FOLLOWER_OPTIONS, ${JSON.stringify(overrides)})`); | |
| await ev(`(async () => { | |
| const devices = await navigator.mediaDevices.enumerateDevices(); | |
| const mic = devices.find(d => d.kind === 'audioinput' && | |
| (d.deviceId === ${JSON.stringify(args.mic)} || d.label.toLowerCase().includes(${JSON.stringify(args.mic.toLowerCase())}))); | |
| if (!mic) throw Error('Requested microphone was not found'); | |
| _selectedMicId = mic.deviceId; | |
| const select = document.getElementById('mic-select'); | |
| select.value = mic.deviceId; | |
| // Select before choosing the engine. onMicEngineChange() then performs | |
| // the one necessary replacement of a running mic node. A second restart | |
| // here used to leave its first AudioWorklet posting alongside the | |
| // replacement in some Chrome runs. | |
| await onOutputDeviceChange('solo', 'default'); | |
| await onOutputDeviceChange('accompaniment', 'default'); | |
| const speaker = devices.find(d => d.kind === 'audiooutput' && | |
| (d.deviceId === ${JSON.stringify(args.speaker)} || d.label.toLowerCase().includes(${JSON.stringify(args.speaker.toLowerCase())}))); | |
| if (!speaker) throw Error('Requested speaker was not found'); | |
| await onOutputDeviceChange('solo', speaker.deviceId); | |
| // Chrome treats the literal 'default' sink ID as a dedicated context. | |
| // The paired recorder needs the mic and render reference in one clock; | |
| // empty IDs still use the same system-default speaker. | |
| if (${!!args['record-reference']}) { | |
| _outputSinkIds.solo = ''; | |
| _outputSinkIds.accompaniment = ''; | |
| } | |
| setPlaybackVolume('solo', 100); | |
| setPlaybackVolume('accompaniment', ${volume * 100}); | |
| })()`); | |
| await ev(`window.__npReferenceSoloOnly = ${args['solo-only'] === true}; onMicEngineChange(${JSON.stringify(args.reference ? 'reference' : 'follower')})`); | |
| await ev(`setInputMode('mic')`); | |
| await sleep(3000); | |
| if (!args['no-calibrate']) { | |
| console.log('Calibrating latency, gate and room response (audible)…'); | |
| await ev('calculateMicLatency()', 120000); | |
| let calibrationFinished = false; | |
| for (let i = 0; i < 240; i++) { | |
| calibrationFinished = await ev('!_micLatencyCalibration.active && !_calibrationBusy && !_rigSweepActive'); | |
| if (calibrationFinished) break; | |
| await sleep(500); | |
| } | |
| if (!calibrationFinished) throw Error('Latency, gate, and room-response calibration did not all finish'); | |
| console.log(await ev("document.getElementById('mic-latency-result')?.textContent")); | |
| } | |
| if (settleSeconds > 0) { | |
| console.log(`Settling mic and output for ${settleSeconds}s after calibration…`); | |
| await sleep(settleSeconds * 1000); | |
| } | |
| await ev(`(() => { | |
| const input = document.getElementById('bpm-input'); | |
| input.value = ${JSON.stringify(String(bpm))}; | |
| input.dispatchEvent(new Event('change', {bubbles:true})); | |
| state.practiceStartBeat = 0; | |
| })()`); | |
| const info = await ev(`({score:state.current.name, parts:selectedPartIndices(), hidden:document.hidden, | |
| mic:_selectedMicId, tag:FOLLOWER_VERSION_TAG, volume:state.playbackVolumes, | |
| events:getRightHand().map(e => [eventPitches(e),e[1]])})`); | |
| if (info.parts.length !== 1 || info.parts[0] !== part) throw Error('Solo part selection did not take effect'); | |
| if (Math.abs(info.volume.solo - 1) > 1e-6 || Math.abs(info.volume.accompaniment - volume) > 1e-6) throw Error('Playback volume settings did not take effect'); | |
| if (info.hidden) { | |
| // A sleeping secondary display can leave a frontmost tab hidden. | |
| const { windowId } = await c.send('Browser.getWindowForTarget'); | |
| await c.send('Browser.setWindowBounds', {windowId, bounds:{windowState:'normal'}}); | |
| await c.send('Browser.setWindowBounds', {windowId, bounds:{left:40,top:40,width:1200,height:850}}); | |
| await c.send('Page.bringToFront'); | |
| await sleep(500); | |
| info.hidden = await ev('document.hidden'); | |
| if (info.hidden && !args['allow-hidden']) throw Error('NotePilot remains hidden; use --allow-hidden to test the timer-backed audio path explicitly'); | |
| } | |
| const score = info.events.filter(e => e[1] <= beats); | |
| console.log(JSON.stringify({ ...info, events: score.length })); | |
| if (args['record-reference']) { | |
| // The app tees the selected playback role into this bus. Both channels | |
| // then share one browser audio clock: mic on left, output reference on right. | |
| await ev(`(() => { | |
| const ctx = outputCtx('accompaniment'); | |
| if (ctx !== audioCtx()) throw Error('Paired capture needs both roles on the default output context'); | |
| window.__npReferenceBus = ctx.createGain(); | |
| window.__npReferenceRole = ${JSON.stringify(args['reference-role'])}; | |
| })()`); | |
| } | |
| started = true; // also rescue a partially started session if startPlaying throws | |
| await ev('startPlaying()', 30000); | |
| if (!await ev(`state.playing && ${args.reference ? '!!_referenceListener' : '!!_scoreFollower'}`)) throw Error('Mic listener session failed to start'); | |
| if (args['record-reference']) { | |
| await ev(`(() => { | |
| const ctx = audioCtx(), source = _pitchDetector?._source; | |
| if (!source || window.__npReferenceBus?.context !== ctx) throw Error('Paired capture source unavailable'); | |
| const merger = ctx.createChannelMerger(2), dest = ctx.createMediaStreamDestination(); | |
| source.connect(merger, 0, 0); | |
| window.__npReferenceBus.connect(merger, 0, 1); | |
| merger.connect(dest); | |
| const mime = MediaRecorder.isTypeSupported('audio/webm;codecs=opus') ? 'audio/webm;codecs=opus' : 'audio/webm'; | |
| const recorder = new MediaRecorder(dest.stream, {mimeType:mime}); | |
| const chunks = []; | |
| recorder.ondataavailable = e => { if (e.data.size) chunks.push(e.data); }; | |
| window.__npPairedCapture = {recorder,chunks,merger,dest,mime}; | |
| recorder.start(1000); | |
| NPTrace.log('test.captureStart', {sampleRate:ctx.sampleRate,mime}); | |
| })()`); | |
| recording = true; | |
| } | |
| const runId = `mic-loop-${Date.now()}`; | |
| await ev(`NPTrace.meta({testRun:{harness:'mic_loop',runId:${JSON.stringify(runId)},part:${part},maxBeat:${beats},settleMs:${settleSeconds * 1000},hiddenAtStart:document.hidden,pairedCapture:${!!args['record-reference']},referenceRole:${JSON.stringify(args['reference-role'])},referenceListener:${!!args.reference},soloOnly:${!!args['solo-only']},physicalOutput:${!!args['record-reference']},physicalMic:${!!args['record-reference']},options:${JSON.stringify(overrides)}}})`); | |
| let i = 0, retry = 0, retries = 0, gaveUp = 0; | |
| const start = Date.now(), spb = 60000 / bpm; | |
| let anchor = start; | |
| while (i < score.length && Date.now() - start < seconds * 1000) { | |
| const wait = anchor + score[i][1] * spb - Date.now(); | |
| if (wait > 0) await sleep(Math.min(wait, Math.max(0, seconds * 1000 - (Date.now() - start)))); | |
| if (Date.now() - start >= seconds * 1000) break; | |
| // A late commit may arrive during the retry grace beat. Never emit the | |
| // queued input after the follower has already moved beyond this event. | |
| const beforeRetryPos = await ev('state.tracker.position'); | |
| if (retry > 0 && retryAlreadyCommitted(i, beforeRetryPos)) { | |
| await ev(`NPTrace.log('input.retryCancelled', {scoreEventId:${i},index:${i},attempt:${retry},attemptId:${JSON.stringify(`${runId}:e${i}:a${retry}`)},position:${beforeRetryPos}})`); | |
| i = beforeRetryPos; retry = 0; | |
| anchor = Date.now(); | |
| continue; | |
| } | |
| // One browser evaluation for the chord: no CDP round trips between voices. | |
| await ev(`(() => { | |
| if (!state.playing || state.paused) throw Error('Performance stopped or paused'); | |
| NPTrace.log('input.testEvent', {scoreEventId:${i},index:${i},pitches:${JSON.stringify(score[i][0])},attempt:${retry},attemptId:${JSON.stringify(`${runId}:e${i}:a${retry}`)},beat:${score[i][1]}}); | |
| for (const p of ${JSON.stringify(score[i][0])}) handleNote(p); | |
| })()`); | |
| let pos = 0; | |
| for (let elapsed = 0; elapsed < 450; elapsed += 50) { | |
| await sleep(50); | |
| pos = await ev('state.tracker.position'); | |
| if (pos > i) break; | |
| } | |
| // A follower jump past the event the harness just played is evidence to | |
| // record, never permission for the synthetic soloist to teleport forward. | |
| // Continuing at `pos` used to manufacture a musically impossible cascade: | |
| // the accompaniment then passed every intervening beat and the harness | |
| // injected notes from a later measure. End this take as invalid instead. | |
| if (pos > i + 1) { | |
| await ev(`NPTrace.log('test.invalid', {reason:'unexpected-follower-jump', playedIndex:${i}, trackerPosition:${pos}})`); | |
| console.log(`Stopping: follower jumped from requested #${i} to position ${pos}`); | |
| break; | |
| } | |
| const next = nextAttempt(i, pos, retry, maxRetries); | |
| if (next.retry) retries++; | |
| if (next.gaveUp) { gaveUp++; console.log(`Gave up event ${i} ${score[i][0]} after ${maxRetries} retries`); } | |
| i = next.index; retry = next.attempt; | |
| // A retry is a musical retry, not an immediate six-note machine-gun burst. | |
| // Leave a beat for the accompaniment's current sound to finish and for its | |
| // normal checkpoint hold to become audible before playing the same event. | |
| if (next.retry && i < score.length) anchor = Date.now() - score[i][1] * spb + spb; | |
| else if (next.gaveUp && i < score.length) anchor = Date.now() - score[i][1] * spb; | |
| } | |
| await ev(`NPTrace.log('test.endInput', {retries:${retries},gaveUp:${gaveUp},nextIndex:${i},plannedEvents:${score.length},timeLimit:${Date.now() - start >= seconds * 1000}})`); | |
| await sleep(1000); | |
| console.log(JSON.stringify({retries, gaveUp, attemptedThrough:i, plannedEvents:score.length})); | |
| } catch (error) { | |
| // A trace can end normally even when the driving process failed. Keep the | |
| // harness exception beside it so an interrupted take is diagnosable. | |
| fs.writeFileSync(outPath + '.failure.json', JSON.stringify({ | |
| at: new Date().toISOString(), started, message: String(error), stack: error?.stack, | |
| }, null, 2), { flag: 'wx' }); | |
| if (started) { | |
| try { await ev(`NPTrace.log('test.failure', {message:${JSON.stringify(String(error))}})`); } catch (_) {} | |
| } | |
| throw error; | |
| } finally { | |
| try { | |
| if (started) { | |
| if (recording) { | |
| const dataUrl = await ev(`(async () => { | |
| const c = window.__npPairedCapture; | |
| if (c.recorder.state !== 'inactive') await new Promise((resolve,reject) => { | |
| c.recorder.onstop = resolve; c.recorder.onerror = reject; c.recorder.stop(); | |
| }); | |
| const blob = new Blob(c.chunks, {type:c.mime}); | |
| return await new Promise((resolve,reject) => { | |
| const reader = new FileReader(); | |
| reader.onload = () => resolve(reader.result); | |
| reader.onerror = reject; | |
| reader.readAsDataURL(blob); | |
| }); | |
| })()`, 30000); | |
| fs.writeFileSync(outPath + '.paired.webm', Buffer.from(dataUrl.split(',')[1], 'base64'), {flag:'wx'}); | |
| console.log('Saved paired mic/reference audio beside trace'); | |
| } | |
| await ev("stopPlaying('mic-loop')"); | |
| const trace = await ev('JSON.stringify(NPTrace.toObject())'); | |
| if (trace && trace !== 'null') { | |
| fs.writeFileSync(outPath, trace, { flag: 'wx' }); | |
| console.log('Saved', outPath); | |
| console.log('Event-based result', JSON.stringify(summariseRun(JSON.parse(trace)))); | |
| } | |
| } | |
| } finally { | |
| try { await ev('window.__npPairedCapture = null; window.__npReferenceBus = null; window.__npReferenceRole = null'); } catch (_) {} | |
| c.close(); | |
| } | |
| } | |