mirror of
https://github.com/got-feedBack/feedBack.git
synced 2026-07-26 14:52:13 +00:00
4148b0e72e
Reword comments/docstrings/strings and rename identifiers that referenced the external game and its file formats: - format-id "psarc" -> "archive"; local vars psarc_path -> song_path, psarc_base -> tone_base - lyrics provenance value "sng" -> "notechart" (legacy "sng" still accepted) - highway_3d fret-ghost scope value "rocksmith" -> "chords" (invalid/legacy values fall back to the default, preserving behaviour) - neutralise references in prose, test names/data, .gitattributes and docs No functional change beyond the renamed identifiers; all Python compiles.
396 lines
19 KiB
JavaScript
396 lines
19 KiB
JavaScript
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 NOTE_DETECTION_JS = path.join(ROOT, 'static', 'capabilities', 'note-detection.js');
|
|
|
|
function loadNoteDetection(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(NOTE_DETECTION_JS, 'utf8'), context, { filename: NOTE_DETECTION_JS });
|
|
return window;
|
|
}
|
|
|
|
function captureEvents(api, eventNames) {
|
|
const events = [];
|
|
for (const name of eventNames) {
|
|
api.subscribe(name, (detail) => events.push(detail));
|
|
}
|
|
return events;
|
|
}
|
|
|
|
async function registerMidiProvider(api) {
|
|
return api.dispatch({
|
|
capability: 'note-detection', command: 'register-provider',
|
|
source: 'keys_highway_3d',
|
|
payload: { providerId: 'keys-midi', label: 'Keys MIDI', kind: 'midi', primitives: ['verify.target'] },
|
|
});
|
|
}
|
|
|
|
test('note-detection domain registers an active sensitive provider-coordinator', () => {
|
|
const window = loadNoteDetection();
|
|
const api = window.slopsmith.capabilities;
|
|
const pipeline = api.inspect('note-detection');
|
|
assert.ok(pipeline, 'note-detection pipeline exists');
|
|
const owner = (pipeline.participants || []).find(p => p.pluginId === 'core.note-detection');
|
|
assert.ok(owner, 'core.note-detection owner registered');
|
|
assert.equal(owner.safety, 'sensitive');
|
|
assert.ok(owner.commands.includes('open-binding'));
|
|
assert.equal(window.slopsmith.noteDetection.version, 1);
|
|
});
|
|
|
|
test('open-binding without a provider reports unavailable, never a silent verdict', async () => {
|
|
const window = loadNoteDetection();
|
|
const api = window.slopsmith.capabilities;
|
|
const result = await api.dispatch({
|
|
capability: 'note-detection', command: 'open-binding',
|
|
source: 'keys_highway_3d', payload: { context: { arrangement: 'keys' } },
|
|
});
|
|
assert.equal(result.outcome, 'unavailable');
|
|
assert.match(result.reason, /No note-detection provider/);
|
|
});
|
|
|
|
test('provider registration + binding lifecycle with per-binding context', async () => {
|
|
const window = loadNoteDetection();
|
|
const api = window.slopsmith.capabilities;
|
|
const events = captureEvents(api, [
|
|
'note-detection:provider-registered',
|
|
'note-detection:binding-opened',
|
|
'note-detection:binding-closed',
|
|
'note-detection:target-changed',
|
|
]);
|
|
|
|
const reg = await registerMidiProvider(api);
|
|
assert.equal(reg.outcome, 'handled');
|
|
assert.ok(api.inspect('note-detection').participants.some(p => p.pluginId === 'keys_highway_3d'));
|
|
|
|
const open = await api.dispatch({
|
|
capability: 'note-detection', command: 'open-binding',
|
|
source: 'keys_highway_3d',
|
|
payload: { providerId: 'keys-midi', context: { arrangement: 'keys', midiLow: 21, midiHigh: 108, capo: 0 } },
|
|
});
|
|
assert.equal(open.outcome, 'handled');
|
|
const bindingId = open.payload.bindingId;
|
|
assert.ok(bindingId);
|
|
const binding = open.payload.bindings.find(b => b.id === bindingId);
|
|
assert.equal(binding.context.arrangement, 'keys');
|
|
assert.equal(binding.context.midiLow, 21);
|
|
|
|
const target = await api.dispatch({
|
|
capability: 'note-detection', command: 'set-target',
|
|
source: 'keys_highway_3d',
|
|
payload: { bindingId, notes: [{ midi: 60 }, { midi: 64 }, { midi: 67 }] },
|
|
});
|
|
assert.equal(target.outcome, 'handled');
|
|
assert.equal(target.payload.targetSize, 3);
|
|
|
|
const close = await api.dispatch({
|
|
capability: 'note-detection', command: 'close-binding',
|
|
source: 'keys_highway_3d', payload: { bindingId },
|
|
});
|
|
assert.equal(close.outcome, 'handled');
|
|
|
|
const names = events.map(e => e.event);
|
|
assert.ok(names.includes('provider-registered'));
|
|
assert.ok(names.includes('binding-opened'));
|
|
assert.ok(names.includes('target-changed'));
|
|
assert.ok(names.includes('binding-closed'));
|
|
});
|
|
|
|
test('concurrent bindings keep independent contexts (FR-003)', async () => {
|
|
const window = loadNoteDetection();
|
|
const api = window.slopsmith.capabilities;
|
|
await registerMidiProvider(api);
|
|
const a = await api.dispatch({
|
|
capability: 'note-detection', command: 'open-binding',
|
|
source: 'highway', payload: { context: { arrangement: 'guitar', stringCount: 6, capo: 2 } },
|
|
});
|
|
const b = await api.dispatch({
|
|
capability: 'note-detection', command: 'open-binding',
|
|
source: 'slopscale', payload: { context: { arrangement: 'bass', stringCount: 4, capo: 0 } },
|
|
});
|
|
const snapshot = window.slopsmith.noteDetection.snapshot();
|
|
const ctxA = snapshot.bindings.find(x => x.id === a.payload.bindingId).context;
|
|
const ctxB = snapshot.bindings.find(x => x.id === b.payload.bindingId).context;
|
|
assert.equal(ctxA.arrangement, 'guitar');
|
|
assert.equal(ctxA.capo, 2);
|
|
assert.equal(ctxB.arrangement, 'bass');
|
|
assert.equal(ctxB.capo, 0);
|
|
});
|
|
|
|
test('unregistering a provider closes its bindings and flips availability', async () => {
|
|
const window = loadNoteDetection();
|
|
const api = window.slopsmith.capabilities;
|
|
const events = captureEvents(api, ['note-detection:availability-changed', 'note-detection:binding-closed']);
|
|
await registerMidiProvider(api);
|
|
const openResult = await api.dispatch({ capability: 'note-detection', command: 'open-binding', source: 'keys_highway_3d', payload: {} });
|
|
assert.equal(openResult.outcome, 'handled');
|
|
assert.equal(window.slopsmith.noteDetection.snapshot().bindings.length, 1);
|
|
const result = await api.dispatch({
|
|
capability: 'note-detection', command: 'unregister-provider',
|
|
source: 'keys_highway_3d', payload: { providerId: 'keys-midi' },
|
|
});
|
|
assert.equal(result.outcome, 'handled');
|
|
assert.equal(window.slopsmith.noteDetection.snapshot().bindings.length, 0);
|
|
const availability = events.filter(e => e.event === 'availability-changed').map(e => e.payload.available);
|
|
assert.deepEqual(JSON.parse(JSON.stringify(availability)), [true, false]);
|
|
assert.ok(events.some(e => e.event === 'binding-closed' && e.payload.reason === 'provider-unregistered'));
|
|
// Runtime participant must be removed from the pipeline so inspect() no
|
|
// longer lists the provider as active after it unregisters.
|
|
const participants = api.inspect('note-detection').participants || [];
|
|
assert.ok(!participants.some(p => p.pluginId === 'keys_highway_3d' && (p.roles || []).includes('provider')),
|
|
'provider participant should be removed from the pipeline on unregister');
|
|
});
|
|
|
|
test('hit/miss reports flow as observability events with bounded fields', () => {
|
|
const window = loadNoteDetection();
|
|
const api = window.slopsmith.capabilities;
|
|
const events = captureEvents(api, ['note-detection:hit', 'note-detection:miss']);
|
|
window.slopsmith.noteDetection.reportHit({ bindingId: 'ndb-1', providerId: 'keys-midi', midi: 64, hit: true, secretDevice: 'Yamaha P-125' });
|
|
window.slopsmith.noteDetection.reportMiss({ bindingId: 'ndb-1', providerId: 'keys-midi', midi: 65, hit: false });
|
|
assert.equal(events.length, 2);
|
|
assert.equal(events[0].payload.midi, 64);
|
|
// Unknown fields are dropped — payloads stay bounded and device-label free.
|
|
assert.equal(events[0].payload.secretDevice, undefined);
|
|
assert.equal(events[1].event, 'miss');
|
|
});
|
|
|
|
test('diagnostics contribution is redaction-safe', async () => {
|
|
const window = loadNoteDetection();
|
|
const api = window.slopsmith.capabilities;
|
|
await registerMidiProvider(api);
|
|
await api.dispatch({
|
|
capability: 'note-detection', command: 'open-binding',
|
|
source: 'keys_highway_3d', payload: { context: { arrangement: 'keys', deviceLabel: 'Yamaha P-125' } },
|
|
});
|
|
window.slopsmith.noteDetection.reportHit({ bindingId: 'ndb-1', midi: 60, hit: true });
|
|
const contribution = window.__diagnosticsContributions.get('note-detection-capability');
|
|
assert.equal(contribution.schema, 'slopsmith.note_detection_capability.v1');
|
|
const serialized = JSON.stringify(contribution);
|
|
assert.ok(!/Yamaha|deviceLabel|filename|\.sloppak|\.archive/i.test(serialized), serialized);
|
|
});
|
|
|
|
test('legacy setNoteStateProvider surface is wrapped and accounted', () => {
|
|
const window = loadNoteDetection();
|
|
const api = window.slopsmith.capabilities;
|
|
// Simulate highway.js arriving after the host, then the notedetect
|
|
// plugin installing its chart-coupled provider.
|
|
let installed = null;
|
|
window.highway = { setNoteStateProvider(fn) { installed = fn; } };
|
|
window.slopsmith.emit('song:loaded', {});
|
|
const provider = () => ({ state: 'hit' });
|
|
window.highway.setNoteStateProvider(provider);
|
|
assert.equal(installed, provider, 'legacy behavior preserved');
|
|
const shims = api.snapshotDiagnostics().compatibilityShims
|
|
.filter(s => s.capability === 'note-detection');
|
|
assert.equal(shims.length, 1);
|
|
assert.equal(shims[0].shimId, 'note-detection:highway.setNoteStateProvider');
|
|
assert.equal(shims[0].status, 'used');
|
|
assert.ok(shims[0].hitCount >= 1);
|
|
});
|
|
|
|
test('unsupported binding/provider ids degrade with bounded reasons (FR-008)', async () => {
|
|
const window = loadNoteDetection();
|
|
const api = window.slopsmith.capabilities;
|
|
await registerMidiProvider(api);
|
|
const badProvider = await api.dispatch({
|
|
capability: 'note-detection', command: 'open-binding',
|
|
source: 'x', payload: { providerId: 'nope' },
|
|
});
|
|
assert.equal(badProvider.outcome, 'degraded');
|
|
const badBinding = await api.dispatch({
|
|
capability: 'note-detection', command: 'set-target',
|
|
source: 'x', payload: { bindingId: 'ndb-999', notes: [] },
|
|
});
|
|
assert.equal(badBinding.outcome, 'degraded');
|
|
});
|
|
|
|
test('_contextSummary whitelists arrangement kind — unknown values are dropped', async () => {
|
|
const window = loadNoteDetection();
|
|
const api = window.slopsmith.capabilities;
|
|
await registerMidiProvider(api);
|
|
// Known arrangement kinds pass through.
|
|
const open = await api.dispatch({
|
|
capability: 'note-detection', command: 'open-binding',
|
|
source: 'caller', payload: { context: { arrangement: 'keys', stringCount: 6 } },
|
|
});
|
|
assert.equal(open.outcome, 'handled');
|
|
const snap = window.slopsmith.noteDetection.snapshot();
|
|
const ctx = snap.bindings.find(b => b.id === open.payload.bindingId).context;
|
|
assert.equal(ctx.arrangement, 'keys');
|
|
|
|
// Arbitrary string must not appear in context summary.
|
|
const open2 = await api.dispatch({
|
|
capability: 'note-detection', command: 'open-binding',
|
|
source: 'caller', payload: { context: { arrangement: '/Users/victim/song.archive' } },
|
|
});
|
|
assert.equal(open2.outcome, 'handled');
|
|
const snap2 = window.slopsmith.noteDetection.snapshot();
|
|
const ctx2 = snap2.bindings.find(b => b.id === open2.payload.bindingId).context;
|
|
assert.equal(ctx2.arrangement, undefined, 'path-bearing arrangement must be dropped');
|
|
});
|
|
|
|
test('snapshot primitives are deep-copied — caller cannot mutate provider internals', async () => {
|
|
const window = loadNoteDetection();
|
|
const api = window.slopsmith.capabilities;
|
|
await registerMidiProvider(api);
|
|
const snap1 = window.slopsmith.noteDetection.snapshot();
|
|
const providerEntry = snap1.providers.find(p => p.id === 'keys-midi');
|
|
assert.ok(Array.isArray(providerEntry.primitives));
|
|
// Mutate the copy — must not affect subsequent snapshots.
|
|
providerEntry.primitives.push('injected');
|
|
const snap2 = window.slopsmith.noteDetection.snapshot();
|
|
const providerEntry2 = snap2.providers.find(p => p.id === 'keys-midi');
|
|
assert.ok(!providerEntry2.primitives.includes('injected'), 'live primitives must not be mutated via snapshot');
|
|
});
|
|
|
|
test('close-binding and set-target enforce requester ownership', async () => {
|
|
const window = loadNoteDetection();
|
|
const api = window.slopsmith.capabilities;
|
|
await registerMidiProvider(api);
|
|
const open = await api.dispatch({
|
|
capability: 'note-detection', command: 'open-binding',
|
|
source: 'owner-plugin', payload: {},
|
|
});
|
|
const bindingId = open.payload.bindingId;
|
|
|
|
// A different requester must not close the binding.
|
|
const stealClose = await api.dispatch({
|
|
capability: 'note-detection', command: 'close-binding',
|
|
source: 'other-plugin', payload: { bindingId },
|
|
});
|
|
assert.equal(stealClose.outcome, 'degraded', 'non-owner close must be rejected');
|
|
|
|
// A different requester must not retarget the binding.
|
|
const stealTarget = await api.dispatch({
|
|
capability: 'note-detection', command: 'set-target',
|
|
source: 'other-plugin', payload: { bindingId, notes: [{ midi: 60 }] },
|
|
});
|
|
assert.equal(stealTarget.outcome, 'degraded', 'non-owner set-target must be rejected');
|
|
|
|
// The binding must still exist and be closeable by the original owner.
|
|
const ownerClose = await api.dispatch({
|
|
capability: 'note-detection', command: 'close-binding',
|
|
source: 'owner-plugin', payload: { bindingId },
|
|
});
|
|
assert.equal(ownerClose.outcome, 'handled');
|
|
});
|
|
|
|
test('register-provider rejects cross-owner re-registration', async () => {
|
|
const window = loadNoteDetection();
|
|
const api = window.slopsmith.capabilities;
|
|
// First registration by plugin-a.
|
|
const first = await api.dispatch({
|
|
capability: 'note-detection', command: 'register-provider',
|
|
source: 'plugin-a',
|
|
payload: { providerId: 'shared-provider', label: 'Shared', kind: 'js', primitives: [] },
|
|
});
|
|
assert.equal(first.outcome, 'handled');
|
|
|
|
// A different participant must not overwrite the same providerId.
|
|
const steal = await api.dispatch({
|
|
capability: 'note-detection', command: 'register-provider',
|
|
source: 'plugin-b',
|
|
payload: { providerId: 'shared-provider', label: 'Hijacked', kind: 'js', primitives: [] },
|
|
});
|
|
assert.equal(steal.outcome, 'degraded', 'cross-owner re-registration must be rejected');
|
|
|
|
// The original owner may still update its own registration.
|
|
const refresh = await api.dispatch({
|
|
capability: 'note-detection', command: 'register-provider',
|
|
source: 'plugin-a',
|
|
payload: { providerId: 'shared-provider', label: 'Refreshed', kind: 'js', primitives: [] },
|
|
});
|
|
assert.equal(refresh.outcome, 'handled', 'owner may refresh its own registration');
|
|
});
|
|
|
|
test('unregister-provider rejects cross-owner unregister', async () => {
|
|
const window = loadNoteDetection();
|
|
const api = window.slopsmith.capabilities;
|
|
await registerMidiProvider(api);
|
|
|
|
// A different participant must not unregister a provider it does not own.
|
|
const steal = await api.dispatch({
|
|
capability: 'note-detection', command: 'unregister-provider',
|
|
source: 'other-plugin', payload: { providerId: 'keys-midi' },
|
|
});
|
|
assert.equal(steal.outcome, 'degraded', 'cross-owner unregister must be rejected');
|
|
|
|
// Provider must still be present after the failed cross-owner attempt.
|
|
const snap = window.slopsmith.noteDetection.snapshot();
|
|
assert.ok(snap.providers.some(p => p.id === 'keys-midi'), 'provider must survive cross-owner unregister attempt');
|
|
|
|
// The original owner can still unregister.
|
|
const ownerUnreg = await api.dispatch({
|
|
capability: 'note-detection', command: 'unregister-provider',
|
|
source: 'keys_highway_3d', payload: { providerId: 'keys-midi' },
|
|
});
|
|
assert.equal(ownerUnreg.outcome, 'handled', 'owner must be able to unregister its own provider');
|
|
});
|
|
|
|
test('availability-changed fires only on 0→1 and 1→0 transitions', async () => {
|
|
const window = loadNoteDetection();
|
|
const api = window.slopsmith.capabilities;
|
|
const events = captureEvents(api, ['note-detection:availability-changed']);
|
|
|
|
// First registration: 0→1, should emit.
|
|
await registerMidiProvider(api);
|
|
// Second registration of a different provider by same owner: already available, must NOT emit.
|
|
await api.dispatch({
|
|
capability: 'note-detection', command: 'register-provider',
|
|
source: 'plugin-b',
|
|
payload: { providerId: 'engine-provider', label: 'Engine', kind: 'engine', primitives: [] },
|
|
});
|
|
// Unregister first provider: still one left, must NOT emit.
|
|
await api.dispatch({
|
|
capability: 'note-detection', command: 'unregister-provider',
|
|
source: 'keys_highway_3d', payload: { providerId: 'keys-midi' },
|
|
});
|
|
// Unregister last provider: 1→0, should emit false.
|
|
await api.dispatch({
|
|
capability: 'note-detection', command: 'unregister-provider',
|
|
source: 'plugin-b', payload: { providerId: 'engine-provider' },
|
|
});
|
|
|
|
const available = events.map(e => e.payload.available);
|
|
assert.deepEqual(JSON.parse(JSON.stringify(available)), [true, false],
|
|
'only the 0→1 and final 1→0 transitions should emit availability-changed');
|
|
});
|
|
|
|
test('unregistering one of two providers from the same participant keeps participant in the pipeline', async () => {
|
|
const window = loadNoteDetection();
|
|
const api = window.slopsmith.capabilities;
|
|
|
|
// One plugin registers two providers under the same participantId.
|
|
await api.dispatch({
|
|
capability: 'note-detection', command: 'register-provider',
|
|
source: 'multi-plugin',
|
|
payload: { providerId: 'multi-provider-a', label: 'A', kind: 'js', primitives: [] },
|
|
});
|
|
await api.dispatch({
|
|
capability: 'note-detection', command: 'register-provider',
|
|
source: 'multi-plugin',
|
|
payload: { providerId: 'multi-provider-b', label: 'B', kind: 'js', primitives: [] },
|
|
});
|
|
|
|
// Unregister one provider — the participant must remain in the pipeline
|
|
// because the second provider from the same plugin still exists.
|
|
const unreg = await api.dispatch({
|
|
capability: 'note-detection', command: 'unregister-provider',
|
|
source: 'multi-plugin', payload: { providerId: 'multi-provider-a' },
|
|
});
|
|
assert.equal(unreg.outcome, 'handled');
|
|
|
|
const snap = window.slopsmith.noteDetection.snapshot();
|
|
assert.ok(!snap.providers.some(p => p.id === 'multi-provider-a'), 'provider-a must be removed');
|
|
assert.ok(snap.providers.some(p => p.id === 'multi-provider-b'), 'provider-b must still be present');
|
|
const participants = api.inspect('note-detection').participants || [];
|
|
assert.ok(participants.some(p => p.pluginId === 'multi-plugin'),
|
|
'multi-plugin participant must remain in pipeline while it still has a live provider');
|
|
});
|