Clean release snapshot

tests/js/playback_compat.test.js

@@ -0,0 +1,101 @@
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const { loadPlayback, captureEvents, diagnosticsSnapshot, makeTarget, dispatch, makeAdapter, ROOT } = require('./playback_test_harness');
+const { loadCapabilities } = require('./capabilities_test_harness');
+
+test('requester and observer registration is idempotent and visible in diagnostics', async () => {
+    const window = loadPlayback();
+    await dispatch(window, 'register-requester', { requesterId: 'plugin.practice', kind: 'plugin', requests: ['pause'] });
+    await dispatch(window, 'register-requester', { requesterId: 'plugin.practice', kind: 'plugin', requests: ['seek'], status: 'available' });
+    await dispatch(window, 'register-observer', { observerId: 'plugin.hud', observes: ['ready', 'seeked'] });
+
+    const participants = diagnosticsSnapshot(window).participants;
+    assert.equal(participants.filter(item => item.requesterId === 'plugin.practice').length, 1);
+    assert.equal(participants.filter(item => item.observerId === 'plugin.hud').length, 1);
+});
+
+test('plugin fresh starts require user action and incompatible playback participants do not execute', async () => {
+    const window = loadPlayback();
+    const denied = await dispatch(window, 'start', { requesterId: 'plugin.remote', target: makeTarget() });
+    assert.equal(denied.status, 'user-action-required');
+
+    const incompatibleWindow = loadCapabilities();
+    const fixture = JSON.parse(fs.readFileSync(path.join(ROOT, 'tests', 'fixtures', 'plugin_capabilities', 'unsupported_capability_version.json'), 'utf8'));
+    fixture.id = 'future_playback';
+    fixture.capabilities = { playback: { roles: ['owner'], commands: ['inspect'], runtime: true, version: 999, handlers: { inspect: () => ({ outcome: 'handled' }) } } };
+    incompatibleWindow.slopsmith.capabilities.registerParticipants([fixture]);
+    const result = await incompatibleWindow.slopsmith.capabilities.dispatch({ capability: 'playback', command: 'inspect', requester: 'test' });
+    assert.equal(result.status, 'incompatible-version');
+});
+
+test('same-priority latest controls remain non-stale while user-priority commands deny background automation', async () => {
+    const window = loadPlayback();
+    window.slopsmith.playback.registerTransportAdapter(makeAdapter());
+    await dispatch(window, 'start', { authorization: 'user-action', requesterId: 'core.player.controls', target: makeTarget() });
+    const firstPause = await dispatch(window, 'pause', { requesterId: 'plugin.a', priority: 'normal' });
+    const normalResume = await dispatch(window, 'resume', { requesterId: 'plugin.b', priority: 'normal' });
+    await dispatch(window, 'pause', { requesterId: 'core.player.controls', priority: 'user' });
+    const blockedResume = await dispatch(window, 'resume', { requesterId: 'plugin.b', priority: 'normal' });
+
+    assert.equal(firstPause.status, 'paused');
+    assert.equal(normalResume.status, 'playing');
+    assert.equal(blockedResume.status, 'denied');
+});
+
+test('legacy bridge hits are attributed to playback compatibility shims', () => {
+    const window = loadPlayback();
+    const bridgeEvents = captureEvents(window, 'playback:bridge-hit');
+
+    window.slopsmith.playback.recordBridgeHit({
+        bridgeId: 'playback.window-play-song',
+        legacySurface: 'window.playSong',
+        source: 'core.app',
+        reason: 'legacy playSong entry point used',
+    });
+
+    const playback = diagnosticsSnapshot(window);
+    const runtime = window.slopsmith.capabilities.snapshotDiagnostics();
+    const shim = runtime.compatibilityShims.find(item => item.capability === 'playback' && item.legacySurface === 'window.playSong');
+
+    assert.equal(bridgeEvents.length, 1);
+    assert.equal(playback.bridges[0].bridgeId, 'playback.window-play-song');
+    assert.equal(playback.bridges[0].hitCount, 1);
+    assert.ok(shim);
+    assert.equal(shim.hitCount, 1);
+});
+
+test('legacy song events update playback state without exposing raw filenames', () => {
+    const window = loadPlayback();
+    window.slopsmith.emit('song:loading', { filename: '/Users/example/Secret Folder/Artist - Song_p.psarc', arrangement: 0 });
+    window.slopsmith.emit('song:loaded', makeTarget({ filename: '/Users/example/Secret Folder/Artist - Song_p.psarc' }));
+    window.slopsmith.emit('song:play', { time: 4, audioT: 4, chartT: 4 });
+    window.slopsmith.emit('song:seek', { from: 4, to: 12, reason: 'seek-by' });
+
+    const playback = diagnosticsSnapshot(window);
+    const encoded = JSON.stringify(playback);
+
+    assert.equal(playback.state.state, 'playing');
+    assert.equal(playback.state.media.currentTime, 12);
+    assert.match(playback.state.target.settingsKey, /^settings-v1-[a-z0-9]{7}$/);
+    assert.ok(playback.bridges.some(bridge => bridge.bridgeId === 'playback.song-events'));
+    assert.doesNotMatch(encoded, /Secret Folder/);
+    assert.doesNotMatch(encoded, /Artist - Song_p\.psarc/);
+});
+
+test('route changes are captured as redaction-safe playback lifecycle events', () => {
+    const window = loadPlayback();
+    const changing = captureEvents(window, 'playback:route-changing');
+    const changed = captureEvents(window, 'playback:route-changed');
+
+    window.slopsmith.playback.recordRouteChange({ routeKind: 'desktop-native', state: 'switching', preservedTime: true, safeReason: 'desktop engine active' });
+    window.slopsmith.playback.recordRouteChange({ routeKind: 'desktop-native', state: 'active', preservedTime: true, safeReason: 'desktop route active' });
+
+    const playback = diagnosticsSnapshot(window);
+    assert.equal(changing.length, 1);
+    assert.equal(changed.length, 1);
+    assert.equal(playback.state.route.routeKind, 'desktop-native');
+    assert.equal(playback.state.route.state, 'active');
+    assert.equal(playback.state.route.preservedTime, true);
+});