Skip to content

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

36.2 KB
Raw Blame
// Engine mechanics are isolated from the review contract, covered in route/orchestration suites.
vi.mock('./productionReview.js', async (load) => ({ ...await load(), assertProductionApproval: vi.fn() }));
import { describe, it, expect, vi, beforeEach } from 'vitest';

// #2386 — exactly-once terminal handling for the music-video renderer that
// distinguishes a pre-spawn failure (finalize immediately) from a post-spawn
// error such as a failed kill (retain process + project-mutex ownership until
// 'close'). These tests drive a fake ffmpeg child process and emit the
// error/close sequences before AND after 'spawn'.

// A tiny synchronous event emitter — avoids pulling `events` into the hoisted
// mock factory (which runs before imports resolve).
const h = vi.hoisted(() => {
  const procs = [];
  const makeEmitter = () => {
    const listeners = {};
    return {
      on(ev, fn) { (listeners[ev] ||= []).push(fn); return this; },
      emit(ev, ...args) {
        const fns = listeners[ev] || [];
        for (const fn of fns) fn(...args);
        return fns.length > 0;
      },
    };
  };
  const spawn = (_cmd, args) => {
    const p = makeEmitter();
    p.args = args;
    p.stderr = makeEmitter();
    p.kill = () => {};
    procs.push(p);
    return p;
  };
  return { procs, spawn };
});

vi.mock('../../lib/childProcess.js', () => ({ spawn: h.spawn }));
vi.mock('fs', () => ({ existsSync: vi.fn(() => true) }));
vi.mock('fs/promises', () => ({ unlink: vi.fn(async () => {}) }));
vi.mock('../../lib/fileUtils.js', () => ({
  ensureDir: vi.fn(async () => {}),
  PATHS: { videos: '/data/videos', videoThumbnails: '/data/thumbs', music: '/data/music', images: '/data/images', data: '/data' },
}));
vi.mock('../../lib/sseUtils.js', () => ({
  broadcastSse: vi.fn(),
  attachSseClient: vi.fn(),
  closeJobAfterDelay: vi.fn(),
}));
vi.mock('../../lib/ffmpeg.js', () => ({
  findFfmpeg: vi.fn(async () => '/usr/bin/ffmpeg'),
  safeUnder: (root, name) => (name ? `${root}/${name}` : null),
  generateThumbnail: vi.fn(async () => 'thumb.jpg'),
  probeVideoDuration: vi.fn(async () => 30),
}));
vi.mock('../../lib/processEnv.js', () => ({
  safeChildProcessOptions: (options = {}) => ({ ...options, env: {}, windowsHide: true }),
}));
vi.mock('../../lib/killWithEscalation.js', () => ({ killWithEscalation: vi.fn() }));
vi.mock('../videoGen/local.js', () => ({
  loadHistory: vi.fn(),
  mutateVideoHistory: vi.fn(async (fn) => fn([])),
}));
vi.mock('../tracks/index.js', () => ({ getTrack: vi.fn() }));
vi.mock('./statsOutro.js', () => ({ appendStatsOutro: vi.fn(async () => 0), sweepStatsOutroScratch: vi.fn(async () => {}) }));
vi.mock('./compositionRender.js', () => ({
  removeCompositionScratch: vi.fn(async () => {}),
  sweepCompositionScratch: vi.fn(async () => {}),
}));
vi.mock('./projects.js', () => ({ getProject: vi.fn(), listProjects: vi.fn(async () => []), updateProject: vi.fn(async () => ({})), mutateProjectRecord: vi.fn() }));
vi.mock('./renderCleanup.js', () => ({ cleanupSupersededFinals: vi.fn(async () => ({})) }));
vi.mock('../instanceIdentity.js', () => ({ ensureInstanceId: vi.fn(async () => 'inst-self') }));
// A composed render goes shot by shot (shotSegments.js): the segment work is
// held open until a test settles it, or rejects on the render's abort signal.
const seg = vi.hoisted(() => ({ plans: [], render: null, stitch: vi.fn(async () => ({ durationSec: 2, songSec: 2 })) }));
vi.mock('./shotSegments.js', () => ({
  planShotSegments: vi.fn(async (project) => {
    // Planning refuses what the whole-film plan refuses (missing stills, untimed sections).
    await (await import('./render.js')).planMusicVideoRender(project);
    const plan = { project, songSec: 2, width: 910, height: 512, fps: 24, segments: [{ sceneId: 's1', path: '/data/seg/a.mp4', frames: 48 }], outro: null };
    seg.plans.push(plan);
    return plan;
  }),
  renderMissingSegments: vi.fn((plan, { signal, onProgress }) => new Promise((resolve, reject) => {
    seg.render = { resolve, onProgress };
    signal.addEventListener('abort', () => reject(Object.assign(new Error('Render cancelled'), { code: 'CANCELED' })), { once: true });
  })),
  stitchSegments: (...args) => seg.stitch(...args),
  pruneSegments: vi.fn(async () => 0),
  sweepPartialSegments: vi.fn(async () => {}),
}));

