AI media harness for planning, generating, and editing locally
TypeScript
import { expect, it } from "vitest";
import { continuationBlocker, createDraftGenerationJob, createProjectConfig, parseProjectConfig, sceneGenerationReferences, sceneGenerationSnapshot, sceneShots, type GenerationJob, type ProjectReference } from "./project";
import { sceneGenerationRequest, sendBlocker } from "./sceneGeneration";
import { duplicateScene, sceneInput } from "./sceneHistory";
const project = () => createProjectConfig({ name: "Single", prompt: "A dancer walks", resolution: "416p", aspectRatio: "16:9", targetDurationSeconds: 10 });
const shot = (id: string): GenerationJob => createDraftGenerationJob("A dancer walks", { id, sceneType: "single-shot", durationSeconds: 6 });
it("keeps the original context archive while continuation advances and persists context in takes", () => {
const config = project();
const original = { ...shot("original"), sceneType: "prompt" as const, latentRelativePath: "latents/original.safetensors" };
const previous = { ...shot("previous"), continuationSceneId: original.id, contextSceneId: original.id, latentRelativePath: "latents/previous.safetensors" };
const next = { ...shot("next"), continuationSceneId: previous.id, contextSceneId: original.id, endingPrompt: "@[ref:missing] leaves." };
config.generationJobs = [next, previous, original];
expect(continuationBlocker(next, config.generationJobs)).toBeNull();
expect(sendBlocker(next, [])).toBeNull();
const request = sceneGenerationRequest(next, config, "C:/Project", 9);
expect(request).toMatchObject({ contextSceneId: "original", keystoneRelativePath: original.latentRelativePath,
previousSceneId: "previous", continuationRelativePath: previous.latentRelativePath, singleShot: { endingPrompt: "" },
continuationOverlapFrames: 22, continuationLockOverlap: true, continuationFrom: "end" });
expect(sceneGenerationSnapshot(next, request)).not.toBe(sceneGenerationSnapshot(next, { ...request, continuationOverlapFrames: 39 }));
expect(sceneGenerationRequest({ ...next, continuationOverlapFrames: 39, continuationLockOverlap: false }, config, "C:/Project", 9))
.toMatchObject({ continuationOverlapFrames: 22, continuationLockOverlap: true });
expect(JSON.parse(sceneGenerationSnapshot(next, request))).toMatchObject({ contextSceneId: "original", keystoneGuide: "context", capstoneLockAfter: "auto" });
expect(sceneGenerationSnapshot({ ...next, endingPrompt: "Something else" }, request)).toBe(sceneGenerationSnapshot(next, request));
expect(parseProjectConfig(JSON.parse(JSON.stringify(config))).generationJobs[0].contextSceneId).toBe("original");
expect(sceneInput(next).contextSceneId).toBe("original");
const duplicate = duplicateScene(config, next.id)!;
expect(duplicate.config.generationJobs.find((job) => job.id === duplicate.id)?.contextSceneId).toBe("original");
expect(continuationBlocker({ ...next, contextSceneId: previous.id }, config.generationJobs)).toMatch(/first video/);
expect(continuationBlocker({ ...next, contextSceneId: next.id }, config.generationJobs)).toMatch(/itself/);
expect(continuationBlocker({ ...next, contextSceneId: "missing" }, config.generationJobs)).toMatch(/no longer exists/);
expect(continuationBlocker({ ...next, continuationSceneId: null }, config.generationJobs)).toMatch(/Previous video/);
expect(sceneGenerationRequest({ ...next, sceneType: "prompt" }, config, "C:/Project", 9).keystoneRelativePath).toBeUndefined();
});
it("uses fresh middle noise with locked start/end anchors and ignores legacy Continuation values", () => {
const config = project(), source = { ...shot("source"), latentRelativePath: "latents/source.safetensors" };
const job = { ...shot("next"), continuationSceneId: source.id }; config.generationJobs = [source, job];
const request = sceneGenerationRequest(job, config, "D:/Project", 8);
expect(request.continuationSourceNoise).toBeUndefined();
expect(request.continuationRelativePath).toBe("latents/source.safetensors");
expect(request.continuationLockOverlap).toBe(true);
expect(request.continuationOverlapFrames).toBe(22);
expect(request.singleShot?.endingPrompt).toBeTruthy();
const changed = { ...job, continuationStrength: 0.65 };
const changedRequest = sceneGenerationRequest(changed, config, "D:/Project", 8);
expect(changedRequest.continuationSourceNoise).toBeUndefined();
expect(sceneGenerationSnapshot(changed, changedRequest)).toBe(sceneGenerationSnapshot(job, request));
expect(sceneGenerationSnapshot(changed, changedRequest)).not.toBe(sceneGenerationSnapshot(changed, { ...changedRequest, continuationSourceNoise: 0.35 }));
expect(sceneInput(changed).continuationStrength).toBe(0.65);
config.generationJobs[1] = changed;
expect(parseProjectConfig(JSON.parse(JSON.stringify(config))).generationJobs[1].continuationStrength).toBe(0.65);
expect(duplicateScene(config, changed.id)?.config.generationJobs.at(-1)?.continuationStrength).toBe(0.65);
for (const continuationStrength of [0, 0.3, 0.65, 0.99]) {
expect(sceneGenerationRequest({ ...job, continuationStrength }, config, "D:/Project", 8).continuationSourceNoise).toBeUndefined();
}
expect(sceneGenerationRequest({ ...changed, continuationSceneId: null }, config, "D:/Project", 8).continuationSourceNoise).toBeUndefined();
expect(sceneGenerationRequest({ ...changed, sceneType: "continue" }, config, "D:/Project", 8).continuationSourceNoise).toBeUndefined();
config.generationJobs[1] = { ...job, continuationStrength: 1 };
expect(() => parseProjectConfig(config)).toThrow();
});
it("compiles both prompts with consistent reference numbering and persists ending settings in drafts and copies", () => {
const config = project();
config.references = ["main", "ending", "unused"].map((id): ProjectReference => ({ id, name: id, kind: "image", description: "", intendedUse: [], relativePath: `references/${id}.png`, createdAt: config.createdAt }));
const job = { ...shot("single"), endingPrompt: "@[ref:ending] waves goodbye.",
shots: [{ id: "one", startSeconds: 0, action: "@[ref:main] enters the room." }], startFrameReferenceId: "unused", endFrameReferenceId: "unused" };
config.generationJobs = [job];
const restored = parseProjectConfig(JSON.parse(JSON.stringify(config)));
expect(restored.generationJobs[0].endingPrompt).toBe(job.endingPrompt);
const request = sceneGenerationRequest(job, restored, "C:/Project", 8);
expect(sceneGenerationReferences(job, config.references).map((reference) => reference.id)).toEqual(["main", "ending"]);
expect(request.referencePaths).toEqual(["C:/Project/references/main.png", "C:/Project/references/ending.png"]);
expect(request.prompt).toContain("<Subject 1> enters the room.");
expect(request.singleShot?.endingPrompt).toContain("<Subject 2> waves goodbye.");
expect(request.prompt).not.toContain("is the last frame");
expect(request.frames).toBe(144);
expect(sceneInput(job).endingPrompt).toBe(job.endingPrompt);
expect(duplicateScene(config, job.id)?.config.generationJobs[1].endingPrompt).toBe(job.endingPrompt);
expect(JSON.parse(sceneGenerationSnapshot(job, request)).singleShot).toEqual(request.singleShot);
const changed = { ...job, endingPrompt: "@[ref:ending] sits down." };
expect(sceneGenerationSnapshot(changed, sceneGenerationRequest(changed, restored, "C:/Project", 8))).not.toBe(sceneGenerationSnapshot(job, request));
});
it("falls back to the main prompt, collapses source shots, and rejects missing references and too-short scenes", () => {
const config = project();
const job = { ...shot("single"), endingPrompt: " ", shots: [
{ id: "a", startSeconds: 0, action: "Walk forward." }, { id: "b", startSeconds: 2, action: "Wave goodbye." },
] };
expect(sceneShots(job)).toHaveLength(1);
expect(sceneShots(job)[0].action).toBe("Walk forward.\n\nWave goodbye.");
const request = sceneGenerationRequest(job, config, "C:/Project", 8);
expect(request.singleShot?.endingPrompt).toBe(request.prompt);
expect(sendBlocker({ ...job, endingPrompt: "@[ref:missing] leaves." }, [])).toMatch(/ending prompt/);
expect(sendBlocker({ ...job, durationSeconds: 1 }, [])).toMatch(/at least 2 seconds/);
});
it("uses the starting video's ending latents and rejects cycles, missing sources and incompatible upscale settings", () => {
const config = project(), source = { ...shot("start"), latentRelativePath: "latents/start.safetensors", status: "completed" as const };
const next = { ...shot("next"), continuationSceneId: source.id, continuationFrom: "start" as const, continuationOverlapFrames: 39, continuationLockOverlap: false };
config.generationJobs = [next, source];
expect(continuationBlocker(next, config.generationJobs)).toBeNull();
expect(sceneGenerationRequest(next, config, "C:/Project", 8)).toMatchObject({ previousSceneId: "start", continuationRelativePath: source.latentRelativePath,
continuationFrom: "end", continuationOverlapFrames: 22, continuationLockOverlap: true, singleShot: { endingPrompt: expect.any(String) } });
expect(continuationBlocker(next, [next])).toMatch(/no longer exists/);
expect(continuationBlocker(next, [next, { ...source, sceneType: "prompt" }])).toBeNull();
expect(continuationBlocker(next, [next, { ...source, continuationSceneId: next.id }])).toMatch(/cycle/);
expect(continuationBlocker({ ...source, continuationSceneId: source.id }, [source])).toMatch(/cycle/);
expect(continuationBlocker(next, [next, { ...source, latentUpscale: true }])).toBeNull();
});