Clean release snapshot

tests/js/audio_session_test_harness.js

@@ -0,0 +1,193 @@
+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 AUDIO_SESSION_JS = path.join(ROOT, 'static', 'capabilities', 'audio-session.js');
+const AUDIO_MIXER_JS = path.join(ROOT, 'static', 'audio-mixer.js');
+
+function loadAudioSession(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(AUDIO_SESSION_JS, 'utf8'), context, { filename: AUDIO_SESSION_JS });
+    window.__vmContext = context;
+    return window;
+}
+
+function runBrowserScript(window, relativePath) {
+    const filePath = path.join(ROOT, relativePath);
+    vm.runInContext(fs.readFileSync(filePath, 'utf8'), window.__vmContext, { filename: filePath });
+}
+
+function captureEvents(window, eventName) {
+    const events = [];
+    window.slopsmith.on(eventName, event => events.push(event.detail));
+    return events;
+}
+
+function diagnosticsSnapshot(window) {
+    return window.slopsmith.audioSession.snapshot();
+}
+
+function storageEntries(window) {
+    return Object.fromEntries(window.__storage || new Map());
+}
+
+function makeInputProvider(overrides = {}) {
+    const calls = [];
+    const sources = overrides.sources || [];
+    return {
+        calls,
+        source: {
+            sourceId: overrides.sourceId || 'provider-source-1',
+            logicalSourceKey: overrides.logicalSourceKey || 'provider:input:primary',
+            providerId: overrides.providerId || 'provider',
+            ownerPluginId: overrides.ownerPluginId || overrides.providerId || 'provider',
+            kind: overrides.kind || 'instrument',
+            safeLabel: overrides.safeLabel || 'Input 1',
+            availability: overrides.availability || 'available',
+            channelSummary: overrides.channelSummary || { channelCount: 2, channelShape: 'stereo', supports: ['mono', 'stereo'] },
+            sourceMode: overrides.sourceMode || 'native',
+            operations: overrides.operations || ['source.enumerate', 'source.open', 'source.close'],
+            operationHandlers: {
+                'source.enumerate': request => { calls.push(['source.enumerate', request]); return { sources }; },
+                'source.open': request => { calls.push(['source.open', request]); return overrides.openResult || { outcome: 'handled', status: 'open' }; },
+                'source.close': request => { calls.push(['source.close', request]); return overrides.closeResult || { outcome: 'handled', status: 'closed' }; },
+                ...(overrides.operationHandlers || {}),
+            },
+        },
+    };
+}
+
+function makeMonitoringProvider(overrides = {}) {
+    const calls = [];
+    const providerId = overrides.providerId || 'monitoring-provider';
+    const logicalMonitoringKey = overrides.logicalMonitoringKey || `${providerId}:main`;
+    const operations = overrides.operations || ['monitoring.start', 'monitoring.stop', 'monitoring.status', 'monitoring.set-direct-monitor'];
+    const defaultHandlers = {
+        'monitoring.start': request => {
+            calls.push(['monitoring.start', request]);
+            return overrides.startResult || { outcome: 'handled', status: 'active', summary: { directMonitor: overrides.directMonitor || { state: 'muted', control: 'supported', preference: 'muted', applied: true }, latencySummary: overrides.latencySummary || { bucket: 'low' } } };
+        },
+        'monitoring.stop': request => {
+            calls.push(['monitoring.stop', request]);
+            return overrides.stopResult || { outcome: 'handled', status: 'stopped' };
+        },
+        'monitoring.status': request => {
+            calls.push(['monitoring.status', request]);
+            return overrides.statusResult || { outcome: 'handled', status: 'active', summary: { availability: 'available', directMonitor: overrides.directMonitor || { state: 'muted', control: 'supported', preference: 'muted', applied: true }, latencySummary: overrides.latencySummary || { bucket: 'low' } } };
+        },
+        'monitoring.set-direct-monitor': request => {
+            calls.push(['monitoring.set-direct-monitor', request]);
+            return overrides.directMonitorResult || { outcome: 'handled', status: 'active', summary: { directMonitor: { state: request.state, control: 'supported', preference: request.state, applied: true } } };
+        },
+    };
+    const operationHandlers = {};
+    for (const operation of operations) {
+        if (defaultHandlers[operation]) operationHandlers[operation] = defaultHandlers[operation];
+    }
+    Object.assign(operationHandlers, overrides.operationHandlers || {});
+    return {
+        calls,
+        provider: {
+            providerId,
+            ownerPluginId: overrides.ownerPluginId || providerId,
+            logicalMonitoringKey,
+            safeLabel: overrides.safeLabel || 'Monitoring Provider',
+            availability: overrides.availability || 'available',
+            sourceMode: overrides.sourceMode || 'native',
+            compatibilitySource: overrides.compatibilitySource || '',
+            operations,
+            directMonitor: overrides.directMonitor || { state: 'muted', control: 'supported', preference: 'muted', applied: true },
+            latencySummary: overrides.latencySummary || { bucket: 'low' },
+            operationHandlers,
+        },
+    };
+}
+
+function installDeterministicTimers(window) {
+    const timers = [];
+    let nextId = 1;
+    window.setTimeout = (callback, delay = 0) => {
+        const id = nextId;
+        nextId += 1;
+        timers.push({ id, callback, delay, cleared: false });
+        return id;
+    };
+    window.clearTimeout = id => {
+        const timer = timers.find(item => item.id === id);
+        if (timer) timer.cleared = true;
+    };
+    window.__runTimers = (minimumDelay = 0) => {
+        for (const timer of timers.slice()) {
+            if (timer.cleared || timer.delay < minimumDelay) continue;
+            timer.cleared = true;
+            timer.callback();
+        }
+    };
+    return timers;
+}
+
+function makeElement(tagName) {
+    return {
+        tagName,
+        className: '',
+        textContent: '',
+        value: '',
+        innerHTML: '',
+        disabled: false,
+        title: '',
+        style: {},
+        children: [],
+        listeners: {},
+        classList: {
+            values: new Set(),
+            add(name) { this.values.add(name); },
+            remove(name) { this.values.delete(name); },
+            contains(name) { return this.values.has(name); },
+        },
+        setAttribute(name, value) { this[name] = String(value); },
+        appendChild(child) { this.children.push(child); return child; },
+        addEventListener(type, handler) { this.listeners[type] = handler; },
+        contains() { return false; },
+        focus() {},
+    };
+}
+
+function installMixerDom(window) {
+    const elements = new Map();
+    const audio = { volume: 0, src: '', load() {} };
+    const button = makeElement('button');
+    const popover = makeElement('div');
+    elements.set('audio', audio);
+    elements.set('btn-mixer', button);
+    elements.set('mixer-popover', popover);
+    window.Event = class Event { constructor(type) { this.type = type; } };
+    window.document.readyState = 'complete';
+    window.document.getElementById = id => elements.get(id) || null;
+    window.document.addEventListener = () => {};
+    window.document.removeEventListener = () => {};
+    window.document.createElement = makeElement;
+    return { elements, audio, button, popover };
+}
+
+function loadAudioMixer(window) {
+    runBrowserScript(window, path.relative(ROOT, AUDIO_MIXER_JS));
+    return window.slopsmith.audio;
+}
+
+module.exports = {
+    loadAudioSession,
+    runBrowserScript,
+    captureEvents,
+    diagnosticsSnapshot,
+    storageEntries,
+    makeInputProvider,
+    makeMonitoringProvider,
+    installDeterministicTimers,
+    installMixerDom,
+    loadAudioMixer,
+    ROOT,
+};