import { buildTypographyDocument } from './composition.js';
import { renderMusicVideo, getRenderJobStatus, cancelRender } from './render.js';
import { removeCompositionScratch } from './compositionRender.js';
import { findFfmpeg, generateThumbnail } from '../../lib/ffmpeg.js';
import { loadHistory } from '../videoGen/local.js';
import { getTrack } from '../tracks/index.js';
import { getProject, listProjects, updateProject, mutateProjectRecord } from './projects.js';
import { unlink } from 'fs/promises';
import { musicVideoEvents } from './events.js';
import { broadcastSse } from '../../lib/sseUtils.js';
import { killWithEscalation } from '../../lib/killWithEscalation.js';
import { maintenance } from '../../lib/maintenanceAdmission.js';

const tick = () => new Promise((r) => setTimeout(r, 0));
const lastProc = () => h.procs[h.procs.length - 1];
// A terminal project write: the status plus the cleared in-flight mark (#9010).
const settled = (status, extra = {}) => ({ status, renderError: null, ...extra, renderingOn: null, renderPartialFilename: null, renderResume: null });

const prime = (projectId) => {
  getProject.mockResolvedValue({
    id: projectId, name: 'P', trackId: 't1', status: 'ready',
    scenes: [{ sceneId: 's1', order: 0, videoHistoryId: 'h1' }],
  });
  getTrack.mockResolvedValue({ audioFilename: 'song.wav' });
  loadHistory.mockResolvedValue([{ id: 'h1', filename: 'a.mp4', width: 768, height: 512, fps: 24, numFrames: 48 }]);
  findFfmpeg.mockResolvedValue('/usr/bin/ffmpeg');
};

beforeEach(() => {
  vi.clearAllMocks();
  h.procs.length = 0;
  seg.render = null;
  seg.plans.length = 0;
});

