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

Prevent pool deletion from removing selected music-video media (#11529)

[._.]/c21e8810db6b
diff --git a/server/lib/backupAssetOwners.js b/server/lib/backupAssetOwners.js
index 0203f3f0e2..eb28d93105 100644
--- a/server/lib/backupAssetOwners.js
+++ b/server/lib/backupAssetOwners.js
@@ -48,6 +48,7 @@ export const BACKUP_ASSET_OWNERS = Object.freeze([
{ id: 'gallery-image-workflows', status: 'admitted', modules: ['services/imageGen/local.js'] },
{ id: 'gallery-image-deletion-canon-purge', status: 'admitted', modules: ['services/galleryImageDeletion.js'] },
{ id: 'video-history-deletion', status: 'admitted', modules: ['services/videoGen/historyOps.js'] },
+ { id: 'music-video-pool-deletion', status: 'admitted', modules: ['services/musicVideo/mediaPool.js'] },
{
id: 'lora-dataset-workflows',
status: 'admitted',
diff --git a/server/routes/musicVideoAudioTiming.test.js b/server/routes/musicVideoAudioTiming.test.js
index 3c1bb8de7a..9657d3d641 100644
--- a/server/routes/musicVideoAudioTiming.test.js
+++ b/server/routes/musicVideoAudioTiming.test.js
@@ -28,6 +28,7 @@ const post = (id, action, body) => request(app).post(`/api/music-video/${id}/aud
async function fixture({ legacy = false } = {}) {
mkdirSync(join(ROOT(), 'music'), { recursive: true });
+ writeFileSync(join(ROOT(), 'video-history.json'), JSON.stringify(['clip-a', 'clip-b'].map(id => ({ id, filename: `${id}.mp4` }))));
for (const name of ['old', 'insert', 'delete']) writeFileSync(join(ROOT(), 'music', `${name}.wav`), `${name}-synthetic-audio`);
const project = await projects.createProject({ name: 'Example timing project', trackId: 'old' });
await projects.mutateProjectRecord(project.id, (p) => ({ project: { ...p,
diff --git a/server/routes/musicVideoAutoReview.test.js b/server/routes/musicVideoAutoReview.test.js
index 794ec43cc5..030733fea7 100644
--- a/server/routes/musicVideoAutoReview.test.js
+++ b/server/routes/musicVideoAutoReview.test.js
@@ -188,6 +188,11 @@ const start = (projectId, limits) => request(app).post(`${base(projectId)}/auto-
beforeEach(() => {
rmSync(join(ROOT(), 'music-video-projects.json'), { force: true });
+ mkdirSync(join(ROOT(), 'images'), { recursive: true });
+ for (const file of ['f1.png', 'f2.png', 'still-3.png', 'frame.png']) writeFileSync(join(ROOT(), 'images', file), 'synthetic still');
+ writeFileSync(join(ROOT(), 'video-history.json'), JSON.stringify(
+ ['clip-1', 'clip-2', 'clip-2b', 'another-take', 'accepted'].map(id => ({ id, filename: `${id}.mp4` })),
+ ));
h.procs.length = 0;
h.jobs.length = 0;
h.verdicts.length = 0;
diff --git a/server/routes/musicVideoRevision.test.js b/server/routes/musicVideoRevision.test.js
index 2fc75ef074..0304995232 100644
--- a/server/routes/musicVideoRevision.test.js
+++ b/server/routes/musicVideoRevision.test.js
@@ -92,6 +92,11 @@ const settledProject = (projectId, check) => vi.waitFor(async () => {
beforeEach(() => {
rmSync(join(ROOT(), 'music-video-projects.json'), { force: true });
+ mkdirSync(join(ROOT(), 'images'), { recursive: true });
+ for (const file of ['f1.png', 'f2.png', 'still-3.png', 'frame.png']) writeFileSync(join(ROOT(), 'images', file), 'synthetic still');
+ writeFileSync(join(ROOT(), 'video-history.json'), JSON.stringify(
+ ['clip-1', 'clip-2', 'clip-2b', 'another-take', 'accepted'].map(id => ({ id, filename: `${id}.mp4` })),
+ ));
h.procs.length = 0;
h.jobs.length = 0;
vi.clearAllMocks();
diff --git a/server/routes/musicVideoSceneSplit.test.js b/server/routes/musicVideoSceneSplit.test.js
index 8dfd5f8ed8..83ae9f6e87 100644
--- a/server/routes/musicVideoSceneSplit.test.js
+++ b/server/routes/musicVideoSceneSplit.test.js
@@ -37,7 +37,7 @@ beforeEach(async () => {
rmSync(join(ROOT(), 'music-video-projects.json'), { force: true });
mkdirSync(join(ROOT(), 'images'), { recursive: true });
writeFileSync(join(ROOT(), 'images', 'singer.png'), 'png-bytes');
- writeFileSync(join(ROOT(), 'video-history.json'), JSON.stringify([]));
+ writeFileSync(join(ROOT(), 'video-history.json'), JSON.stringify(['clip-whole-verse', 'clip-bridge'].map(id => ({ id, filename: `${id}.mp4` }))));
project = await projects.createProject({ name: 'Example Video' });
await projects.updateProject(project.id, { lyricCues: LYRICS, videoSettings: { backend: 'fal' } });
});
diff --git a/server/routes/musicVideoSongRevision.test.js b/server/routes/musicVideoSongRevision.test.js
index 7413982d20..688c9cbb41 100644
--- a/server/routes/musicVideoSongRevision.test.js
+++ b/server/routes/musicVideoSongRevision.test.js
@@ -1,5 +1,7 @@
import { describe, it, expect, vi, afterAll, afterEach } from 'vitest';
import express from 'express';
+import { mkdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
import { request } from '../lib/testHelper.js';
import { errorMiddleware } from '../lib/errorHandler.js';
import { makePathsProxy, lazyTempDataRoot, cleanupTempDataRoots } from '../lib/mockPathsDataRoot.js';
@@ -17,7 +19,13 @@ const app = express();
app.use(express.json()); app.use('/api/music-video', routes); app.use(errorMiddleware);
const fields = { title: 'Example song', style: 'Bright synth pop', lyrics: '[Verse]\nA new morning', instrumental: false };
const post = (id, action = '', body = {}) => request(app).post(`/api/music-video/${id}/song-revision${action ? `/${action}` : ''}`).send(body);
+function seedArt() {
+ const images = join(lazyTempDataRoot('mv-song-revision-test-'), 'images');
+ mkdirSync(images, { recursive: true });
+ for (const file of ['art.png', 'intro.png']) writeFileSync(join(images, file), 'synthetic still');
+}
async function fixture() {
+ seedArt();
const source = await store.createProject({ name: 'Example video', uploadedAudioFilename: 'original.m4a', composition: { mode: 'code' } });
await store.mutateProjectRecord(source.id, (p) => {
const project = { ...p, status: 'complete', lyricCues: [{ id: 'cue-a', text: 'Old morning', startSec: 1, endSec: 2 }],
@@ -141,6 +149,7 @@ describe('revise the song from an imported track', () => {
lyrics: '[Verse]\nLine a\nA brand new line\nLine b' };
const timed = (project, times) => project.lyricCues.map((cue, i) => ({ ...cue, startSec: times[i][0], endSec: times[i][1] }));
async function source() {
+ seedArt();
const project = await store.createProject({ name: 'Example video', uploadedAudioFilename: 'original.m4a' });
await store.mutateProjectRecord(project.id, (p) => ({ project: { ...p, status: 'complete', audioAnalysis: { durationSec: 30 },
lyricCues: [{ id: 'cue-a', text: 'Line a', startSec: 10, endSec: 14 }, { id: 'cue-x', text: 'Old middle line', startSec: 14, endSec: 18 },
diff --git a/server/routes/musicVideoTakes.test.js b/server/routes/musicVideoTakes.test.js
index 5a7a77843f..80f0116851 100644
--- a/server/routes/musicVideoTakes.test.js
+++ b/server/routes/musicVideoTakes.test.js
@@ -9,12 +9,35 @@
import { describe, it, expect, vi, beforeEach, afterAll } from 'vitest';
import express from 'express';
-import { mkdirSync, rmSync, writeFileSync } from 'fs';
+import { mkdirSync, rmSync, writeFileSync, existsSync } from 'fs';
import { join } from 'path';
import { request } from '../lib/testHelper.js';
import { errorMiddleware } from '../lib/errorHandler.js';
import { makePathsProxy, lazyTempDataRoot, cleanupTempDataRoots } from '../lib/mockPathsDataRoot.js';
+const race = vi.hoisted(() => ({ beforeDelete: null, beforeSave: null, onRequest: null }));
+vi.mock('../services/galleryImageDeletion.js', async (original) => {
+ const actual = await original();
+ return { ...actual, deleteGalleryImage: async (...args) => {
+ await race.beforeDelete?.(...args);
+ return actual.deleteGalleryImage(...args);
+ } };
+});
+vi.mock('../services/videoGen/historyOps.js', async (original) => {
+ const actual = await original();
+ return { ...actual, deleteHistoryItem: async (...args) => {
+ await race.beforeDelete?.(...args);
+ return actual.deleteHistoryItem(...args);
+ } };
+});
+vi.mock('../lib/fileUtils.js', async (original) => {
+ const actual = await original();
+ return { ...actual, atomicWrite: async (...args) => {
+ if (args[0].endsWith('music-video-projects.json')) await race.beforeSave?.(args[1]);
+ return actual.atomicWrite(...args);
+ } };
+});
+
const ROOT = () => lazyTempDataRoot('mv-takes-route-test-');
vi.mock('../lib/paths.js', async (importOriginal) => makePathsProxy(await importOriginal(), { dataRoot: ROOT }));
vi.mock('../services/settings.js', () => ({ getSettings: vi.fn(async () => ({})) }));
@@ -24,6 +47,7 @@ const projects = await import('../services/musicVideo/projects.js');
const app = express();
app.use(express.json());
+app.use((req, res, next) => { race.onRequest?.(req); next(); });
app.use('/api/music-video', musicVideoRoutes);
app.use(errorMiddleware);
@@ -39,6 +63,7 @@ let project;
let sceneA;
let sceneB;
beforeEach(async () => {
+ race.beforeDelete = race.beforeSave = race.onRequest = null;
rmSync(join(ROOT(), 'music-video-projects.json'), { force: true });
rmSync(join(ROOT(), 'images'), { recursive: true, force: true });
seedVideoHistory([]);
@@ -107,7 +132,9 @@ describe('scene takes routes', () => {
it('materializes a pre-takes selection as a legacy take instead of losing it', async () => {
// A pre-#8965 scene: a selected frame with no takes list at all.
+ seedImage('legacy.png');
await projects.updateScene(project.id, sceneB.sceneId, { referenceImageId: 'legacy.png' });
+ rmSync(join(ROOT(), 'images', 'legacy.png')); // legacy records may outlive their bytes
const raw = await reload();
// updateScene records the slot as a take; strip it to model an old record.
const { mergeProjectsFromSync } = projects;
@@ -514,3 +541,139 @@ describe('a shot\'s frame references', () => {
expect(musicVideoConditioningReferences(await reload(), await sceneOf()).map((ref) => ref.id)).toEqual(['lead']);
});
});
+
+
+function barrier() {
+ let entered;
+ let release;
+ const reached = new Promise(resolve => { entered = resolve; });
+ const resumed = new Promise(resolve => { release = resolve; });
+ return { reached, release, wait: async () => { entered(); await resumed; } };
+}
+
+// Each combination catches a different deletion lane or all-project scan.
+describe('pool deletion and selection admission', () => {
+ async function seedRace(kind, anotherProject) {
+ const assetId = kind === 'image' ? 'race.png' : 'race-clip';
+ const keep = kind === 'image' ? 'keep.png' : 'keep-clip';
+ const field = kind === 'image' ? 'referenceImageId' : 'videoHistoryId';
+ if (kind === 'image') {
+ seedImage(assetId);
+ seedImage(keep);
+ } else {
+ mkdirSync(join(ROOT(), 'videos'), { recursive: true });
+ for (const id of [assetId, keep]) writeFileSync(join(ROOT(), 'videos', `${id}.mp4`), 'synthetic clip');
+ seedVideoHistory([assetId, keep].map(id => ({ id, filename: `${id}.mp4` })));
+ }
+ await addTake(sceneA.sceneId, { kind, assetId: keep });
+ const candidate = await addTake(sceneA.sceneId, { kind, assetId });
+ let owner = project;
+ let shot = sceneA;
+ let take = candidate.body.take;
+ if (anotherProject) {
+ owner = await projects.createProject({ name: 'Other synthetic project' });
+ shot = await projects.addProjectScene(owner.id, { prompt: 'Another shot' });
+ await projects.appendSceneTakes(owner.id, shot.sceneId, [{ kind, assetId: keep }]);
+ take = (await projects.appendSceneTakes(owner.id, shot.sceneId, [{ kind, assetId }])).appended[0];
+ }
+ const path = `/api/music-video/${owner.id}/scenes/${shot.sceneId}`;
+ const select = () => request(app).post(`${path}/takes/${take.takeId}/select`).then(value => value);
+ const remove = () => request(app).post(`${base()}/media-pool/delete`).send({ items: [{ kind, assetId }] }).then(value => value);
+ const bytes = () => existsSync(join(ROOT(), kind === 'image' ? 'images' : 'videos', kind === 'image' ? assetId : `${assetId}.mp4`));
+ const selected = async () => (await projects.getProject(owner.id)).scenes.find(scene => scene.sceneId === shot.sceneId)[field];
+ return { assetId, keep, field, owner, shot, path, select, remove, bytes, selected };
+ }
+
+ it.each([['image', false], ['video', false], ['image', true], ['video', true]])(
+ 'keeps a %s selected before deletion (other project: %s)', async (kind, anotherProject) => {
+ const fixture = await seedRace(kind, anotherProject);
+ const gate = barrier();
+ race.beforeSave = async rows => {
+ if (rows.some(row => row.id === fixture.owner.id && row.scenes.some(scene => scene[fixture.field] === fixture.assetId))) {
+ race.beforeSave = null;
+ await gate.wait();
+ }
+ };
+ const selection = fixture.select();
+ await gate.reached;
+ const arrived = barrier();
+ race.onRequest = req => { if (req.path.endsWith('/media-pool/delete')) arrived.release(); };
+ const deletion = fixture.remove();
+ // Wait until HTTP deletion has arrived while selection owns the store tail.
+ await arrived.wait();
+ gate.release();
+ expect((await selection).status).toBe(200);
+ const refused = await deletion;
+ expect(refused.status).toBe(409);
+ expect(refused.body.code).toBe('POOL_ASSET_IN_USE');
+ expect(await fixture.selected()).toBe(fixture.assetId);
+ expect(fixture.bytes()).toBe(true);
+ },
+ );
+
+ it.each([['image', false], ['video', false], ['image', true], ['video', true]])(
+ 'refuses selection after admitted %s deletion (other project: %s)', async (kind, anotherProject) => {
+ const fixture = await seedRace(kind, anotherProject);
+ const gate = barrier();
+ race.beforeDelete = gate.wait;
+ const deletion = fixture.remove();
+ await gate.reached;
+ const arrived = barrier();
+ race.onRequest = req => { if (req.path.endsWith('/select')) arrived.release(); };
+ const selection = fixture.select();
+ // An unrelated project edit must survive the file-wide cleanup too.
+ const edit = projects.updateProject(fixture.owner.id, { name: 'Concurrent title' });
+ await arrived.wait();
+ gate.release();
+ expect((await deletion).status).toBe(200);
+ expect((await selection).status).toBe(404); // cleanup removed the now-missing take
+ await edit;
+ expect(await fixture.selected()).toBe(fixture.keep);
+ expect(fixture.bytes()).toBe(false);
+ expect((await projects.getProject(fixture.owner.id)).name).toBe('Concurrent title');
+ // Direct slot writes and reused/generated/imported completions also see
+ // the missing local asset inside admission, even after route preflight.
+ const direct = await request(app).patch(fixture.path).send({ [fixture.field]: fixture.assetId });
+ expect(direct.status).toBe(400);
+ expect(direct.body.code).toBe('TAKE_ASSET_NOT_FOUND');
+ await expect(projects.placeMediaPoolItem(fixture.owner.id, fixture.shot.sceneId, { kind, assetId: fixture.assetId }))
+ .rejects.toMatchObject({ code: 'TAKE_ASSET_NOT_FOUND' });
+ await projects.updateScene(fixture.owner.id, fixture.shot.sceneId, { [fixture.field]: null });
+ for (const source of ['generated', 'imported']) {
+ await expect(projects.appendSceneTakes(fixture.owner.id, fixture.shot.sceneId, [{ kind, assetId: fixture.assetId, source }]))
+ .rejects.toMatchObject({ code: 'TAKE_ASSET_NOT_FOUND' });
+ }
+ await expect(projects.appendTakesAcrossScenes(fixture.owner.id, [{ sceneId: fixture.shot.sceneId, kind, assetId: fixture.assetId }]))
+ .rejects.toMatchObject({ code: 'TAKE_ASSET_NOT_FOUND' });
+ expect(await fixture.selected()).toBeNull();
+ },
+ );
+
+ it('cleans a completed batch prefix after failure and keeps the failed asset and evidence', async () => {
+ seedImage('keep.png');
+ seedImage('deleted.png');
+ seedImage('failed.png');
+ await addTake(sceneA.sceneId, { kind: 'image', assetId: 'keep.png' });
+ await addTake(sceneA.sceneId, { kind: 'image', assetId: 'deleted.png' });
+ await addTake(sceneA.sceneId, { kind: 'image', assetId: 'failed.png' });
+ const items = ['deleted.png', 'failed.png'].map(assetId => ({ kind: 'image', assetId }));
+ await request(app).patch(`${base()}/media-pool/marks`).send({ items, mark: 'bad' });
+ seedImage('outside.png');
+ for (const assetId of ['keep.png', 'outside.png']) {
+ const refused = await request(app).post(`${base()}/media-pool/delete`).send({ items: [items[0], { kind: 'image', assetId }] });
+ expect(refused.status).toBe(409);
+ expect(refused.body.code).toBe('POOL_ASSET_IN_USE');
+ expect(existsSync(join(ROOT(), 'images', 'deleted.png'))).toBe(true);
+ }
+ race.beforeDelete = async id => { if (id === 'failed.png') throw new Error('Synthetic deletion failure'); };
+ const result = await request(app).post(`${base()}/media-pool/delete`).send({ items });
+ expect(result.status).toBe(500);
+ expect(existsSync(join(ROOT(), 'images', 'deleted.png'))).toBe(false);
+ expect(existsSync(join(ROOT(), 'images', 'failed.png'))).toBe(true);
+ const stored = await reload();
+ expect(stored.scenes[0].takes.map(take => take.assetId)).toEqual(['keep.png', 'failed.png']);
+ expect(stored.assetMarks).toEqual({ 'image:failed.png': 'bad' });
+ await projects.updateProject(project.id, { name: 'Queue recovered' });
+ expect((await reload()).name).toBe('Queue recovered');
+ });
+});
diff --git a/server/services/musicVideo/documentGeneration.test.js b/server/services/musicVideo/documentGeneration.test.js
index 8c35ce4933..2bdcfb60b4 100644
--- a/server/services/musicVideo/documentGeneration.test.js
+++ b/server/services/musicVideo/documentGeneration.test.js
@@ -1,7 +1,7 @@
// Creative approval behavior is covered through production review routes and orchestration.
vi.mock('./productionReview.js', async (load) => ({ ...await load(), assertProductionApproval: vi.fn() }));
import { afterAll, beforeEach, describe, expect, it, vi } from 'vitest';
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { mkdir, readFile, writeFile, unlink } from 'node:fs/promises';
import { join } from 'node:path';
import { cleanupTempDataRoots, lazyTempDataRoot, makePathsProxy } from '../../lib/mockPathsDataRoot.js';
@@ -356,7 +356,9 @@ describe('treatment-driven mixed-media document authoring', () => {
it('preflights selected media before a provider call and stages a reviewable 30-second document', async () => {
const id = await fixture();
const original = await projects.getProject(id);
+ await writeFile(join(PATHS.images, 'missing.png'), 'synthetic still');
await projects.mutateProjectRecord(id, (current) => ({ project: { ...current, scenes: current.scenes.map((s) => s.sceneId === 's-still' ? { ...s, referenceImageId: 'missing.png' } : s) } }));
+ await unlink(join(PATHS.images, 'missing.png')); // model a legacy selection whose file was removed
await expect(generateMixedMediaDocument(id)).rejects.toMatchObject({ code: 'COMPOSITION_MEDIA_MISSING' });
expect(h.calls).toBe(0);
await projects.mutateProjectRecord(id, (current) => ({ project: { ...current, scenes: original.scenes } }));
diff --git a/server/services/musicVideo/documentRender.browser.test.js b/server/services/musicVideo/documentRender.browser.test.js
index 56b625b935..a6aa9bd28e 100644
--- a/server/services/musicVideo/documentRender.browser.test.js
+++ b/server/services/musicVideo/documentRender.browser.test.js
@@ -534,11 +534,11 @@ describe.skipIf(!canRun)('layered template with real Chrome and ffmpeg', () => {
const master = join(PATHS.music, 'timed-master.wav');
execFileSync(ffmpeg, ['-v', 'error', '-y', '-f', 'lavfi', '-i', 'sine=frequency=220:duration=1.5', master]);
const created = await projects.createProject({ name: 'Synthetic shot timing' });
+ await writeFile(join(PATHS.data, 'video-history.json'), JSON.stringify([{ id: 'vh-timed', filename: 'timed-rgb.webm', numFrames: 36, fps: 24, width: 64, height: 36 }]));
await projects.mutateProjectRecord(created.id, current => ({ project: { ...current,
audioAnalysis: { durationSec: 1.5, sections: [] },
scenes: [{ sceneId: 'timed', startSec: 0, endSec: 1.5, videoHistoryId: 'vh-timed', ...timing }],
} }));
- await writeFile(join(PATHS.data, 'video-history.json'), JSON.stringify([{ id: 'vh-timed', filename: 'timed-rgb.webm', numFrames: 36, fps: 24, width: 64, height: 36 }]));
await importDocumentTemplate(created.id);
const project = await projects.getProject(created.id);
const outputPath = join(PATHS.videos, 'timed-output.mp4');
@@ -567,11 +567,11 @@ describe.skipIf(!canRun)('layered template with real Chrome and ffmpeg', () => {
'-f', 'lavfi', '-i', 'color=c=blue:s=64x36:r=24:d=0.5',
'-filter_complex', '[0:v][1:v][2:v]concat=n=3:v=1:a=0', '-c:v', 'libvpx', clip]);
const created = await projects.createProject({ name: 'Synthetic live shot timing' });
+ await writeFile(join(PATHS.data, 'video-history.json'), JSON.stringify([{ id: 'vh-live', filename: 'live-timed-rgb.webm', numFrames: 36, fps: 24, width: 64, height: 36 }]));
await projects.mutateProjectRecord(created.id, current => ({ project: { ...current,
audioAnalysis: { durationSec: 1.5, sections: [] },
scenes: [{ sceneId: 'timed', startSec: 0, endSec: 1.5, videoHistoryId: 'vh-live', ...timing }],
} }));
- await writeFile(join(PATHS.data, 'video-history.json'), JSON.stringify([{ id: 'vh-live', filename: 'live-timed-rgb.webm', numFrames: 36, fps: 24, width: 64, height: 36 }]));
await importDocumentTemplate(created.id);
const preview = await buildDocumentPreview(await projects.getProject(created.id));
const page = await browser.newPage();
@@ -612,12 +612,12 @@ describe.skipIf(!canRun)('layered template with real Chrome and ffmpeg', () => {
const master = join(PATHS.music, 'master.wav');
execFileSync(ffmpeg, ['-v', 'error', '-y', '-f', 'lavfi', '-i', 'sine=frequency=220:duration=6', master]);
const created = await projects.createProject({ name: 'Excerpt' });
+ await writeFile(join(PATHS.data, 'video-history.json'), JSON.stringify([{ id: 'vh-rgb', filename: 'rgb.webm', numFrames: 72, fps: 24, width: 640, height: 360 }]));
await projects.mutateProjectRecord(created.id, (current) => ({ project: {
...current,
audioAnalysis: { durationSec: 6, beats: [], downbeats: [], sections: [] },
scenes: [{ sceneId: 'rgb', order: 0, startSec: 0, endSec: 3, videoHistoryId: 'vh-rgb' }],
} }));
- await writeFile(join(PATHS.data, 'video-history.json'), JSON.stringify([{ id: 'vh-rgb', filename: 'rgb.webm', numFrames: 72, fps: 24, width: 640, height: 360 }]));
await importDocumentTemplate(created.id);
const project = await projects.getProject(created.id);
const plan = await prepareDocumentRender(project);
@@ -870,6 +870,7 @@ describe.skipIf(!canRun)('layered template with real Chrome and ffmpeg', () => {
const master = join(PATHS.music, 'generated-master.wav');
execFileSync(ffmpeg, ['-v', 'error', '-y', '-f', 'lavfi', '-i', 'sine=frequency=220:duration=3', master]);
const created = await projects.createProject({ name: 'Generated Example' });
+ await writeFile(join(PATHS.data, 'video-history.json'), JSON.stringify([{ id: 'vh-generated', filename: 'generated-rgb.webm', numFrames: 72, fps: 24, width: 640, height: 360 }]));
await projects.mutateProjectRecord(created.id, (current) => ({ project: {
...current,
audioAnalysis: { durationSec: 3, beats: [0, 1, 2], downbeats: [0, 1, 2], sections: [
@@ -889,7 +890,6 @@ describe.skipIf(!canRun)('layered template with real Chrome and ffmpeg', () => {
] },
],
} }));
- await writeFile(join(PATHS.data, 'video-history.json'), JSON.stringify([{ id: 'vh-generated', filename: 'generated-rgb.webm', numFrames: 72, fps: 24, width: 640, height: 360 }]));
author.calls = 0;
const staged = await generateMixedMediaDocument(created.id);
expect(author.calls).toBe(1);
diff --git a/server/services/musicVideo/mediaModes.test.js b/server/services/musicVideo/mediaModes.test.js
index 2e3fe9897e..a79cb78a4b 100644
--- a/server/services/musicVideo/mediaModes.test.js
+++ b/server/services/musicVideo/mediaModes.test.js
@@ -33,6 +33,8 @@ describe('whole-workflow media modes', () => {
const project = await projects.createProject({ name: 'Example', mediaMode: 'code-images' });
const scene = await projects.addProjectScene(project.id, { label: 'Scene' });
await expect(projects.updateScene(project.id, scene.sceneId, { videoHistoryId: 'video-example' })).rejects.toMatchObject({ code: 'MUSIC_VIDEO_MEDIA_POLICY' });
+ await mkdir(PATHS.images, { recursive: true });
+ await writeFile(join(PATHS.images, 'example.png'), 'synthetic still');
await projects.updateScene(project.id, scene.sceneId, { referenceImageId: 'example.png' });
await expect(projects.updateProject(project.id, { mediaMode: 'code-only' })).rejects.toMatchObject({ code: 'MUSIC_VIDEO_MEDIA_POLICY' });
expect((await projects.getProject(project.id)).scenes[0].referenceImageId).toBe('example.png');
diff --git a/server/services/musicVideo/mediaPool.js b/server/services/musicVideo/mediaPool.js
index 3243a8bcf1..9d6d207abd 100644
--- a/server/services/musicVideo/mediaPool.js
+++ b/server/services/musicVideo/mediaPool.js
@@ -106,6 +106,26 @@ function forgetPoolAssets(project, keys) {
const usedKeys = (project) => new Set((project?.scenes || []).flatMap((scene) => Object.entries(TAKE_SLOT)
.map(([slot, field]) => (scene[field] ? `${KIND_OF_SLOT[slot]}:${scene[field]}` : null)).filter(Boolean)));
+/** Revalidate newly selected local media while project mutation admission is held.
+ * Existing missing selections and peer-qualified references retain their legacy semantics.
+ */
+export async function assertNewMediaSelections(before, after) {
+ const previous = usedKeys(before);
+ const added = [...usedKeys(after)].filter(key => !previous.has(key));
+ if (!added.length) return;
+ const [{ resolveGalleryImage }, { getHistoryItem }, { ServerError }] = await Promise.all([
+ import('../../lib/pathSafety.js'), import('../videoGen/history.js'), import('../../lib/errorHandler.js'),
+ ]);
+ for (const key of added) {
+ const separator = key.indexOf(':');
+ const kind = key.slice(0, separator);
+ const assetId = key.slice(separator + 1);
+ if (assetId.includes(':') || assetId.includes('/')) continue;
+ const exists = kind === 'image' ? resolveGalleryImage(assetId) : await getHistoryItem(assetId);
+ if (!exists) throw new ServerError(`${kind === 'image' ? 'Image' : 'Video'} not found in this install's media library`, { status: 400, code: 'TAKE_ASSET_NOT_FOUND' });
+ }
+}
+
/** Each `<kind>:<id>` a shot uses now, mapped to the shots using it (still, clip or end frame slot), in board order. */
const shotsUsing = (project) => {
const using = new Map();
@@ -256,7 +276,7 @@ export async function searchMusicVideoMediaPool(project, query) {
* takes, marks, collection rows), in one pass per project, so nothing points
* at a file that is gone. Best-effort, like the other filing.
*/
-export async function forgetDeletedMusicVideoAssets(keys) {
+export async function forgetDeletedMusicVideoAssets(keys, { mutateProjectRecord: admittedMutation } = {}) {
const gone = new Set(keys);
try {
const [{ listProjects, mutateProjectRecord }, { getCollection, musicVideoCollectionId, bulkUpdateCollectionItems }] = await Promise.all([
@@ -266,7 +286,7 @@ export async function forgetDeletedMusicVideoAssets(keys) {
const held = Object.keys(project.assetMarks || {}).some((key) => gone.has(key))
|| (project.scenes || []).some((scene) => (scene.takes || []).some((take) => gone.has(`${KIND_OF_SLOT[take?.kind]}:${take?.assetId}`)));
// The take removal files dropped takes into the collection, so the rows go after it.
- if (held) await mutateProjectRecord(project.id, (current) => forgetPoolAssets(current, keys));
+ if (held) await (admittedMutation || mutateProjectRecord)(project.id, (current) => forgetPoolAssets(current, keys));
const collection = await getCollection(musicVideoCollectionId(project.id)).catch(() => null);
const rows = (collection?.items || []).map((item) => `${item.kind}:${item.ref}`).filter((key) => gone.has(key));
if (rows.length) await bulkUpdateCollectionItems(collection.id, { remove: rows });
@@ -283,22 +303,36 @@ export async function forgetDeletedMusicVideoAssets(keys) {
* the batch on every music video (forgetDeletedMusicVideoAssets).
*/
export async function deleteMusicVideoPoolAssets(project, items) {
+ const { withProjectMediaMutation, getProject, listProjects } = await import('./projects.js');
const { ServerError } = await import('../../lib/errorHandler.js');
- const pool = new Set((await getMusicVideoMediaPool(project)).items.map((item) => `${item.kind}:${item.assetId}`));
- // A shot on any music video using it keeps it, not only this video's shots.
- const { listProjects } = await import('./projects.js');
- const usedAnywhere = new Set((await listProjects()).flatMap((other) => [...usedKeys(other)]));
- const keys = items.map((item) => `${item.kind}:${item.assetId}`);
- const refused = keys.filter((key) => !pool.has(key) || usedAnywhere.has(key));
- if (refused.length) {
- throw new ServerError(`${refused.length} of these ${refused.length === 1 ? 'is' : 'are'} on a shot or not made for this video`, { status: 409, code: 'POOL_ASSET_IN_USE' });
- }
- const [{ deleteGalleryImage }, { deleteHistoryItem }] = await Promise.all([
- import('../galleryImageDeletion.js'), import('../videoGen/historyOps.js'),
- ]);
- for (const item of items) {
- await (item.kind === 'image' ? deleteGalleryImage : deleteHistoryItem)(item.assetId, { forgetInMusicVideos: false });
- }
- await forgetDeletedMusicVideoAssets(keys);
- return { deleted: items.length };
+ const { withBackupAssetPublication } = await import('../../lib/backupSnapshotBoundary.js');
+ // Backup admission precedes the project boundary, matching gallery/history
+ // deletion; one lease covers physical deletion and project cleanup.
+ return withBackupAssetPublication(() => withProjectMediaMutation(async (admitted) => {
+ const current = await getProject(project.id);
+ if (!current) throw new ServerError('Project not found', { status: 404, code: 'NOT_FOUND' });
+ const pool = new Set((await getMusicVideoMediaPool(current)).items.map((item) => `${item.kind}:${item.assetId}`));
+ // A shot on any music video using it keeps it, not only this video's shots.
+ const usedAnywhere = new Set((await listProjects()).flatMap((other) => [...usedKeys(other)]));
+ const keys = items.map((item) => `${item.kind}:${item.assetId}`);
+ const refused = keys.filter((key) => !pool.has(key) || usedAnywhere.has(key));
+ if (refused.length) {
+ throw new ServerError(`${refused.length} of these ${refused.length === 1 ? 'is' : 'are'} on a shot or not made for this video`, { status: 409, code: 'POOL_ASSET_IN_USE' });
+ }
+ const [{ deleteGalleryImage }, { deleteHistoryItem }] = await Promise.all([
+ import('../galleryImageDeletion.js'), import('../videoGen/historyOps.js'),
+ ]);
+ const deleted = [];
+ try {
+ for (const item of items) {
+ await (item.kind === 'image' ? deleteGalleryImage : deleteHistoryItem)(item.assetId, { forgetInMusicVideos: false });
+ deleted.push(`${item.kind}:${item.assetId}`);
+ }
+ } finally {
+ // Even when a later deletion fails, forget the completed prefix. Keep the
+ // failed item's evidence, and let the original error reach the caller.
+ if (deleted.length) await forgetDeletedMusicVideoAssets(deleted, admitted);
+ }
+ return { deleted: deleted.length };
+ }));
}
diff --git a/server/services/musicVideo/projects.js b/server/services/musicVideo/projects.js
index 4a0c140800..99e1db21cd 100644
--- a/server/services/musicVideo/projects.js
+++ b/server/services/musicVideo/projects.js
@@ -23,7 +23,7 @@ import { assertMusicVideoMediaSelections } from '../../lib/musicVideoMediaPolicy
*/
import { setSceneLastFailure } from './takes.js';
-import { droppedTakeAssets, fileMusicVideoMedia } from './mediaPool.js';
+import { droppedTakeAssets, fileMusicVideoMedia, assertNewMediaSelections } from './mediaPool.js';
import { presentMusicVideoDependencies, retainMusicVideoDependencies } from '../../lib/musicVideoDependencies.js';
import { createRecordStoreBackendSelector } from '../../lib/pgFileFacade.js';
import { emitRecordUpdated, emitRecordDeleted, autoSubscribeRecordToAllPeers } from '../sharing/recordEvents.js';
@@ -41,6 +41,14 @@ const { selectBackend, getBackendName } = createRecordStoreBackendSelector({
requireDbMessage: 'Music Video requires PostgreSQL — run `npm run setup:db` (dev/test only: set PGMODE=file in .env)',
});
+/** Pool deletion joins the actual backend write boundary and cleans up without re-entering it. */
+export async function withProjectMediaMutation(work) {
+ const backend = await selectBackend();
+ return backend.withProjectMutation(({ mutateProjectRecord: mutateAdmitted }) => work({
+ mutateProjectRecord: (id, transform) => mutateProjectRecordAdmitted(id, transform, {}, mutateAdmitted),
+ }));
+}
+
/** Name of the active backend, or null before first call (for diagnostics/tests). */
export function getProjectsBackendName() {
return getBackendName();
@@ -189,9 +197,14 @@ export async function updateProject(id, patch) {
const needsSnapshot = seeded?.concept?.universeId !== undefined || seeded?.concept?.characterStyleId !== undefined
|| seeded?.visualSpec?.moodBoardId !== undefined;
const resolved = needsSnapshot ? await withStyleSnapshots(seeded, await backend.getProject(id)) : seeded;
- const next = await backend.updateProject(id, resolved);
- emitRecordUpdated('musicVideoProject', id);
- return next;
+ if (!Array.isArray(resolved.scenes)) {
+ const next = await backend.updateProject(id, resolved);
+ emitRecordUpdated('musicVideoProject', id);
+ return next;
+ }
+ const { applyProjectPatch } = await import('./projectsLogic.js');
+ const { project } = await mutateProjectRecord(id, current => ({ project: applyProjectPatch(current, resolved) }));
+ return project;
}
/**
@@ -353,16 +366,12 @@ export async function markMediaPoolAssets(id, keys, mark) {
// Append candidate takes to one scene: `{ scene, appended }`. A take fills its
// slot only while the slot is empty — never replaces a selection (takes.js).
export async function appendSceneTakes(id, sceneId, inputs) {
- if (inputs.some(input => input.source === 'generated')) {
- const { appendSceneTakes: append } = await import('./takes.js');
- const outcome = await mutateProjectRecord(id, current => append(current, sceneId, inputs), { source: 'generation-completion' });
- await fileAppendedTakes(outcome.project, outcome.appended.map(take => ({ sceneId, take })));
- return { scene: outcome.project.scenes.find(scene => scene.sceneId === sceneId), appended: outcome.appended };
- }
- const result = await (await selectBackend()).appendSceneTakes(id, sceneId, inputs);
- emitRecordUpdated('musicVideoProject', id);
- await fileAppendedTakes(await getProject(id), result.appended.map(take => ({ sceneId, take })));
- return result;
+ const { appendSceneTakes: append } = await import('./takes.js');
+ const outcome = await mutateProjectRecord(id, current => append(current, sceneId, inputs), {
+ source: inputs.some(input => input.source === 'generated') ? 'generation-completion' : null,
+ });
+ await fileAppendedTakes(outcome.project, outcome.appended.map(take => ({ sceneId, take })));
+ return { scene: outcome.project.scenes.find(scene => scene.sceneId === sceneId), appended: outcome.appended };
}
// Every take that lands also lands in the project's own collection (mediaPool.js).
@@ -382,8 +391,8 @@ export async function recordSceneFailure(id, sceneId, failure) {
/** Append takes across scenes in one write (handoff import): `{ project, appended }`. */
export async function appendTakesAcrossScenes(id, items) {
- const result = await (await selectBackend()).appendTakesAcrossScenes(id, items);
- emitRecordUpdated('musicVideoProject', id);
+ const { appendTakesAcrossScenes: append } = await import('./takes.js');
+ const result = await mutateProjectRecord(id, current => append(current, items));
await fileAppendedTakes(result.project, result.appended.filter(Boolean));
return result;
}
@@ -483,10 +492,15 @@ export async function reviewSceneTake(id, sceneId, takeId, review) {
* resolves to that outcome with the persisted project. Used by the treatment
* service (#8980) so its revision checks run against the freshest record.
*/
-export async function mutateProjectRecord(id, transform, { source = null } = {}) {
+export function mutateProjectRecord(id, transform, options = {}) {
+ return mutateProjectRecordAdmitted(id, transform, options);
+}
+
+async function mutateProjectRecordAdmitted(id, transform, { source = null } = {}, mutate = null) {
const { preserveAutomatedShotLocks } = source ? await import('./productionReview.js') : {};
let dropped = null;
- const outcome = await (await selectBackend()).mutateProjectRecord(id, (current) => {
+ const write = mutate || (await selectBackend()).mutateProjectRecord;
+ const outcome = await write(id, async (current) => {
const outcome = transform(current);
if (source) {
const guarded = preserveAutomatedShotLocks(current, outcome.project, source);
@@ -499,6 +513,7 @@ export async function mutateProjectRecord(id, transform, { source = null } = {})
if ('replaced' in outcome) outcome.replaced = 0;
}
}
+ await assertNewMediaSelections(current, outcome.project);
dropped = { project: current, assets: droppedTakeAssets(current, outcome.project) };
return { ...outcome, project: retainMusicVideoDependencies(current, outcome.project) };
});
diff --git a/server/services/musicVideo/projects.test.js b/server/services/musicVideo/projects.test.js
index 6e93900369..bf1d51b732 100644
--- a/server/services/musicVideo/projects.test.js
+++ b/server/services/musicVideo/projects.test.js
@@ -7,7 +7,7 @@
*/
import { describe, it, expect, vi, beforeEach, afterAll } from 'vitest';
-import { mkdtempSync, rmSync } from 'fs';
+import { mkdtempSync, rmSync, writeFileSync } from 'fs';
import { tmpdir } from 'os';
import { join } from 'path';
@@ -42,6 +42,10 @@ const projects = await import('./projects.js');
function reset() {
rmSync(join(TEST_DATA_ROOT, 'music-video-projects.json'), { force: true });
+ writeFileSync(join(TEST_DATA_ROOT, 'video-history.json'), JSON.stringify(
+ ['run-clip', 'new-clip', 'clip-1', 'clip-2', 'approved-clip', 'alternate-clip', 'keep-clip', 'candidate-clip', 'clip-a', 'clip-b']
+ .map(id => ({ id, filename: `${id}.mp4` })),
+ ));
emitRecordUpdated.mockClear();
emitRecordDeleted.mockClear();
autoSubscribeRecordToAllPeers.mockClear();
diff --git a/server/services/musicVideo/projectsDB.js b/server/services/musicVideo/projectsDB.js
index cddfb1b330..342bac2899 100644
--- a/server/services/musicVideo/projectsDB.js
+++ b/server/services/musicVideo/projectsDB.js
@@ -2,6 +2,7 @@
import { randomUUID } from 'crypto';
import { withTransaction } from '../../lib/db.js';
+import { createFileWriteQueue } from '../../lib/fileWriteQueue.js';
import { ServerError } from '../../lib/errorHandler.js';
import { createProjectDbStore } from '../projectDbStore.js';
import * as logic from './projectsLogic.js';
@@ -19,11 +20,10 @@ const store = createProjectDbStore({
const { withLockedProject, rowToProject } = store;
export const {
- persist, listProjects, getProject, getProjectsByIds, listProjectIds, createProject,
- updateProject, deleteProject, mergeProjectsFromSync, pruneTombstonedProjects,
+ persist, listProjects, getProject, getProjectsByIds, listProjectIds,
} = store;
-export async function cloneProject(id, options = {}) {
+async function cloneProjectUnqueued(id, options = {}) {
return withTransaction(async (client) => {
const selected = await client.query(
`SELECT id, data FROM music_video_projects WHERE id = $1 FOR SHARE`,
@@ -43,17 +43,17 @@ export async function cloneProject(id, options = {}) {
});
}
-export async function setProjectAnalysis(id, analysis, sourceProject) {
+async function setProjectAnalysisUnqueued(id, analysis, sourceProject) {
const { project } = await withLockedProject(id, (current) => ({ project: logic.setAudioAnalysis(current, analysis, sourceProject) }));
return project;
}
-export async function setProjectMidiTranscription(id, midi) {
+async function setProjectMidiTranscriptionUnqueued(id, midi) {
const { project } = await withLockedProject(id, (current) => ({ project: logic.setMidiTranscription(current, midi) }));
return project;
}
-export async function addProjectScene(id, sceneInput) {
+async function addProjectSceneUnqueued(id, sceneInput) {
const { result } = await withLockedProject(id, (current) => {
const { project, scene } = logic.addScene(current, sceneInput);
return { project, result: scene };
@@ -61,7 +61,7 @@ export async function addProjectScene(id, sceneInput) {
return result;
}
-export async function addProjectScenes(id, sceneInputs) {
+async function addProjectScenesUnqueued(id, sceneInputs) {
const { project, result: scenes } = await withLockedProject(id, (current) => {
const outcome = logic.addScenes(current, sceneInputs);
return { project: outcome.project, result: outcome.scenes };
@@ -69,7 +69,7 @@ export async function addProjectScenes(id, sceneInputs) {
return { project, scenes };
}
-export async function updateScene(id, sceneId, patch) {
+async function updateSceneUnqueued(id, sceneId, patch) {
const { result } = await withLockedProject(id, (current) => {
const { project, updated } = logic.applySceneUpdate(current, sceneId, patch);
return { project, result: updated };
@@ -77,12 +77,12 @@ export async function updateScene(id, sceneId, patch) {
return result;
}
-export async function deleteScene(id, sceneId) {
+async function deleteSceneUnqueued(id, sceneId) {
const { project } = await withLockedProject(id, (current) => ({ project: logic.removeScene(current, sceneId) }));
return project;
}
-export async function reorderProjectScenes(id, orderedIds) {
+async function reorderProjectScenesUnqueued(id, orderedIds) {
const { project } = await withLockedProject(id, (current) => ({ project: logic.reorderScenes(current, orderedIds) }));
return project;
}
@@ -90,8 +90,8 @@ export async function reorderProjectScenes(id, orderedIds) {
// ---- scene takes (#8965) — each operation runs under the project row lock,
// so a job completion and a director's select/reject can't interleave. -------
async function mutateLocked(id, transform) {
- const { result } = await withLockedProject(id, (current) => {
- const outcome = transform(current);
+ const { result } = await withLockedProject(id, async (current) => {
+ const outcome = await transform(current);
return { project: outcome.project, result: outcome };
});
return result;
@@ -100,29 +100,57 @@ async function mutateLocked(id, transform) {
// Generic pure-transform mutation under the row lock (#8980 treatment ops):
// `transform(project)` returns `{ project, ...result }`; resolves to that
// outcome with `project` replaced by the persisted record.
-export async function mutateProjectRecord(id, transform) {
- const { project, result } = await withLockedProject(id, (current) => {
- const outcome = transform(current);
+async function mutateProjectRecordUnqueued(id, transform) {
+ const { project, result } = await withLockedProject(id, async (current) => {
+ const outcome = await transform(current);
return { project: outcome.project, result: outcome };
});
return { ...result, project };
}
-export async function appendSceneTakes(id, sceneId, inputs) {
+async function appendSceneTakesUnqueued(id, sceneId, inputs) {
const { scene, appended } = await mutateLocked(id, (p) => takes.appendSceneTakes(p, sceneId, inputs));
return { scene, appended };
}
-export async function appendTakesAcrossScenes(id, items) {
+async function appendTakesAcrossScenesUnqueued(id, items) {
return mutateLocked(id, (p) => takes.appendTakesAcrossScenes(p, items));
}
-export async function selectSceneTake(id, sceneId, takeId) {
+async function selectSceneTakeUnqueued(id, sceneId, takeId) {
const { scene } = await mutateLocked(id, (p) => takes.selectSceneTake(p, sceneId, takeId));
return scene;
}
-export async function reviewSceneTake(id, sceneId, takeId, review) {
+async function reviewSceneTakeUnqueued(id, sceneId, takeId, review) {
const { scene } = await mutateLocked(id, (p) => takes.reviewSceneTake(p, sceneId, takeId, review));
return scene;
}
+
+// One same-install admission precedes row locks, including inserts and sync.
+// Pool deletion needs a stable all-project selection scan through file removal.
+// Row locks still protect the persisted read/modify/write transaction.
+const queueWrite = createFileWriteQueue();
+const serialized = (fn) => (...args) => queueWrite(() => fn(...args));
+export const createProject = serialized(store.createProject);
+export const updateProject = serialized(store.updateProject);
+export const deleteProject = serialized(store.deleteProject);
+export const mergeProjectsFromSync = serialized(store.mergeProjectsFromSync);
+export const pruneTombstonedProjects = serialized(store.pruneTombstonedProjects);
+export const cloneProject = serialized(cloneProjectUnqueued);
+export const setProjectAnalysis = serialized(setProjectAnalysisUnqueued);
+export const setProjectMidiTranscription = serialized(setProjectMidiTranscriptionUnqueued);
+export const addProjectScene = serialized(addProjectSceneUnqueued);
+export const addProjectScenes = serialized(addProjectScenesUnqueued);
+export const updateScene = serialized(updateSceneUnqueued);
+export const deleteScene = serialized(deleteSceneUnqueued);
+export const reorderProjectScenes = serialized(reorderProjectScenesUnqueued);
+export const mutateProjectRecord = serialized(mutateProjectRecordUnqueued);
+export const appendSceneTakes = serialized(appendSceneTakesUnqueued);
+export const appendTakesAcrossScenes = serialized(appendTakesAcrossScenesUnqueued);
+export const selectSceneTake = serialized(selectSceneTakeUnqueued);
+export const reviewSceneTake = serialized(reviewSceneTakeUnqueued);
+
+export function withProjectMutation(work) {
+ return queueWrite(() => work({ mutateProjectRecord: mutateProjectRecordUnqueued }));
+}
diff --git a/server/services/musicVideo/projectsFile.js b/server/services/musicVideo/projectsFile.js
index 65bb25d5d8..25ec9f444d 100644
--- a/server/services/musicVideo/projectsFile.js
+++ b/server/services/musicVideo/projectsFile.js
@@ -105,7 +105,7 @@ async function reorderProjectScenesUnqueued(id, orderedIds) {
// ---- scene takes (#8965) — one load/modify/save per take operation ----------
async function mutateProject(id, transform) {
const { all, idx } = await loadAllAndIndex(id);
- const outcome = transform(all[idx]);
+ const outcome = await transform(all[idx]);
all[idx] = outcome.project;
await saveAll(all);
return outcome;
@@ -145,3 +145,8 @@ export const reviewSceneTake = serialized(reviewSceneTakeUnqueued);
// Generic pure-transform mutation (#8980 treatment ops): `transform(project)`
// returns `{ project, ...result }`; resolves to that outcome.
export const mutateProjectRecord = serialized(mutateProject);
+
+/** Hold the same file tail as every writer; cleanup uses the unqueued mutation. */
+export function withProjectMutation(work) {
+ return queueWrite(() => work({ mutateProjectRecord: mutateProject }));
+}
diff --git a/server/services/musicVideo/render.document.test.js b/server/services/musicVideo/render.document.test.js
index 01133cb66b..3e0dd00219 100644
--- a/server/services/musicVideo/render.document.test.js
+++ b/server/services/musicVideo/render.document.test.js
@@ -117,6 +117,9 @@ describe('composition-document render plan', () => {
// Uniquely catches a draft blocked by a stale lip-sync take, or a final render drawing one.
it('refuses a full render over a stale performance take (#9266), while a draft draws it as a cutaway', async () => {
const id = await documentProject();
+ await mkdir(PATHS.images, { recursive: true });
+ await writeFile(join(PATHS.images, 'still.png'), 'synthetic still');
+ await writeFile(join(PATHS.data, 'video-history.json'), JSON.stringify([{ id: 'clip-1', filename: 'clip-1.mp4' }]));
await importDocumentTemplate(id);
await projects.mutateProjectRecord(id, (current) => ({ project: {
...current,
diff --git a/server/services/musicVideoSceneHooks.test.js b/server/services/musicVideoSceneHooks.test.js
index 4db2cf83a4..befb201ff2 100644
--- a/server/services/musicVideoSceneHooks.test.js
+++ b/server/services/musicVideoSceneHooks.test.js
@@ -7,16 +7,14 @@
*/
import { describe, it, expect, beforeEach, afterEach, afterAll, vi } from 'vitest';
-import { mkdtempSync, rmSync } from 'fs';
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync } from 'fs';
import { tmpdir } from 'os';
import { join } from 'path';
+import { makePathsProxy } from '../lib/mockPathsDataRoot.js';
const TEST_DATA_ROOT = mkdtempSync(join(tmpdir(), 'mv-scene-hooks-test-'));
-vi.mock('../lib/fileUtils.js', async (importOriginal) => {
- const actual = await importOriginal();
- return { ...actual, PATHS: { ...actual.PATHS, data: TEST_DATA_ROOT } };
-});
+vi.mock('../lib/paths.js', async (original) => makePathsProxy(await original(), { dataRoot: () => TEST_DATA_ROOT }));
vi.mock('./settings.js', () => ({ getSettings: vi.fn(async () => ({})) }));
const { mediaJobEvents } = await import('./mediaJobQueue/index.js');
@@ -64,6 +62,17 @@ describe('music-video scene completion hooks → takes', () => {
beforeEach(async () => {
project = null;
rmSync(join(TEST_DATA_ROOT, 'music-video-projects.json'), { force: true });
+ // Real workers publish media/history before emitting completed. Keep the
+ // hook tests on that boundary, including direct selection of source plates.
+ mkdirSync(join(TEST_DATA_ROOT, 'images'), { recursive: true });
+ for (const name of ['newer', 'older', 'first', 'second', 'third', 'one', 'two', 'three',
+ 'frame-a', 'frame-b', 'start', 'sketch', 'late', 'kept', 'frame']) {
+ writeFileSync(join(TEST_DATA_ROOT, 'images', `${name}.png`), 'synthetic image');
+ }
+ mkdirSync(join(TEST_DATA_ROOT, 'videos'), { recursive: true });
+ const clips = ['clip-1', 'clip-2', 'clip-old', 'late-clip', 'clip-ok'];
+ for (const id of clips) writeFileSync(join(TEST_DATA_ROOT, 'videos', `${id}.mp4`), 'synthetic clip');
+ writeFileSync(join(TEST_DATA_ROOT, 'video-history.json'), JSON.stringify(clips.map(id => ({ id, filename: `${id}.mp4` }))));
imageHook.__testing.reset();
videoHook.__testing.reset();
imageHook.initMusicVideoSceneImageHook();