Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS
JavaScript ai-agentsdashboarddeveloper-toolsdigital-twinquantified-selfsecond-brainself-hostedtailscale
import { describe, expect, it, vi, beforeEach } from 'vitest';
import { buildAlbumRecord, TRACK_IDS_MAX } from './albums/logic.js';
import { buildTrackRecord, makeRender } from './tracks/logic.js';
const queue = vi.hoisted(() => {
const listeners = new Set();
return {
events: {
on: (_event, handler) => listeners.add(handler),
off: (_event, handler) => listeners.delete(handler),
emit: (_event, job) => listeners.forEach((handler) => handler(job)),
},
updateJobResult: vi.fn(),
};
});
const trackStore = vi.hoisted(() => ({ getTrack: vi.fn(), buildRenderAppend: vi.fn(), updateTrack: vi.fn(), createTrack: vi.fn() }));
const albumStore = vi.hoisted(() => ({ getAlbum: vi.fn(), updateAlbum: vi.fn() }));
vi.mock('./mediaJobQueue/index.js', () => ({ mediaJobEvents: queue.events, updateJobResult: queue.updateJobResult }));
vi.mock('./tracks/index.js', () => trackStore);
vi.mock('./albums/index.js', () => albumStore);
const { initMusicStudioHook, __testing } = await import('./musicStudioHook.js');
describe('music studio completion hook', () => {
beforeEach(() => {
__testing.reset();
queue.updateJobResult.mockReset();
trackStore.getTrack.mockReset();
trackStore.buildRenderAppend.mockReset().mockReturnValue({ renders: [{ id: 'render-1' }] });
trackStore.updateTrack.mockReset().mockResolvedValue({ id: 'track-1' });
trackStore.createTrack.mockReset().mockImplementation(async (input) => ({ id: 'track-new', ...input }));
albumStore.getAlbum.mockReset().mockResolvedValue({ id: 'album-1', trackIds: [] });
albumStore.updateAlbum.mockReset().mockResolvedValue({});
initMusicStudioHook();
});
it('attaches a completed render to an existing track and records its id', async () => {
trackStore.getTrack.mockResolvedValue({ id: 'track-1', renders: [] });
queue.events.emit('completed', {
id: 'job-1', kind: 'audio', queuedAt: new Date().toISOString(),
params: { prompt: 'fake prompt', lyrics: '[verse] fake', musicStudio: { trackId: 'track-1', lyricsEnabled: true, lyricsProvided: true } },
result: { filename: 'fake.wav', durationSec: 12, engine: 'acestep', modelId: 'a', executionProfile: 'cuda-bf16-component-offload' },
});
await new Promise((resolve) => setImmediate(resolve));
expect(trackStore.updateTrack).toHaveBeenCalledWith('track-1', expect.objectContaining({ audioFilename: 'fake.wav', lyrics: '[verse] fake' }));
expect(trackStore.buildRenderAppend).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({
executionProfile: 'cuda-bf16-component-offload',
}));
expect(queue.updateJobResult).toHaveBeenCalledWith('job-1', { trackId: 'track-1' });
});
it('records an instrumental render without replacing saved track lyrics', async () => {
trackStore.getTrack.mockResolvedValue({ id: 'track-1', lyrics: 'keep these words', renders: [] });
queue.events.emit('completed', {
id: 'job-instrumental', kind: 'audio', queuedAt: new Date().toISOString(),
params: {
prompt: 'warm folk\n\nInstrumental only. Do not include vocals.',
lyrics: '',
musicStudio: {
trackId: 'track-1',
authoredPrompt: 'warm folk',
authoredLyrics: 'keep these words',
lyricsEnabled: true,
lyricsProvided: true,
instrumentalOnly: true,
},
},
result: { filename: 'instrumental.wav', durationSec: 60, engine: 'acestep', modelId: 'a' },
});
await new Promise((resolve) => setImmediate(resolve));
expect(trackStore.buildRenderAppend).toHaveBeenCalledWith(
expect.objectContaining({ id: 'track-1' }),
expect.objectContaining({
prompt: expect.stringContaining('Instrumental only.'),
authoredPrompt: 'warm folk',
lyrics: '',
instrumentalOnly: true,
}),
);
const update = trackStore.updateTrack.mock.calls[0][1];
expect(update.prompt).toBe('warm folk');
expect(update).not.toHaveProperty('lyrics');
expect(queue.updateJobResult).toHaveBeenCalledWith('job-instrumental', { trackId: 'track-1' });
});
it('persists exact caption and lyric provenance on the take beyond the authored caps', async () => {
const authored = 'x'.repeat(8000);
const addition = { id: 'instrumental-only', label: 'Instrumental only', text: 'No vocals.' };
const sentPrompt = `${authored}\n\n${addition.text}\n`;
const sentLyrics = `${'x'.repeat(20000)}\n[outro]`;
const lyricAdditions = [{ id: 'closing-section', label: 'Closing section', text: '[outro]' }];
trackStore.getTrack.mockResolvedValue({ id: 'track-1', renders: [] });
trackStore.buildRenderAppend.mockImplementation((_current, input) => ({ renders: [makeRender(input)] }));
queue.events.emit('completed', {
id: 'job-provenance', kind: 'audio', queuedAt: new Date().toISOString(),
params: { prompt: sentPrompt, musicStudio: {
trackId: 'track-1', authoredPrompt: authored, sentPrompt, promptAdditions: [addition], instrumentalOnly: true,
sentLyrics, lyricAdditions,
} },
result: { filename: 'provenance.wav', engine: 'musicgen' },
});
await new Promise((resolve) => setImmediate(resolve));
expect(trackStore.updateTrack.mock.calls[0][1].renders[0]).toMatchObject({
sentPrompt, promptAdditions: [addition],
sentLyrics, lyricAdditions,
});
});
it('keeps authored lyrics when an instrumental render creates a standalone track', async () => {
queue.events.emit('completed', {
id: 'job-standalone-instrumental', kind: 'audio', queuedAt: new Date().toISOString(),
params: {
prompt: 'cinematic score\n\nInstrumental only. Do not include vocals.',
lyrics: '',
musicStudio: {
trackId: null,
title: 'Fake score',
authoredPrompt: 'cinematic score',
authoredLyrics: '[verse]\nSaved draft words',
lyricsEnabled: true,
lyricsProvided: true,
instrumentalOnly: true,
},
},
result: { filename: 'standalone.wav', durationSec: 60, engine: 'acestep', modelId: 'a' },
});
await new Promise((resolve) => setImmediate(resolve));
expect(trackStore.createTrack).toHaveBeenCalledWith(expect.objectContaining({
title: 'Fake score',
prompt: 'cinematic score',
lyrics: '[verse]\nSaved draft words',
}));
});
it('creates a standalone track, appends its album, and does not crash when target is deleted', async () => {
trackStore.createTrack.mockResolvedValue({ id: 'track-new', albumId: 'album-1' });
queue.events.emit('completed', {
id: 'job-2', kind: 'audio', queuedAt: new Date().toISOString(),
params: { prompt: 'fake prompt', musicStudio: { trackId: null, title: 'Fake song', albumId: 'album-1' } },
result: { filename: 'fake.wav', durationSec: 8, engine: 'musicgen', modelId: 'm' },
});
await new Promise((resolve) => setImmediate(resolve));
expect(trackStore.createTrack).toHaveBeenCalledWith(expect.objectContaining({ title: 'Fake song', albumId: 'album-1' }));
expect(albumStore.updateAlbum).toHaveBeenCalledWith('album-1', { trackIds: ['track-new'] });
trackStore.getTrack.mockResolvedValue(null);
queue.events.emit('completed', {
id: 'job-3', kind: 'audio', queuedAt: new Date().toISOString(),
params: { prompt: 'fake prompt', musicStudio: { trackId: 'deleted-track' } },
result: { filename: 'orphan.wav' },
});
await new Promise((resolve) => setImmediate(resolve));
expect(trackStore.updateTrack).not.toHaveBeenCalledWith('deleted-track', expect.anything());
});
it.each(['full', 'missing'])('preserves completed audio as an unassigned track when the album is %s', async (state) => {
const now = '2026-01-01T00:00:00.000Z';
const album = state === 'full' ? buildAlbumRecord({
title: 'Example Album', trackIds: Array.from({ length: TRACK_IDS_MAX }, (_, i) => `track-example-${i}`),
}, { id: 'album-1', now }) : null;
albumStore.getAlbum.mockResolvedValue(album);
let storedTrack;
trackStore.createTrack.mockImplementation(async (input) => {
storedTrack = buildTrackRecord(input, { id: 'track-new', now });
return storedTrack;
});
trackStore.buildRenderAppend.mockImplementation((_track, input) => ({
renders: [makeRender(input, { id: 'render-new', now })],
}));
queue.events.emit('completed', {
id: 'job-preserved', kind: 'audio', queuedAt: now,
params: { prompt: 'Example prompt', musicStudio: { trackId: null, title: 'Example Track', albumId: 'album-1' } },
result: { filename: 'completed.wav', durationSec: 8, engine: 'musicgen', modelId: 'example-model' },
});
await new Promise((resolve) => setImmediate(resolve));
expect(storedTrack).toMatchObject({ id: 'track-new', albumId: '', audioFilename: 'completed.wav' });
expect(storedTrack.renders).toEqual([expect.objectContaining({ audioFilename: 'completed.wav' })]);
expect(albumStore.updateAlbum).not.toHaveBeenCalled();
expect(queue.updateJobResult).toHaveBeenCalledWith('job-preserved', {
trackId: 'track-new',
albumAssignmentError: { code: state === 'full' ? 'ALBUM_FULL' : 'ALBUM_NOT_FOUND', message: expect.any(String) },
});
});
it('files the privacy-safe profile prompt instead of the rollback-safe empty prompt', async () => {
trackStore.getTrack.mockResolvedValue({ id: 'track-1', renders: [] });
queue.events.emit('completed', {
id: 'job-remote', kind: 'audio', queuedAt: new Date().toISOString(),
params: {
prompt: '',
lyrics: '',
remoteMedia: {
wireVersion: 1,
peerId: '00000000-0000-4000-8000-000000000001',
profile: { style: 'ambient', mood: 'calm', tempo: 'slow', energy: 'low', instruments: ['piano'] },
request: { engine: 'remote-audio', modelId: 'example/model' },
},
musicStudio: { trackId: 'track-1', lyricsEnabled: true, lyricsProvided: false },
},
result: { filename: 'remote.wav', durationSec: 30, engine: 'remote-audio', modelId: 'example/model' },
});
await new Promise((resolve) => setImmediate(resolve));
expect(trackStore.buildRenderAppend).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({
prompt: 'Instrumental ambient music with a calm mood, slow tempo, low energy, featuring piano. No vocals or spoken words.',
lyrics: '',
}));
});
});