describe('renderMusicVideo terminal handling (#2386)', () => {
  it('finalizes immediately on a PRE-spawn error and releases the project slot', async () => {
    const pid = 'pre-1';
    prime(pid);
    const settledEvents = [];
    const onRender = (e) => settledEvents.push(e);
    musicVideoEvents.on('render', onRender);
    const { jobId } = await renderMusicVideo(pid);
    const proc = lastProc();

    // No 'spawn' event → genuine spawn failure. 'close' will not follow.
    proc.emit('error', new Error('spawn ENOENT'));
    await tick();
    musicVideoEvents.off('render', onRender);
    // An autonomous run waiting on this render learns it failed (and why).
    expect(settledEvents).toEqual([{ projectId: pid, jobId, status: 'failed', error: expect.stringMatching(/Failed to spawn ffmpeg/) }]);

    expect(getRenderJobStatus(jobId).status).toBe('error');
    expect(getRenderJobStatus(jobId).error).toMatch(/Failed to spawn ffmpeg/);
    expect(updateProject).toHaveBeenCalledWith(pid, settled('failed', { renderError: 'Failed to spawn ffmpeg: spawn ENOENT' }));

    // Slot released — a re-render reaches spawn again instead of 409ing.
    const again = await renderMusicVideo(pid);
    expect(again.jobId).toBeTruthy();
    expect(again.jobId).not.toBe(jobId);
  });

  it('retains the slot on a POST-spawn error until close (no overlapping render)', async () => {
    const pid = 'post-1';
    prime(pid);
    const { jobId } = await renderMusicVideo(pid);
    const proc = lastProc();

    proc.emit('spawn'); // child is live
    proc.emit('error', new Error('kill EPERM')); // failed kill, process still running
    await tick();

    // NOT finalized: status stays running, project not marked failed, slot held.
    expect(getRenderJobStatus(jobId).status).toBe('running');
    expect(updateProject).not.toHaveBeenCalledWith(pid, settled('failed'));
    await expect(renderMusicVideo(pid)).rejects.toMatchObject({
      status: 409, code: 'RENDER_IN_PROGRESS', context: { jobId },
    });

    // 'close' is the sole terminal handler for the post-spawn error.
    proc.emit('close', 1, null);
    await tick();
    expect(getRenderJobStatus(jobId).status).toBe('error');
    expect(updateProject).toHaveBeenCalledWith(pid, settled('failed', { renderError: 'ffmpeg exit 1' }));

    // Slot now released.
    const again = await renderMusicVideo(pid);
    expect(again.jobId).not.toBe(jobId);
  });

  it('handles terminal state exactly once (a stray close after a pre-spawn error is a no-op)', async () => {
    const pid = 'once-1';
    prime(pid);
    const { jobId } = await renderMusicVideo(pid);
    const proc = lastProc();

    proc.emit('error', new Error('spawn ENOENT'));
    await tick();
    proc.emit('close', 1, null); // must not re-finalize / double-release
    await tick();

    // updateProject('failed') fired exactly once for this project.
    const failedCalls = updateProject.mock.calls.filter(
      ([id, patch]) => id === pid && patch && patch.status === 'failed',
    );
    expect(failedCalls).toHaveLength(1);
    expect(getRenderJobStatus(jobId).status).toBe('error');
  });

  it('preserves a completed project when canceled ffmpeg exits 255 without a signal', async () => {
    const pid = 'cancel-close';
    prime(pid);
    getProject.mockResolvedValue({ ...(await getProject(pid)), status: 'complete' });
    const events = [];
    const onRender = (event) => events.push(event);
    musicVideoEvents.on('render', onRender);
    const { jobId } = await renderMusicVideo(pid);
    const proc = lastProc();
    proc.emit('spawn');
    expect(cancelRender(jobId)).toBe(true);
    expect(killWithEscalation).toHaveBeenCalledWith(proc, expect.objectContaining({ label: 'music-video render' }));
    proc.emit('error', new Error('kill EPERM'));
    await tick();
    expect(getRenderJobStatus(jobId).status).toBe('running');
    expect(maintenance.status().blockers).toContainEqual(expect.objectContaining({ kind: 'music-video', resource: pid }));
    await expect(renderMusicVideo(pid)).rejects.toMatchObject({ code: 'RENDER_IN_PROGRESS' });

    proc.emit('close', 255, null);
    await tick();
    proc.emit('close', 255, null);
    await tick();
    musicVideoEvents.off('render', onRender);
    expect(getRenderJobStatus(jobId)).toEqual({ status: 'canceled', error: 'Render cancelled' });
    expect(events).toEqual([{ projectId: pid, jobId, status: 'canceled', error: 'Render cancelled' }]);
    expect(broadcastSse.mock.calls.filter(([job, frame]) => job.id === jobId && ['canceled', 'error'].includes(frame.type)))
      .toEqual([[expect.objectContaining({ id: jobId }), { type: 'canceled', error: 'Render cancelled' }]]);
    expect(updateProject.mock.calls.filter(([id, patch]) => id === pid && patch.status === 'complete')).toEqual([[pid, settled('complete')]]);
    expect(unlink).toHaveBeenCalledWith(expect.stringMatching(/music-video-.*\.mp4$/));
    expect(maintenance.status().blockers).not.toContainEqual(expect.objectContaining({ resource: pid }));
    expect(cancelRender(jobId)).toBe(false);
    const again = await renderMusicVideo(pid);
    expect(again.jobId).not.toBe(jobId);
    lastProc().emit('error', new Error('spawn ENOENT'));
    await tick();
  });

  it('retains zero-exit success when cancellation arrives just before close', async () => {
    const pid = 'cancel-success';
    prime(pid);
    const { jobId } = await renderMusicVideo(pid);
    lastProc().emit('spawn');
    expect(cancelRender(jobId)).toBe(true);
    lastProc().emit('close', 0, null);
    await tick();
    expect(getRenderJobStatus(jobId).status).toBe('complete');
    expect(updateProject).toHaveBeenCalledWith(pid, expect.objectContaining(settled('complete', { renderHistoryId: jobId })));
  });

  it('a late stray error after a successful close does not clobber the completed job', async () => {
    const pid = 'late-1';
    prime(pid);
    const { jobId } = await renderMusicVideo(pid);
    const proc = lastProc();

    proc.emit('spawn');
    proc.emit('close', 0, null); // clean success
    await tick();
    expect(getRenderJobStatus(jobId).status).toBe('complete');

    // A stray post-close 'error' (e.g. ESRCH from a kill on the dead pid) must
    // be a no-op — not overwrite lastError on the completed job.
    proc.emit('error', new Error('kill ESRCH'));
    await tick();
    expect(getRenderJobStatus(jobId).status).toBe('complete');
    expect(getRenderJobStatus(jobId).error).toBeUndefined();
  });

  it('persists a bounded finalization error while releasing the render slot', async () => {
    const pid = 'finalize-failure';
    prime(pid);
    const failure = `poster write failed ${'x'.repeat(3000)}`;
    generateThumbnail.mockRejectedValueOnce(new Error(failure));
    const { jobId } = await renderMusicVideo(pid);
    lastProc().emit('spawn');
    lastProc().emit('close', 0, null);
    await tick();

    expect(getRenderJobStatus(jobId).status).toBe('error');
    expect(updateProject).toHaveBeenCalledWith(pid, settled('failed', { renderError: `Finalize failed: ${failure}`.slice(0, 2000) }));
    const again = await renderMusicVideo(pid);
    expect(again.jobId).not.toBe(jobId);
  });
});


describe('status write failures are logged, not swallowed (#8430)', () => {
  it('logs a failed status→complete write and still finishes the job', async () => {
    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
    const pid = 'write-1';
    prime(pid);
    updateProject.mockImplementation(async (_id, patch) => {
      if (patch.status === 'complete') throw new Error('disk full');
      return {};
    });
    const { jobId } = await renderMusicVideo(pid);
    const proc = lastProc();
    proc.emit('spawn');
    proc.emit('close', 0, null);
    await tick();

    expect(getRenderJobStatus(jobId).status).toBe('complete');
    expect(errorSpy.mock.calls.some(([line]) => line.includes(jobId.slice(0, 8))
      && line.includes(pid) && line.includes('status→complete'))).toBe(true);
    updateProject.mockImplementation(async () => ({}));
    errorSpy.mockRestore();
  });
});

