AI media harness for planning, generating, and editing locally
TypeScript
import { describe, expect, it } from "vitest";
import type { ProjectAsset, TimelineClip, TimelineTrack } from "./project";
import { preparedPreviewClips, previewPlayerKeys, previewSegmentIndex, previewSegments } from "./timelinePreview";
const asset = { id: "video", kind: "video", mimeType: "video/mp4" } as ProjectAsset;
const assets = new Map([[asset.id, asset]]);
const clip = (id: string, startMs: number, durationMs: number, extra: Partial<TimelineClip> = {}): TimelineClip => ({
id, assetId: asset.id, trackId: "track", startMs, durationMs, sourceStartMs: 0, label: id, color: null, status: "approved", ...extra,
});
const track = (clips: TimelineClip[]): TimelineTrack => ({ id: "track", name: "Picture", kind: "video", muted: false, locked: false, clips });
describe("prepared timeline pictures", () => {
it("shares a joined decoder across rounded scene boundaries, but keeps distinct seeks separate", () => {
const joined = new Map([[asset.id, { ...asset, sceneSegments: [
{ sceneId: "a", latentRelativePath: "a", startFrame: 0, frameCount: 124 },
{ sceneId: "b", latentRelativePath: "b", startFrame: 124, frameCount: 46 },
] }]]);
const a = clip("a", 0, 5167);
const b = clip("b", 5167, 1917, { sourceStartMs: 124 * 1000 / 24 });
const tracks = [track([a, b])];
const segments = previewSegments(tracks, joined);
const keys = previewPlayerKeys(tracks, joined);
expect(preparedPreviewClips(segments, 0, keys).map((entry) => [entry.clip.id, entry.playerKey])).toEqual([["a", "a"]]);
expect(preparedPreviewClips(segments, 1, keys).map((entry) => [entry.clip.id, entry.playerKey])).toEqual([["b", "a"]]);
for (const change of [{ sourceStartMs: b.sourceStartMs + 1 }, { startMs: 5168 }, { startMs: 5166 }, { playbackRate: 2 }]) {
expect(previewPlayerKeys([track([a, { ...b, ...change }])], joined).get("b")).toBe("b");
}
expect(previewPlayerKeys(tracks, assets).get("b")).toBe("b");
});
it("prepares a covered lower track at the time it will be revealed", () => {
const segments = previewSegments([track([clip("top", 0, 2000)]), track([clip("lower", 0, 6000, { sourceStartMs: 8000 })])], assets);
expect(segments.map((segment) => [segment.startMs, segment.clips.map((clip) => clip.id)])).toEqual([
[0, ["top"]], [2000, ["lower"]], [6000, []],
]);
const prepared = preparedPreviewClips(segments, 0);
expect(prepared.map((entry) => [entry.clip.id, entry.prepareAtMs])).toEqual([["top", 0], ["lower", 2000]]);
expect(prepared[1].clip.sourceStartMs + prepared[1].prepareAtMs - prepared[1].clip.startMs).toBe(10000);
});
it("retains transition layers only while revealed and prepares beyond gaps", () => {
const segments = previewSegments([
track([clip("fade", 1000, 2000, { transition: { type: "fade", durationMs: 500 } }), clip("later", 5000, 1000)]),
track([clip("lower", 1000, 2000)]),
], assets);
expect(segments.map((segment) => [segment.startMs, segment.clips.map((clip) => clip.id)])).toEqual([
[0, []], [1000, ["fade", "lower"]], [1500, ["fade"]], [3000, []], [5000, ["later"]], [6000, []],
]);
expect(previewSegmentIndex(segments, 1499)).toBe(1);
expect(previewSegmentIndex(segments, 1500)).toBe(2);
expect(previewSegmentIndex(segments, 99999)).toBe(5);
expect(preparedPreviewClips(segments, 2).map((entry) => entry.clip.id)).toEqual(["fade", "later"]);
});
it("bounds prepared players to the current and next two pictures, even for repeated assets", () => {
const segments = previewSegments([track(Array.from({ length: 30 }, (_, index) => clip(String(index), index * 1000, 1000)))], assets);
expect(preparedPreviewClips(segments, 0).map((entry) => entry.clip.id)).toEqual(["0", "1", "2"]);
expect(preparedPreviewClips(segments, 1).map((entry) => entry.clip.id)).toEqual(["1", "2", "3"]);
expect(preparedPreviewClips(segments, 30)).toEqual([]);
});
});