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

fix: a music-video re-render right after a cancel no longer joins the cancelled shot render (#11774)

[._.]/ Adam Eivybcfac38d379b
diff --git a/server/services/musicVideo/shotSegments.js b/server/services/musicVideo/shotSegments.js
index c7a326510b..e63159ca0a 100644
--- a/server/services/musicVideo/shotSegments.js
+++ b/server/services/musicVideo/shotSegments.js
@@ -191,12 +191,15 @@ export const segmentRendering = (segment) => inFlight.has(segment.path);
export function renderSegment(plan, segment, { signal, onProgress } = {}) {
if (existsSync(segment.path)) return Promise.resolve(segment.path);
let entry = inFlight.get(segment.path);
- if (!entry) {
+ // An aborted entry is still tearing down (ffmpeg/browser) and can only reject
+ // with the abort, so a new caller replaces it rather than joining it.
+ if (!entry || entry.controller.signal.aborted) {
const controller = new AbortController();
- entry = { controller, waiters: 0, listeners: new Set() };
- entry.promise = renderSegmentFiles(plan, segment, { signal: controller.signal, onProgress: (f) => entry.listeners.forEach((fn) => fn(f)) })
- .finally(() => inFlight.delete(segment.path));
- inFlight.set(segment.path, entry);
+ const fresh = { controller, waiters: 0, listeners: new Set() };
+ fresh.promise = renderSegmentFiles(plan, segment, { signal: controller.signal, onProgress: (f) => fresh.listeners.forEach((fn) => fn(f)) })
+ .finally(() => { if (inFlight.get(segment.path) === fresh) inFlight.delete(segment.path); });
+ inFlight.set(segment.path, fresh);
+ entry = fresh;
}
entry.waiters += 1;
if (onProgress) entry.listeners.add(onProgress);
diff --git a/server/services/musicVideo/shotSegments.test.js b/server/services/musicVideo/shotSegments.test.js
index 974fd8302f..6cbbd1ef4a 100644
--- a/server/services/musicVideo/shotSegments.test.js
+++ b/server/services/musicVideo/shotSegments.test.js
@@ -6,7 +6,7 @@
*/
import { describe, it, expect, vi, afterAll, afterEach, beforeAll } from 'vitest';
import { execFileSync } from 'child_process';
-import { existsSync, mkdirSync, rmSync } from 'fs';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'fs';
import { join } from 'path';
import { cleanupTempDataRoots, lazyTempDataRoot, makePathsProxy } from '../../lib/mockPathsDataRoot.js';
@@ -30,7 +30,7 @@ vi.mock('./render.js', async (importOriginal) => {
vi.mock('./filmLookFinish.js', () => ({ applyFilmLookFinish: vi.fn(async () => true) }));
vi.mock('./projects.js', () => ({ getProject: vi.fn(async (id) => (id === fixture.project?.id ? fixture.project : null)) }));
-const { planShotSegments, renderMissingSegments, renderSegment, segmentConcurrency, stitchSegments, pruneSegments, listFilmLooks, deleteFilmLook, buildRenderPreview } = await import('./shotSegments.js');
+const { planShotSegments, renderMissingSegments, renderSegment, segmentConcurrency, stitchSegments, pruneSegments, listFilmLooks, deleteFilmLook, buildRenderPreview, segmentRendering } = await import('./shotSegments.js');
const { buildMusicVideoFfmpegArgs } = await import('./render.js');
const { musicVideoEvents } = await import('./events.js');
const { applyFilmLookFinish } = await import('./filmLookFinish.js');
@@ -254,3 +254,37 @@ describe.skipIf(!hasFfmpeg)('shot segments', () => {
expect(existsSync(pinned.segments[2].basePath)).toBe(true);
}, 60000);
});
+
+describe('renderSegment after a cancel', () => {
+ const deferred = () => { let release; const promise = new Promise((r) => { release = r; }); return { promise, release }; };
+
+ it('starts a fresh render instead of joining the aborted one still tearing down', async () => {
+ const dir = join(ROOT(), 'cancel-rejoin');
+ mkdirSync(dir, { recursive: true });
+ const segment = { sceneId: 'scene-cancel', startSec: 0, look: { id: 'look' }, ownLook: true, basePath: join(dir, 'base.mp4'), path: join(dir, 'final.mp4') };
+ writeFileSync(segment.basePath, 'base');
+ const plan = { dir, project: { id: 'p' } };
+ const first = deferred();
+ const second = deferred();
+ applyFilmLookFinish.mockReset();
+ applyFilmLookFinish.mockReturnValueOnce(first.promise).mockReturnValueOnce(second.promise);
+
+ const cancel = new AbortController();
+ const cancelled = renderSegment(plan, segment, { signal: cancel.signal });
+ await vi.waitFor(() => expect(applyFilmLookFinish).toHaveBeenCalledTimes(1));
+ cancel.abort();
+ await expect(cancelled).rejects.toMatchObject({ code: 'CANCELED' });
+ expect(segmentRendering(segment)).toBe(true); // old render still tearing down
+
+ const retry = renderSegment(plan, segment);
+ await vi.waitFor(() => expect(applyFilmLookFinish).toHaveBeenCalledTimes(2));
+
+ first.release(true); // the old render settles; it must not evict the new entry
+ await new Promise((r) => setTimeout(r, 20));
+ expect(segmentRendering(segment)).toBe(true);
+
+ second.release(true);
+ await expect(retry).resolves.toBe(segment.path);
+ expect(segmentRendering(segment)).toBe(false);
+ });
+});