// Recovery re-checks each record under the store's write lock (#9010): back
// both the list and the transform with one in-memory store.
const seedStore = (records) => {
  const store = new Map(records.map((r) => [r.id, r]));
  listProjects.mockResolvedValueOnce(records);
  mutateProjectRecord.mockImplementation(async (id, transform) => {
    const outcome = transform(store.get(id));
    store.set(id, outcome.project);
    return outcome;
  });
  return store;
};
const statusOf = (store) => Object.fromEntries([...store].map(([id, p]) => [id, p.status]));

describe('recoverStuckMusicVideoRenders (#8430)', () => {
  it('demotes stale renders by history, skips live jobs and other statuses', async () => {
    const { recoverStuckMusicVideoRenders } = await import('./render.js');
    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
    prime('live-1');
    await renderMusicVideo('live-1');
    const store = seedStore([
      { id: 'done-1', status: 'rendering', renderHistoryId: 'hist-1' },
      { id: 'fresh-1', status: 'rendering' },
      { id: 'live-1', status: 'rendering' },
      { id: 'idle-1', status: 'ready' },
    ]);

    await recoverStuckMusicVideoRenders();

    expect(statusOf(store)).toEqual({ 'done-1': 'complete', 'fresh-1': 'ready', 'live-1': 'rendering', 'idle-1': 'ready' });
    expect(store.get('fresh-1')).toMatchObject({ renderingOn: null, renderPartialFilename: null });
    expect(logSpy.mock.calls.some(([line]) => line.includes('demoted 2/2'))).toBe(true);
    logSpy.mockRestore();
  });

  it('stamps the in-flight mark with this instance and the output file it is writing (#9010)', async () => {
    prime('stamp-1');
    await renderMusicVideo('stamp-1');
    expect(updateProject).toHaveBeenCalledWith('stamp-1', {
      status: 'rendering', renderingOn: 'inst-self', renderError: null, renderPartialFilename: expect.stringMatching(/^music-video-stamp-1-\d+\.mp4$/),
    });
  });

  it('leaves a peer-owned render alone, and deletes only its own partial output (#9010)', async () => {
    const { recoverStuckMusicVideoRenders } = await import('./render.js');
    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
    loadHistory.mockResolvedValue([{ id: 'r-done', filename: 'music-video-finished.mp4' }]);
    const store = seedStore([
      { id: 'mine-1', status: 'rendering', renderingOn: 'inst-self', renderPartialFilename: 'music-video-mine.mp4' },
      { id: 'peer-1', status: 'rendering', renderingOn: 'inst-peer', renderPartialFilename: 'music-video-peer.mp4' },
      { id: 'legacy-1', status: 'rendering' },
      // Its history append landed but the 'complete' write did not: the file is a finished render.
      { id: 'late-1', status: 'rendering', renderingOn: 'inst-self', renderPartialFilename: 'music-video-finished.mp4' },
      // Listed as ours, but a peer sync handed the mark over before the demotion write.
      { id: 'moved-1', status: 'rendering', renderingOn: 'inst-self', renderPartialFilename: 'music-video-moved.mp4' },
    ]);
    const listed = mutateProjectRecord.getMockImplementation();
    mutateProjectRecord.mockImplementation(async (id, transform) => {
      if (id === 'moved-1') store.set(id, { ...store.get(id), renderingOn: 'inst-peer' });
      return listed(id, transform);
    });

    await recoverStuckMusicVideoRenders();

    expect(statusOf(store)).toEqual({ 'mine-1': 'ready', 'peer-1': 'rendering', 'legacy-1': 'ready', 'late-1': 'ready', 'moved-1': 'rendering' });
    expect(store.get('peer-1')).toMatchObject({ renderingOn: 'inst-peer', renderPartialFilename: 'music-video-peer.mp4' });
    expect(unlink.mock.calls).toEqual([['/data/videos/music-video-mine.mp4']]);
    expect(logSpy.mock.calls.some(([line]) => line.includes('demoted 3/4'))).toBe(true);
    logSpy.mockRestore();
  });

  it('excerpt recovery demotes its own and legacy drafts but not a peer\'s (#9010)', async () => {
    const { recoverStuckMusicVideoExcerpts } = await import('./excerptRender.js');
    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
    const draft = (id, extra) => ({ id, status: 'rendering', jobId: id, partialFilename: `${id}.mp4`, notes: [], ...extra });
    const store = seedStore([{
      id: 'mv-x', status: 'complete', revisions: [],
      excerpts: [draft('mve-mine', { renderingOn: 'inst-self' }), draft('mve-peer', { renderingOn: 'inst-peer' }), draft('mve-legacy')],
    }]);

    await recoverStuckMusicVideoExcerpts();

    const byId = Object.fromEntries(store.get('mv-x').excerpts.map((e) => [e.id, e]));
    expect(byId['mve-mine']).toMatchObject({ status: 'error', renderingOn: null, partialFilename: null });
    expect(byId['mve-legacy']).toMatchObject({ status: 'error', partialFilename: null });
    expect(byId['mve-peer']).toMatchObject({ status: 'rendering', renderingOn: 'inst-peer', partialFilename: 'mve-peer.mp4' });
    const unlinked = unlink.mock.calls.map(([p]) => p);
    expect(unlinked).toContain('/data/videos/mve-mine.mp4');
    expect(unlinked).not.toContain('/data/videos/mve-peer.mp4');
    logSpy.mockRestore();
  });

  it('propagates a list failure instead of reporting zero recovered', async () => {
    const { recoverStuckMusicVideoRenders } = await import('./render.js');
    listProjects.mockRejectedValueOnce(new Error('DB unavailable'));
    await expect(recoverStuckMusicVideoRenders()).rejects.toThrow('DB unavailable');
    expect(mutateProjectRecord).not.toHaveBeenCalled();
  });

  it('logs a failed demotion and keeps recovering the rest', async () => {
    const { recoverStuckMusicVideoRenders } = await import('./render.js');
    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
    const store = seedStore([
      { id: 'bad-1', status: 'rendering' },
      { id: 'good-1', status: 'rendering' },
    ]);
    const listed = mutateProjectRecord.getMockImplementation();
    mutateProjectRecord.mockImplementation(async (id, transform) => {
      if (id === 'bad-1') throw new Error('write failed');
      return listed(id, transform);
    });

    await recoverStuckMusicVideoRenders();

    expect(statusOf(store)).toEqual({ 'bad-1': 'rendering', 'good-1': 'ready' });
    expect(errorSpy.mock.calls.some(([line]) => line.includes('bad-1'))).toBe(true);
    expect(logSpy.mock.calls.some(([line]) => line.includes('demoted 1/2'))).toBe(true);
    errorSpy.mockRestore();
    logSpy.mockRestore();
  });

  it('starts an interrupted shot-by-shot render again from its cached shots, a bounded number of times', async () => {
    const { recoverStuckMusicVideoRenders } = await import('./render.js');
    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
    vi.useFakeTimers({ toFake: ['setTimeout'] });
    prime('resume-1');
    getProject.mockResolvedValue({
      id: 'resume-1', name: 'P', trackId: 't1', status: 'ready',
      scenes: [{ sceneId: 's1', order: 0, videoHistoryId: 'h1' }],
      composition: { version: 1, mode: 'composed', textCues: [], style: { color: '#ffffff', font: 'sans' }, posterSec: null },
    });
    const store = seedStore([
      { id: 'resume-1', status: 'rendering', renderResume: { attempt: 0 } },
      { id: 'spent-1', status: 'rendering', renderResume: { attempt: 2 } },
      { id: 'plain-2', status: 'rendering', renderResume: null },
    ]);

    await recoverStuckMusicVideoRenders();
    expect(statusOf(store)).toEqual({ 'resume-1': 'ready', 'spent-1': 'ready', 'plain-2': 'ready' });
    expect(store.get('resume-1').renderResume).toBeNull();
    expect(seg.plans).toHaveLength(0);

    await vi.runOnlyPendingTimersAsync();
    vi.useRealTimers();
    await tick();
    expect(seg.plans.map((plan) => plan.project.id)).toEqual(['resume-1']);
    expect(updateProject).toHaveBeenCalledWith('resume-1', expect.objectContaining({ status: 'rendering', renderResume: { attempt: 1 } }));
    logSpy.mockRestore();
  });

  it('leaves no error when the render was started again before the resume ran', async () => {
    const { recoverStuckMusicVideoRenders, renderMusicVideo } = await import('./render.js');
    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
    vi.useFakeTimers({ toFake: ['setTimeout'] });
    prime('again-1');
    getProject.mockResolvedValue({
      id: 'again-1', name: 'P', trackId: 't1', status: 'ready',
      scenes: [{ sceneId: 's1', order: 0, videoHistoryId: 'h1' }],
      composition: { version: 1, mode: 'composed', textCues: [], style: { color: '#ffffff', font: 'sans' }, posterSec: null },
    });
    seedStore([{ id: 'again-1', status: 'rendering', renderResume: { attempt: 0 } }]);

    await recoverStuckMusicVideoRenders();
    await renderMusicVideo('again-1', { resumable: true });
    await vi.runOnlyPendingTimersAsync();
    vi.useRealTimers();
    await tick();
    expect(seg.plans).toHaveLength(1);
    expect(updateProject.mock.calls.some(([, patch]) => /could not restart/.test(patch?.renderError || ''))).toBe(false);
    logSpy.mockRestore();
  });
});

