' +
+ // Step 4 — calibration offer (first-run only).
+ '
' +
'
' +
'
Prove your setup: play the fee[dB]ack Diagnostic with note detection and finish at 100% accuracy to reach Mastery Rank 1.
' +
'
Not ready? Skip it and you’ll start at Rank 1 anyway — you can still play it later from the Progress screen.
' +
@@ -211,9 +269,12 @@
const skipBtn = overlay.querySelector('#v3-ob-skip');
let selected = null; // { type:'default', value } | { type:'upload', value:url }
let step = 1; // first-run wizard step (editing stays on 1)
- let selectedPaths = []; // step-2 picks
+ let songDir = ''; // step-2 song directory pick
+ let selectedPaths = []; // step-3 picks
let pathsAvailable = false; // any tiles rendered? (false → don't strand the user)
- let diagnosticFilename = null; // from /api/progression (step-3 "Play it now")
+ let diagnosticFilename = null; // from /api/progression (step-4 "Play it now")
+ const songDirEl = overlay.querySelector('#v3-ob-songdir');
+ const songDirBrowse = overlay.querySelector('#v3-ob-songdir-browse');
if (editing && profile) {
nameEl.value = profile.display_name || '';
@@ -229,6 +290,10 @@
const haveAvatar = !!selected || (editing && profile && !!profile.avatar_url);
submit.disabled = !(nameEl.value.trim().length >= 1 && haveAvatar);
} else if (step === 2) {
+ // Song directory — require a non-empty path to proceed; "Skip
+ // for now" is available for users who'll set it later.
+ submit.disabled = !songDir.trim();
+ } else if (step === 3) {
// ≥1 path required — unless none could be offered (offline /
// empty content), where blocking would strand onboarding.
submit.disabled = pathsAvailable && selectedPaths.length < 1;
@@ -240,7 +305,7 @@
function setStep(n) {
step = n;
errEl.classList.add('hidden');
- for (let i = 1; i <= 3; i++) {
+ for (let i = 1; i <= 4; i++) {
overlay.querySelector('#v3-ob-step' + i).classList.toggle('hidden', i !== n);
}
overlay.querySelectorAll('#v3-ob-dots [data-dot]').forEach((d) => {
@@ -250,11 +315,14 @@
const subtitle = overlay.querySelector('#v3-ob-subtitle');
if (subtitle) {
subtitle.textContent = n === 1 ? 'Set up your player profile'
- : n === 2 ? 'Choose your instrument paths'
+ : n === 2 ? 'Point us at your songs'
+ : n === 3 ? 'Choose your instrument paths'
: 'One last thing — calibrate your setup';
}
- submit.textContent = n === 3 ? 'Play it now' : 'Next';
- skipBtn.classList.toggle('hidden', n !== 3);
+ submit.textContent = n === 4 ? 'Play it now' : 'Next';
+ // Skip is offered on the song-directory step (configure later) and
+ // the calibration challenge.
+ skipBtn.classList.toggle('hidden', !(n === 2 || n === 4));
refreshSubmit();
}
@@ -347,6 +415,43 @@
if (editing) overlay.querySelector('#v3-ob-cancel')?.addEventListener('click', () => overlay.remove());
+ // ── Song directory (step 2) ──────────────────────────────────────────
+ if (songDirEl) {
+ songDirEl.addEventListener('input', () => { songDir = songDirEl.value.trim(); refreshSubmit(); });
+ }
+ // Native folder picker on desktop; web users type/paste the path.
+ const _desktop = window.slopsmithDesktop;
+ if (songDirBrowse && _desktop && typeof _desktop.pickDirectory === 'function') {
+ songDirBrowse.classList.remove('hidden');
+ songDirBrowse.addEventListener('click', async () => {
+ try {
+ const picked = await _desktop.pickDirectory();
+ if (picked) { songDirEl.value = picked; songDir = picked; refreshSubmit(); }
+ } catch (e) { /* user cancelled / unavailable */ }
+ });
+ }
+ // Save the song directory to settings + kick a library scan so the
+ // user's songs appear. Throws (with a message) on an invalid folder.
+ async function saveSongDir() {
+ const dir = ((songDirEl && songDirEl.value) || '').trim();
+ if (!dir) return; // skipped — leave unconfigured (settable later)
+ const res = await fetch('/api/settings', {
+ method: 'POST', headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify({ dlc_dir: dir }),
+ });
+ // /api/settings reports an invalid folder as a 200 with an `error`
+ // field (a bare dict return, not a non-2xx status), so a res.ok-only
+ // check would treat the failure as success and advance without saving.
+ // Inspect the body too.
+ let data = null;
+ try { data = await res.json(); } catch (e) { /* non-JSON body */ }
+ if (!res.ok || (data && data.error)) {
+ throw new Error((data && data.error) || 'That folder couldn’t be set — check the path and try again.');
+ }
+ // Non-fatal: scan kicks off the library build in the background.
+ try { await fetch('/api/rescan', { method: 'POST' }); } catch (e) { /* best-effort */ }
+ }
+
async function postProfile() {
const res = await fetch('/api/profile', {
method: 'POST', headers: { 'Content-Type': 'application/json' },
@@ -380,12 +485,23 @@
}
if (step === 1) {
setStep(2);
- loadPathTiles();
+ setTimeout(() => { try { songDirEl && songDirEl.focus(); } catch (e) { /* noop */ } }, 50);
return;
}
if (step === 2) {
+ // Save the song directory + kick a library scan, then continue
+ // to instrument paths. "Skip for now" leaves it unconfigured.
+ submit.disabled = true;
+ try {
+ await saveSongDir();
+ setStep(3);
+ loadPathTiles();
+ } catch (e) { showErr(e.message || 'Could not set the song directory.'); refreshSubmit(); }
+ return;
+ }
+ if (step === 3) {
// Create the profile (onboarded=1) BEFORE the calibration choice
- // so closing the overlay at step 3 can never lose the profile.
+ // so closing the overlay at the challenge can never lose the profile.
submit.disabled = true;
try {
_profile = await postProfile();
@@ -403,11 +519,14 @@
throw new Error(msg);
}
}
- setStep(3);
+ // New step: input-device selection + calibration, between
+ // path selection and the note-detect calibration challenge.
+ await runInputSetup(selectedPaths);
+ setStep(4);
} catch (e) { showErr(e.message || 'Could not save profile.'); refreshSubmit(); }
return;
}
- // Step 3 — "Play it now": leave calibration pending (it completes
+ // Step 4 — "Play it now": leave calibration pending (it completes
// through the normal scored-stats path) and launch the diagnostic.
const target = diagnosticFilename;
await finish();
@@ -415,7 +534,14 @@
});
skipBtn.addEventListener('click', async () => {
- // Step 3 — skip: Mastery Rank 1 immediately, calibration stays
+ // Step 2 — skip the song directory (the user can set it later in
+ // Settings). Proceed straight to instrument paths.
+ if (step === 2) {
+ setStep(3);
+ loadPathTiles();
+ return;
+ }
+ // Step 4 — skip: Mastery Rank 1 immediately, calibration stays
// replayable from the Progress screen.
skipBtn.disabled = true;
try {
diff --git a/tests/js/midi_input_domain.test.js b/tests/js/midi_input_domain.test.js
new file mode 100644
index 0000000..47754fe
--- /dev/null
+++ b/tests/js/midi_input_domain.test.js
@@ -0,0 +1,216 @@
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const vm = require('node:vm');
+const { createWindow, ROOT } = require('./capabilities_test_harness');
+
+const CAPABILITIES_JS = path.join(ROOT, 'static', 'capabilities.js');
+const MIDI_INPUT_JS = path.join(ROOT, 'static', 'capabilities', 'midi-input.js');
+
+function loadMidiInput(options = {}) {
+ const window = createWindow(options);
+ const context = vm.createContext(window);
+ vm.runInContext(fs.readFileSync(CAPABILITIES_JS, 'utf8'), context, { filename: CAPABILITIES_JS });
+ vm.runInContext(fs.readFileSync(MIDI_INPUT_JS, 'utf8'), context, { filename: MIDI_INPUT_JS });
+ return window;
+}
+
+// A fake provider whose enumerate/open/close are observable by the test.
+function fakeProvider(window, overrides = {}) {
+ const calls = { enumerate: 0, open: [], close: [] };
+ window.slopsmith.midiInput.registerProvider({
+ providerId: 'web-midi',
+ label: 'Web MIDI',
+ participantId: 'input_setup',
+ enumerate: async () => { calls.enumerate += 1; return overrides.sources || [{ sourceId: 'dev1', label: 'My Keyboard' }]; },
+ open: async (sourceId) => { calls.open.push(sourceId); return { addListener() {}, removeListener() {}, _id: sourceId }; },
+ close: (sourceId, handle) => { calls.close.push(sourceId); },
+ ...overrides.handlers,
+ });
+ return calls;
+}
+
+test('midi-input registers an active sensitive provider-coordinator', () => {
+ const window = loadMidiInput();
+ const api = window.slopsmith.capabilities;
+ const pipeline = api.inspect('midi-input');
+ assert.ok(pipeline, 'midi-input pipeline exists');
+ const owner = (pipeline.participants || []).find(p => p.pluginId === 'core.midi-input');
+ assert.ok(owner, 'core.midi-input owner registered');
+ assert.equal(owner.safety, 'sensitive');
+ assert.equal(owner.kind, 'provider-coordinator');
+ for (const cmd of ['inspect', 'list-sources', 'discover', 'select-source', 'open-source', 'close-source']) {
+ assert.ok(owner.commands.includes(cmd), `owner exposes ${cmd}`);
+ }
+ assert.equal(window.slopsmith.midiInput.version, 1);
+});
+
+test('list-sources and select-source are prompt-free (never enumerate)', async () => {
+ const window = loadMidiInput();
+ const api = window.slopsmith.capabilities;
+ const calls = fakeProvider(window);
+ const listed = await api.dispatch({ capability: 'midi-input', command: 'list-sources', source: 'tester' });
+ assert.equal(listed.outcome, 'handled');
+ assert.equal(calls.enumerate, 0, 'list-sources must not request MIDI access');
+});
+
+test('discover is the permission boundary and surfaces sources', async () => {
+ const window = loadMidiInput();
+ const api = window.slopsmith.capabilities;
+ const calls = fakeProvider(window);
+ const r = await api.dispatch({ capability: 'midi-input', command: 'discover', source: 'tester' });
+ assert.equal(r.outcome, 'handled');
+ assert.equal(calls.enumerate, 1, 'discover requests MIDI access exactly once');
+ const sources = window.slopsmith.midiInput.listSources();
+ assert.equal(sources.length, 1);
+ assert.equal(sources[0].logicalSourceKey, 'web-midi::dev1');
+ assert.equal(sources[0].kind, 'midi');
+});
+
+test('re-discovery drops sources for devices that vanished', async () => {
+ const window = loadMidiInput();
+ let devices = [{ sourceId: 'dev1', label: 'A' }, { sourceId: 'dev2', label: 'B' }];
+ window.slopsmith.midiInput.registerProvider({
+ providerId: 'web-midi', label: 'Web MIDI',
+ enumerate: async () => devices,
+ open: async () => ({ addListener() {}, removeListener() {} }),
+ close: () => {},
+ });
+ await window.slopsmith.midiInput.discover();
+ assert.equal(window.slopsmith.midiInput.listSources().length, 2);
+ devices = [{ sourceId: 'dev1', label: 'A' }]; // dev2 unplugged
+ await window.slopsmith.midiInput.discover();
+ const keys = window.slopsmith.midiInput.listSources().map((s) => s.logicalSourceKey);
+ assert.equal(keys.length, 1, 'vanished device is dropped from the source list');
+ assert.equal(keys[0], 'web-midi::dev1');
+});
+
+test('discover with no provider reports unavailable', async () => {
+ const window = loadMidiInput();
+ const api = window.slopsmith.capabilities;
+ const r = await api.dispatch({ capability: 'midi-input', command: 'discover', source: 'tester' });
+ assert.equal(r.outcome, 'unavailable');
+});
+
+test('discover surfaces denied when MIDI access is rejected', async () => {
+ const window = loadMidiInput();
+ const api = window.slopsmith.capabilities;
+ fakeProvider(window, { handlers: { enumerate: async () => { throw new Error('SecurityError: permission denied'); } } });
+ const r = await api.dispatch({ capability: 'midi-input', command: 'discover', source: 'tester' });
+ assert.equal(r.outcome, 'denied');
+ assert.match(r.reason, /denied/i);
+});
+
+test('select-source persists by logicalSourceKey', async () => {
+ const window = loadMidiInput();
+ const api = window.slopsmith.capabilities;
+ fakeProvider(window);
+ await api.dispatch({ capability: 'midi-input', command: 'discover', source: 'tester' });
+ const sel = await api.dispatch({ capability: 'midi-input', command: 'select-source', source: 'tester', payload: { logicalSourceKey: 'web-midi::dev1' } });
+ assert.equal(sel.outcome, 'handled');
+ assert.equal(window.__storage.get('slopsmith.midiInput.selectedLogicalSourceKey'), 'web-midi::dev1');
+ assert.ok(window.slopsmith.midiInput.listSources()[0].selected);
+});
+
+test('open/close share one session and release on the last requester', async () => {
+ const window = loadMidiInput();
+ const api = window.slopsmith.capabilities;
+ const calls = fakeProvider(window);
+ await window.slopsmith.midiInput.discover();
+ await window.slopsmith.midiInput.select('web-midi::dev1');
+ const a = await api.dispatch({ capability: 'midi-input', command: 'open-source', source: 'reqA', payload: { logicalSourceKey: 'web-midi::dev1' } });
+ const b = await api.dispatch({ capability: 'midi-input', command: 'open-source', source: 'reqB', payload: { logicalSourceKey: 'web-midi::dev1' } });
+ assert.equal(a.outcome, 'handled');
+ assert.equal(b.outcome, 'handled');
+ assert.equal(calls.open.length, 1, 'provider.open called once for a shared session');
+ // First release keeps the session open; second closes it.
+ await api.dispatch({ capability: 'midi-input', command: 'close-source', source: 'reqA', payload: { logicalSourceKey: 'web-midi::dev1' } });
+ assert.equal(calls.close.length, 0, 'session stays open while a requester holds it');
+ await api.dispatch({ capability: 'midi-input', command: 'close-source', source: 'reqB', payload: { logicalSourceKey: 'web-midi::dev1' } });
+ assert.equal(calls.close.length, 1, 'provider.close after the last release');
+});
+
+test('concurrent opens for one source coalesce onto a single provider.open', async () => {
+ const window = loadMidiInput();
+ const api = window.slopsmith.capabilities;
+ // A provider whose open() stays pending until we release it, so both
+ // dispatches are genuinely in flight at the same time.
+ let release;
+ const gate = new Promise((r) => { release = r; });
+ const calls = { open: 0, close: 0 };
+ window.slopsmith.midiInput.registerProvider({
+ providerId: 'web-midi', label: 'Web MIDI',
+ enumerate: async () => [{ sourceId: 'dev1', label: 'My Keyboard' }],
+ open: async () => { calls.open += 1; await gate; return { addListener() {}, removeListener() {} }; },
+ close: () => { calls.close += 1; },
+ });
+ await window.slopsmith.midiInput.discover();
+ await window.slopsmith.midiInput.select('web-midi::dev1');
+ const p1 = api.dispatch({ capability: 'midi-input', command: 'open-source', source: 'reqA', payload: { logicalSourceKey: 'web-midi::dev1' } });
+ const p2 = api.dispatch({ capability: 'midi-input', command: 'open-source', source: 'reqB', payload: { logicalSourceKey: 'web-midi::dev1' } });
+ release();
+ const [a, b] = await Promise.all([p1, p2]);
+ assert.equal(a.outcome, 'handled');
+ assert.equal(b.outcome, 'handled');
+ assert.equal(calls.open, 1, 'provider.open called exactly once despite concurrent opens');
+ // Both requesters joined the single shared session: it survives the first
+ // release and only closes on the last, with exactly one provider.close.
+ await api.dispatch({ capability: 'midi-input', command: 'close-source', source: 'reqA', payload: { logicalSourceKey: 'web-midi::dev1' } });
+ assert.equal(calls.close, 0, 'shared session stays open while reqB holds it');
+ await api.dispatch({ capability: 'midi-input', command: 'close-source', source: 'reqB', payload: { logicalSourceKey: 'web-midi::dev1' } });
+ assert.equal(calls.close, 1, 'provider.close once after the last requester releases');
+});
+
+test('public open() surfaces the live handle (in-page only)', async () => {
+ const window = loadMidiInput();
+ fakeProvider(window);
+ await window.slopsmith.midiInput.discover();
+ await window.slopsmith.midiInput.select('web-midi::dev1');
+ const res = await window.slopsmith.midiInput.open({ requester: 'input_setup', logicalSourceKey: 'web-midi::dev1' });
+ assert.equal(res.outcome, 'handled');
+ assert.ok(res.handle && typeof res.handle.addListener === 'function', 'live handle exposed via public global');
+});
+
+// Load the domain with a Web-MIDI-capable navigator so the built-in provider
+// self-registers (the shared harness has no navigator, so it normally skips).
+function loadWithWebMidi(inputs) {
+ const window = createWindow();
+ window.navigator = {
+ requestMIDIAccess: async () => ({
+ onstatechange: null,
+ inputs: new Map(inputs.map((i) => [i.id, { id: i.id, name: i.name, onmidimessage: null }])),
+ }),
+ };
+ const context = vm.createContext(window);
+ vm.runInContext(fs.readFileSync(CAPABILITIES_JS, 'utf8'), context, { filename: CAPABILITIES_JS });
+ vm.runInContext(fs.readFileSync(MIDI_INPUT_JS, 'utf8'), context, { filename: MIDI_INPUT_JS });
+ return window;
+}
+
+test('built-in Web-MIDI provider self-registers + discovers, filtering loopback ports', async () => {
+ const window = loadWithWebMidi([
+ { id: 'kb1', name: 'My Keyboard' },
+ { id: 'thru', name: 'Midi Through Port-0' }, // loopback → filtered out
+ ]);
+ const api = window.slopsmith.capabilities;
+ assert.ok(api.inspect('midi-input').participants.some(p => p.pluginId === 'core.midi-input'),
+ 'built-in provider registered without any plugin');
+ const r = await api.dispatch({ capability: 'midi-input', command: 'discover', source: 'tester' });
+ assert.equal(r.outcome, 'handled');
+ const sources = window.slopsmith.midiInput.listSources();
+ assert.equal(sources.length, 1, 'loopback/passthrough ports are filtered');
+ assert.equal(sources[0].logicalSourceKey, 'web-midi::kb1');
+});
+
+test('diagnostics are redaction-safe (no device labels, no raw messages)', async () => {
+ const window = loadMidiInput();
+ fakeProvider(window);
+ await window.slopsmith.midiInput.discover();
+ const contrib = window.slopsmith.diagnostics.snapshotContributions()['midi-input-capability'];
+ assert.ok(contrib, 'midi-input contributes diagnostics');
+ assert.equal(contrib.schema, 'slopsmith.midi_input.diagnostics.v1');
+ const serialized = JSON.stringify(contrib);
+ assert.ok(!serialized.includes('My Keyboard'), 'device labels are redacted from diagnostics');
+ for (const s of contrib.sources) assert.ok(!('label' in s), 'source entries carry no label');
+});