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: reuse music video dependency checks within each read

[._.]/ Adam Eivy02c7cc2d3d43
diff --git a/server/lib/musicVideoDependencies.js b/server/lib/musicVideoDependencies.js
index 350b4628d4..10a29448f2 100644
--- a/server/lib/musicVideoDependencies.js
+++ b/server/lib/musicVideoDependencies.js
@@ -81,22 +81,50 @@ export function captureMusicVideoEvidence(project, { sceneIds = null, startSec =
return snapshot(references);
}
-/** Absent legacy evidence is unknown, never an affirmative current verdict. */
-export function musicVideoDependencyChanges(project, dependencies) {
+// A presentation/impact read checks many historical snapshots against the same
+// project. Share current references only within that synchronous read: project
+// objects can be mutated in place between reads, including before a save.
+function createDependencyReader(project) {
+ let song;
+ let scenesById;
+ const sceneReferences = new Map();
+ const windows = new Map();
+ return (ref) => {
+ if (ref.role === 'song') return song ??= songRef(project);
+ if (ref.role === 'window' || ref.role === 'composition') {
+ let byEnd = windows.get(ref.startSec);
+ if (!byEnd) windows.set(ref.startSec, byEnd = new Map());
+ let references = byEnd.get(ref.endSec);
+ if (!references) byEnd.set(ref.endSec, references = {});
+ if (!references[ref.role]) references[ref.role] = ref.role === 'composition'
+ ? compositionRef(project, ref.startSec, ref.endSec)
+ : { assetId: 'scene-set', revision: checksum((project.scenes || []).filter((scene) => intersects(scene, ref.startSec, ref.endSec)).map((scene) => scene.sceneId).sort()) };
+ return references[ref.role];
+ }
+ if (!scenesById) {
+ scenesById = new Map();
+ for (const scene of project.scenes || []) {
+ if (!scenesById.has(scene.sceneId)) scenesById.set(scene.sceneId, scene);
+ }
+ }
+ const scene = scenesById.get(ref.sceneId);
+ if (!scene) return null;
+ let references = sceneReferences.get(scene);
+ if (!references) sceneReferences.set(scene, references = new Map());
+ if (!references.has(ref.role)) references.set(ref.role, slots[ref.role] ? assetRef(scene, ref.role)
+ : ref.role === 'layer' ? layerRef(scene) : null);
+ return references.get(ref.role);
+ };
+}
+
+function dependencyChanges(dependencies, readCurrent) {
if (!dependencies || dependencies.version !== MUSIC_VIDEO_DEPENDENCY_VERSION || !Array.isArray(dependencies.references)) {
return [{ role: 'unknown', reason: 'Dependency evidence was not recorded; review again' }];
}
const changes = dependencies.references.some((ref) => ref.role === 'window') && !dependencies.references.some((ref) => ref.role === 'song')
? [{ role: 'song', reason: 'Song dependency evidence was not recorded; review again' }] : [];
for (const ref of dependencies.references) {
- let current;
- const scene = (project.scenes || []).find((entry) => entry.sceneId === ref.sceneId);
- if (ref.role === 'song') current = songRef(project);
- else if (ref.role === 'window') current = { assetId: 'scene-set', revision: checksum((project.scenes || []).filter((scene) => intersects(scene, ref.startSec, ref.endSec)).map((scene) => scene.sceneId).sort()) };
- else if (ref.role === 'composition') current = compositionRef(project, ref.startSec, ref.endSec);
- else if (!scene) current = null;
- else if (slots[ref.role]) current = assetRef(scene, ref.role);
- else if (ref.role === 'layer') current = layerRef(scene);
+ const current = readCurrent(ref);
if (!current || current.assetId !== ref.assetId || current.revision !== ref.revision) {
changes.push({ ...ref, reason: `${ref.role === 'song' ? 'Master audio, lyrics or alignment' : ref.role === 'plate' ? 'Selected plate or its crop/mask inputs' : ref.role === 'endPlate' ? 'Selected end frame' : ref.role === 'clip' ? 'Selected clip' : ref.role === 'layer' ? 'Shot timing or composition layer' : 'Composition'} changed` });
}
@@ -104,8 +132,13 @@ export function musicVideoDependencyChanges(project, dependencies) {
return changes;
}
-export function musicVideoTakeChanges(project, scene, take) {
- if (take?.dependencies) return musicVideoDependencyChanges(project, take.dependencies);
+/** Absent legacy evidence is unknown, never an affirmative current verdict. */
+export function musicVideoDependencyChanges(project, dependencies) {
+ return dependencyChanges(dependencies, createDependencyReader(project));
+}
+
+function takeChanges(scene, take, readCurrent) {
+ if (take?.dependencies) return dependencyChanges(take.dependencies, readCurrent);
// Pre-provenance generated clips still recorded their actual source basename.
if (take?.sourceImageId && take.sourceImageId !== scene.referenceImageId) {
return [{ role: 'plate', sceneId: scene.sceneId, reason: 'Selected plate changed' }];
@@ -113,6 +146,10 @@ export function musicVideoTakeChanges(project, scene, take) {
return [];
}
+export function musicVideoTakeChanges(project, scene, take) {
+ return takeChanges(scene, take, createDependencyReader(project));
+}
+
/** Before a write, materialize legacy provenance from the PRE-image, never new inputs. */
export function retainMusicVideoDependencies(before, after) {
const previousScenes = new Map((before.scenes || []).map((scene) => [scene.sceneId, scene]));
@@ -135,11 +172,12 @@ export function retainMusicVideoDependencies(before, after) {
/** Read-only downstream preview. Generation count is an upper bound, not a price quote. */
export function musicVideoDependencyImpact(project, performanceChanges = []) {
+ const readCurrent = createDependencyReader(project);
const shots = [];
for (const scene of project.scenes || []) {
const take = selectedTake(scene, 'clip') || (!scene.videoHistoryId
? (scene.takes || []).findLast((entry) => entry.kind === 'video' && entry.status === 'rejected') : null);
- const changes = take ? musicVideoTakeChanges(project, scene, take) : [];
+ const changes = take ? takeChanges(scene, take, readCurrent) : [];
const audio = performanceChanges.filter((entry) => entry.sceneId === scene.sceneId);
const unfinished = !scene.videoHistoryId && (project.revisions || []).some((revision) => revision.type === 'dependencies'
&& revision.sections?.some((section) => section.sceneId === scene.sceneId && section.verdict === 'rejected'));
@@ -150,7 +188,7 @@ export function musicVideoDependencyImpact(project, performanceChanges = []) {
const affected = new Set(shots.map((shot) => shot.sceneId));
const evidence = [];
const check = (kind, id, dependencies, scope = {}) => {
- const changes = musicVideoDependencyChanges(project, dependencies);
+ const changes = dependencyChanges(dependencies, readCurrent);
const transitive = (dependencies?.references || []).some((ref) => affected.has(ref.sceneId));
if (changes.length || transitive) evidence.push({ kind, id, reasons: [...new Set([
...changes.map((entry) => entry.reason), ...(transitive ? ['Derived clip is stale'] : []),
@@ -177,8 +215,9 @@ export function musicVideoDependencyImpact(project, performanceChanges = []) {
/** Bounded projection for readers: retain verdicts/assets, expose their validity separately. */
export function presentMusicVideoDependencies(project) {
if (!project) return project;
+ const readCurrent = createDependencyReader(project);
const state = (dependencies) => {
- const changes = musicVideoDependencyChanges(project, dependencies);
+ const changes = dependencyChanges(dependencies, readCurrent);
return { status: changes.length ? (changes[0].role === 'unknown' ? 'unknown' : 'stale') : 'current',
reasons: [...new Set(changes.map((change) => change.reason))] };
};
diff --git a/server/lib/musicVideoDependencies.test.js b/server/lib/musicVideoDependencies.test.js
new file mode 100644
index 0000000000..89d63b28b3
--- /dev/null
+++ b/server/lib/musicVideoDependencies.test.js
@@ -0,0 +1,52 @@
+import { afterEach, expect, it, vi } from 'vitest';
+import * as checksums from './snapshotChecksum.js';
+import { captureMusicVideoEvidence, presentMusicVideoDependencies } from './musicVideoDependencies.js';
+
+afterEach(() => vi.restoreAllMocks());
+
+const projectFixture = () => ({
+ id: 'mv-synthetic',
+ lyricCues: [{ id: 'cue', text: 'Synthetic lyric', startSec: 0, endSec: 10 }],
+ composition: { cues: [{ startSec: 0, endSec: 5, text: 'First' }, { startSec: 5, endSec: 10, text: 'Second' }] },
+ scenes: [0, 1].map(i => ({ sceneId: `scene-${i}`, startSec: i * 5, endSec: i * 5 + 5,
+ visualLayer: 'still', referenceImageId: `image-${i}.png`, takes: [] })),
+});
+
+it('bounds checksum work by distinct current inputs across historical snapshots and refreshes after edits', () => {
+ const project = projectFixture();
+ const dependencies = captureMusicVideoEvidence(project);
+ project.renderHistoryId = 'final';
+ project.renderDependencies = dependencies;
+ project.excerpts = Array.from({ length: 40 }, (_, i) => ({ id: `excerpt-${i}`, dependencies: structuredClone(dependencies) }));
+ const checksum = vi.spyOn(checksums, 'canonicalSnapshotChecksum');
+
+ presentMusicVideoDependencies({ ...project, excerpts: project.excerpts.slice(0, 1) });
+ const oneSnapshotWork = checksum.mock.calls.length;
+ checksum.mockClear();
+ const current = presentMusicVideoDependencies(project);
+ expect(current.excerpts.every(excerpt => excerpt.dependencyState.status === 'current')).toBe(true);
+ expect(checksum.mock.calls.length).toBe(oneSnapshotWork);
+
+ project.lyricCues[0].text = 'Revised synthetic lyric';
+ const songChanged = presentMusicVideoDependencies(project);
+ expect(songChanged.renderDependencyState.status).toBe('stale');
+ expect(songChanged.excerpts.every(excerpt => excerpt.dependencyState.reasons.includes('Master audio, lyrics or alignment changed'))).toBe(true);
+
+ project.lyricCues[0].text = 'Synthetic lyric';
+ project.scenes[0].referenceImageId = 'replacement.png';
+ expect(presentMusicVideoDependencies(project).renderDependencyState.reasons).toEqual(['Selected plate or its crop/mask inputs changed']);
+ expect(dependencies).toEqual(project.excerpts[0].dependencies);
+});
+
+it('keeps distinct rendered windows independent when caching composition and scene-set references', () => {
+ const project = projectFixture();
+ project.excerpts = [0, 5].map(startSec => ({ dependencies: captureMusicVideoEvidence(project, { startSec, endSec: startSec + 5 }) }));
+ project.composition.cues[0].text = 'Revised first window';
+
+ const changed = presentMusicVideoDependencies(project);
+ expect(changed.excerpts.map(excerpt => excerpt.dependencyState.status)).toEqual(['stale', 'current']);
+ expect(changed.excerpts[0].dependencyState.reasons).toEqual(['Composition changed']);
+
+ project.scenes[0].endSec = 6;
+ expect(presentMusicVideoDependencies(project).excerpts.map(excerpt => excerpt.dependencyState.status)).toEqual(['stale', 'stale']);
+});