it('chooses the loudest section midpoint within the rendered duration', async () => {
  prime('poster-section');
  const project = await getProject();
  getProject.mockResolvedValue({ ...project, audioAnalysis: { sections: [
    { startSec: 0, endSec: 1, energy: 0.2 },
    { startSec: 1, endSec: 2, energy: 0.9 },
  ] } });
  const { jobId } = await renderMusicVideo('poster-section');
  lastProc().emit('spawn');
  lastProc().emit('close', 0, null);
  await tick();
  expect(generateThumbnail).toHaveBeenCalledWith(expect.any(String), jobId, { atSec: 1.5 });
  expect(getRenderJobStatus(jobId).status).toBe('complete');
});

// #8964 — loop semantics at the render boundary. A pre-#8964 scene (no `loop`
// key) keeps filling its authored span by repeating the clip; a planned shot
// (`loop: false`) may never silently repeat, so a span its clip cannot cover
// blocks the render with the shots to fix, and never spawns ffmpeg.
describe('renderMusicVideo clip coverage (#8964)', () => {
  const primeScene = (projectId, scene) => {
    prime(projectId);
    getProject.mockResolvedValue({
      id: projectId, name: 'P', trackId: 't1', status: 'ready',
      scenes: [{ sceneId: 's1', order: 0, videoHistoryId: 'h1', beatAligned: true, ...scene }],
    });
  };
  const filterGraph = (args) => args[args.indexOf('-filter_complex') + 1];

  it('keeps looping a legacy scene across a span longer than its clip', async () => {
    primeScene('legacy-1', { startSec: 0, endSec: 20 });
    await renderMusicVideo('legacy-1');
    const { args } = lastProc();
    expect(args.slice(0, 3)).toEqual(['-stream_loop', '-1', '-i']);
    expect(filterGraph(args)).toContain('trim=start=0:end=20');
  });

  it('refuses a non-looping shot its clip cannot cover, naming the fix, without spawning', async () => {
    primeScene('short-1', { startSec: 0, endSec: 20, loop: false });
    const expected = {
      status: 422,
      code: 'INSUFFICIENT_CLIP_COVERAGE',
      message: 'Shot 1 (18s short): longer than its clip. Hold the last frame, trim, continue, replace, or loop it before rendering',
      context: {
        shortfalls: [{ sceneId: 's1', spanSec: 20, clipSec: 2, shortBySec: 18 }],
        resolutions: ['hold', 'trim', 'continue', 'replace', 'loop'],
      },
    };
    await expect(renderMusicVideo('short-1')).rejects.toMatchObject(expected);
    expect(h.procs).toHaveLength(0);
    expect(updateProject).not.toHaveBeenCalled();
    // The slot is released: a retry re-checks coverage instead of 409ing.
    await expect(renderMusicVideo('short-1')).rejects.toMatchObject({ code: 'INSUFFICIENT_CLIP_COVERAGE' });
  });

  it('reads a covered non-looping shot once and holds its last frame over a sub-tolerance gap', async () => {
    primeScene('fit-1', { startSec: 0, endSec: 2.2, loop: false });
    await renderMusicVideo('fit-1');
    const { args } = lastProc();
    expect(args).not.toContain('-stream_loop');
    expect(filterGraph(args)).toContain('tpad=stop_mode=clone:stop_duration=0.2,trim=start=0:end=2.2');
  });

  // Uniquely catches the director's held last frame still blocking, or repeating footage.
  it('holds the last frame over a shot the director set to hold, however long the gap', async () => {
    primeScene('hold-1', { startSec: 0, endSec: 20, loop: false, holdLastFrame: true });
    await renderMusicVideo('hold-1');
    const { args } = lastProc();
    expect(args).not.toContain('-stream_loop');
    expect(filterGraph(args)).toContain('tpad=stop_mode=clone:stop_duration=18,trim=start=0:end=20');
  });

  it('repeats a shot the director explicitly set to loop', async () => {
    primeScene('loop-1', { startSec: 0, endSec: 20, loop: true });
    await renderMusicVideo('loop-1');
    const { args } = lastProc();
    expect(args).toContain('-stream_loop');
    expect(filterGraph(args)).not.toContain('tpad');
  });
});

// #8984 — a composed render captures its typography overlay before ffmpeg
// exists. The capture phase must be cancelable and terminal on its own, and a
// project whose manifest has nothing to draw must render exactly as before.
describe('composed render lifecycle (#8984)', () => {
  const cue = { id: 'c1', text: 'Hello', startSec: 0.5, endSec: 1.5, template: 'fade', placement: 'lower', emphasis: 'subtitle' };
  const primeComposed = (projectId, composition) => {
    prime(projectId);
    getProject.mockResolvedValue({
      id: projectId, name: 'P', trackId: 't1', status: 'complete',
      scenes: [{ sceneId: 's1', order: 0, videoHistoryId: 'h1' }],
      composition: { version: 1, style: { color: '#ffffff', font: 'sans' }, posterSec: null, ...composition },
    });
  };

  it('renders a concat-mode manifest through the plain path', async () => {
    primeComposed('plain-1', { mode: 'concat', textCues: [cue] });
    await renderMusicVideo('plain-1');
    expect(lastProc().args).not.toContain('-itsoffset');
  });

  it('marks a render the user started as resumable after a restart', async () => {
    primeComposed('mark-1', { mode: 'composed' });
    await renderMusicVideo('mark-1', { resumable: true });
    await tick();
    expect(updateProject).toHaveBeenCalledWith('mark-1', expect.objectContaining({ status: 'rendering', renderResume: { attempt: 0 } }));
  });

  it('cancels while shots render: no stitch, prior status restored, slot released', async () => {
    primeComposed('cancel-1', { mode: 'composed', textCues: [cue] });
    const { jobId } = await renderMusicVideo('cancel-1');
    await tick();
    expect(seg.render).toBeTruthy();
    expect(cancelRender(jobId)).toBe(true);
    await tick();
    await tick();
    expect(getRenderJobStatus(jobId).status).toBe('canceled');
    expect(seg.stitch).not.toHaveBeenCalled();
    expect(h.procs).toHaveLength(0);
    expect(updateProject).toHaveBeenLastCalledWith('cancel-1', settled('complete', { renderError: null }));
    expect(cancelRender(jobId)).toBe(false);
    const again = await renderMusicVideo('cancel-1');
    expect(again.jobId).not.toBe(jobId);
  });

  it('renders the missing shots, stitches them into the published file and honors the chosen poster frame', async () => {
    primeComposed('composed-1', { mode: 'composed', textCues: [cue], posterSec: 1 });
    const { jobId } = await renderMusicVideo('composed-1');
    await tick();
    seg.render.onProgress(0.5);
    expect(broadcastSse).toHaveBeenCalledWith(expect.anything(), { type: 'progress', progress: 0.475 });
    seg.render.resolve(0);
    await tick();
    await tick();
    await tick();
    const [plan, outputPath] = seg.stitch.mock.calls[0];
    expect(plan).toBe(seg.plans.at(-1));
    expect(outputPath.replaceAll('\\', '/')).toMatch(/^\/data\/videos\/music-video-composed/);
    expect(generateThumbnail).toHaveBeenCalledWith(outputPath, jobId, { atSec: 1 });
    expect(getRenderJobStatus(jobId).status).toBe('complete');
    expect(updateProject).toHaveBeenCalledWith('composed-1', expect.objectContaining({ status: 'complete', renderHistoryId: jobId }));
    // Nothing is left to cancel once the render has finished.
    expect(cancelRender(jobId)).toBe(false);
  });

  it('a failed shot settles the render as failed with the shot it names', async () => {
    primeComposed('composed-2', { mode: 'composed' });
    seg.stitch.mockRejectedValueOnce(new Error('Shot 2: ffmpeg failed: boom'));
    const { jobId } = await renderMusicVideo('composed-2');
    await tick();
    seg.render.resolve(0);
    await tick();
    await tick();
    expect(getRenderJobStatus(jobId)).toEqual({ status: 'error', error: 'Shot 2: ffmpeg failed: boom' });
    expect(updateProject).toHaveBeenLastCalledWith('composed-2', settled('failed', { renderError: 'Shot 2: ffmpeg failed: boom' }));
  });
});

// #8985 — per-scene visual layers. A composed render cuts a still (its
// reference frame, moved deterministically) and a code-rendered title card
// into the footage timebase without needing footage for either; a plain
// concat render ignores the layer choice entirely.
describe('layered sections (#8985)', () => {
  const layeredScenes = [
    { sceneId: 's1', order: 0, videoHistoryId: 'h1' },
    { sceneId: 's2', order: 1, visualLayer: 'still', stillMove: 'pan', referenceImageId: 'frame.png', videoHistoryId: 'h1', startSec: 2, endSec: 4 },
    { sceneId: 's3', order: 2, visualLayer: 'card', cardText: 'Verse two', cardColor: '#112233', videoHistoryId: null, startSec: 4, endSec: 5.01 },
  ];
  const primeLayered = (projectId, mode, scenes = layeredScenes) => {
    prime(projectId);
    getProject.mockResolvedValue({
      id: projectId, name: 'P', trackId: 't1', status: 'ready', scenes,
      composition: { version: 1, mode, textCues: [], style: { color: '#ffffff', font: 'sans' }, posterSec: null },
    });
  };
  const filterGraph = (args) => args[args.indexOf('-filter_complex') + 1];

  it('keeps a concat render on footage only: the still scene plays its clip and the footage-less card is skipped', async () => {
    primeLayered('plain-layers', 'concat');
    await renderMusicVideo('plain-layers');
    const { args } = lastProc();
    expect(args).not.toContain('/data/images/frame.png');
    expect(filterGraph(args)).not.toContain('color=');
    expect(filterGraph(args)).toContain('concat=n=2:v=1:a=0[outv]');
  });

  it('refuses a still with no reference frame and an untimed card, without spawning', async () => {
    primeLayered('no-frame', 'composed', [{ sceneId: 's1', order: 0, visualLayer: 'still', referenceImageId: null, startSec: 0, endSec: 2 }]);
    await expect(renderMusicVideo('no-frame')).rejects.toMatchObject({ status: 404, code: 'MISSING_STILLS', context: { sceneIds: ['s1'] } });
    primeLayered('untimed', 'composed', [{ sceneId: 's1', order: 0, visualLayer: 'card', cardText: 'Hi', startSec: null, endSec: null }]);
    await expect(renderMusicVideo('untimed')).rejects.toMatchObject({ status: 422, code: 'UNTIMED_SECTIONS', context: { sceneIds: ['s1'] } });
    expect(h.procs).toHaveLength(0);
  });
});

// The film look finishing pass (filmLookFinish.js) runs between a zero-exit
// encode and publication: the job stays cancellable through it and its failure
// settles the render like an encode failure.
const look = vi.hoisted(() => ({ calls: [], resolve: null, reject: null }));
vi.mock('./filmLookFinish.js', () => ({
  filmLookFinishNeeded: (project) => !!project?.filmLook,
  applyFilmLookFinish: (options) => new Promise((resolve, reject) => {
    look.calls.push(options);
    look.resolve = resolve;
    look.reject = reject;
    options.signal.addEventListener('abort', () => reject(new Error('aborted')), { once: true });
  }),
}));

describe('film look finishing pass on a footage render', () => {
  const primeLook = (pid, status = 'ready') => {
    prime(pid);
    getProject.mockResolvedValue({
      id: pid, name: 'P', trackId: 't1', status, filmLook: { preset: 'super8', grain: 0.5 },
      scenes: [{ sceneId: 's1', order: 0, videoHistoryId: 'h1' }],
    });
  };
  const encodeDone = async (proc) => {
    proc.emit('spawn');
    proc.stderr.emit('data', 'progress=end\n');
    proc.emit('close', 0, null);
    await tick();
  };
  beforeEach(() => { look.calls.length = 0; });

  it('runs the pass over the encoded file after a zero exit, holding publication and the progress bar for it', async () => {
    const pid = 'look-1';
    primeLook(pid);
    const { jobId } = await renderMusicVideo(pid);
    await encodeDone(lastProc());
    // The encode's end is the middle of the bar; the pass fills the rest.
    expect(broadcastSse).toHaveBeenCalledWith(expect.anything(), { type: 'progress', progress: 0.5 });
    expect(look.calls).toHaveLength(1);
    expect(look.calls[0]).toMatchObject({ jobId, path: lastProc().args.at(-1), project: expect.objectContaining({ id: pid }) });
    expect(getRenderJobStatus(jobId).status).toBe('running');
    expect(updateProject).not.toHaveBeenCalledWith(pid, expect.objectContaining({ status: 'complete' }));
    look.calls[0].onProgress(0.5);
    expect(broadcastSse).toHaveBeenCalledWith(expect.anything(), { type: 'progress', progress: 0.75 });
    look.resolve(true);
    await tick();
    await tick();
    expect(getRenderJobStatus(jobId).status).toBe('complete');
    expect(updateProject).toHaveBeenCalledWith(pid, expect.objectContaining({ status: 'complete', renderHistoryId: jobId }));
    expect(broadcastSse).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({ type: 'complete' }));
  });

  it('a cancel during the pass aborts it, removes the file and restores the prior status', async () => {
    const pid = 'look-2';
    primeLook(pid, 'complete');
    const { jobId } = await renderMusicVideo(pid);
    await encodeDone(lastProc());
    expect(look.calls).toHaveLength(1);
    expect(cancelRender(jobId)).toBe(true);
    await tick();
    await tick();
    expect(look.calls[0].signal.aborted).toBe(true);
    expect(getRenderJobStatus(jobId).status).toBe('canceled');
    expect(unlink).toHaveBeenCalledWith(look.calls[0].path);
    expect(updateProject).toHaveBeenCalledWith(pid, settled('complete'));
    expect(broadcastSse).toHaveBeenCalledWith(expect.anything(), { type: 'canceled', error: 'Render cancelled' });
    // Slot released: a new render starts.
    expect((await renderMusicVideo(pid)).jobId).not.toBe(jobId);
  });

  it('a failed pass settles the render as failed, naming the pass', async () => {
    const pid = 'look-3';
    primeLook(pid);
    const { jobId } = await renderMusicVideo(pid);
    await encodeDone(lastProc());
    look.reject(new Error('no browser'));
    await tick();
    await tick();
    expect(getRenderJobStatus(jobId)).toEqual({ status: 'error', error: 'Film look pass failed: no browser' });
    expect(unlink).toHaveBeenCalledWith(look.calls[0].path);
    expect(updateProject).toHaveBeenCalledWith(pid, settled('failed', { renderError: 'Film look pass failed: no browser' }));
  });
});