Skip to content

Code-first video & image, rendered natively on WebGPU.

5.4 KB
Raw Blame
import { describe, expect, it } from "vitest";
import {
	calculateSequenceTimeline,
	computeCarrierContinuity,
	Scene,
	Sequence,
} from "./sequence.js";

describe("Cinematic Sequencing & Carrier Match Cuts", () => {
	it("calculates sequential timeline offsets without overlap", () => {
		const scenes = [
			{ id: "act-1", durationFrames: 60 },
			{ id: "act-2", durationFrames: 90 },
			{ id: "act-3", durationFrames: 45 },
		];

		const result = calculateSequenceTimeline(scenes, 60);

		expect(result.totalFrames).toBe(195);
		expect(result.totalDurationMs).toBe(3250);
		expect(result.sceneOffsets).toEqual([
			{ sceneId: "act-1", startFrame: 0, durationFrames: 60 },
			{ sceneId: "act-2", startFrame: 60, durationFrames: 90 },
			{ sceneId: "act-3", startFrame: 150, durationFrames: 45 },
		]);
	});

	it("calculates timeline with transition overlap", () => {
		const scenes = [
			{ id: "act-1", durationFrames: 60, transitionOverlap: 10 },
			{ id: "act-2", durationFrames: 60, transitionOverlap: 15 },
			{ id: "act-3", durationFrames: 60 },
		];

		const result = calculateSequenceTimeline(scenes, 60);

		// act-1: 0..60 (advance by 50)
		// act-2: 50..110 (advance by 45)
		// act-3: 95..155
		expect(result.sceneOffsets[0]?.startFrame).toBe(0);
		expect(result.sceneOffsets[1]?.startFrame).toBe(50);
		expect(result.sceneOffsets[2]?.startFrame).toBe(95);
		expect(result.totalFrames).toBe(155);
	});

	it("computes carrier state continuity across cuts", () => {
		const outgoingState = {
			x: 960,
			y: 540,
			scale: 1.2,
			vx: 15.5,
			vy: -4.2,
		};

		const incomingContinuousState = computeCarrierContinuity(outgoingState, {
			scale: 1.0,
		});

		expect(incomingContinuousState.x).toBe(960);
		expect(incomingContinuousState.y).toBe(540);
		expect(incomingContinuousState.vx).toBe(15.5);
		expect(incomingContinuousState.vy).toBe(-4.2);
		expect(incomingContinuousState.scale).toBe(1.0);
	});

	it("compiles sequenced scenes into a unified compositor program", () => {
		const seq = Sequence.create({
			fps: 60,
			width: 1920,
			height: 1080,
			backgroundColor: "#fdfbf7",
		});

		const scene1 = Scene.create({
			id: "hook",
			chapter: "hook",
			durationFrames: 60,
			layout: [
				{
					id: "card-1",
					kind: "box",
					background: "#ffffff",
					width: 400,
					height: 300,
					startFrame: 0,
					durationFrames: 60,
				},
			],
		});

		const scene2 = Scene.create({
			id: "solution",
			chapter: "solution",
			durationFrames: 90,
			layout: [
				{
					id: "card-2",
					kind: "box",
					background: "#f0f4ff",
					width: 500,
					height: 400,
					startFrame: 5,
				},
			],
		});

		seq.addScene(scene1);
		seq.addScene(scene2);

		const program = seq.toProgram();

		expect(program.fps).toBe(60);
		expect(program.width).toBe(1920);
		expect(program.height).toBe(1080);
		expect(program.backgroundColor).toBe("#fdfbf7");
		expect(program.layout.length).toBe(2);

		// scene 1 node
		expect(program.layout[0]?.id).toBe("card-1");
		expect(program.layout[0]?.startFrame).toBe(0);

		// scene 2 node should be offset by 60 frames
		expect(program.layout[1]?.id).toBe("card-2");
		expect(program.layout[1]?.startFrame).toBe(65);
		expect(program.layout[1]?.durationFrames).toBe(85);
	});
});

describe("sequence window boundaries", () => {
	it("does not subtract a final outgoing overlap", () => {
		const result = calculateSequenceTimeline(
			[{ id: "a", durationFrames: 60, transitionOut: { durationFrames: 10 } }],
			30,
		);
		expect(result.totalFrames).toBe(60);
		expect(result.totalDurationMs).toBe(2000);
	});
	it("measures the union of fully overlapping scenes", () => {
		const result = calculateSequenceTimeline(
			[
				{ id: "a", durationFrames: 60, transitionOverlap: 30 },
				{ id: "b", durationFrames: 30, transitionOverlap: 10 },
			],
			30,
		);
		expect(result.sceneOffsets[1].startFrame).toBe(30);
		expect(result.totalFrames).toBe(60);
	});
	it("rejects overlap longer than either adjacent scene", () => {
		expect(() =>
			calculateSequenceTimeline([
				{ id: "a", durationFrames: 60, transitionOverlap: 31 },
				{ id: "b", durationFrames: 30 },
			]),
		).toThrow(/a.*overlap/);
	});
	it("validates numeric boundaries and empty sequences", () => {
		expect(calculateSequenceTimeline([]).totalFrames).toBe(0);
		for (const durationFrames of [0, -1, 1.5, Infinity, NaN])
			expect(() =>
				calculateSequenceTimeline([{ id: "bad", durationFrames }]),
			).toThrow(/bad/);
		expect(() =>
			calculateSequenceTimeline([{ id: "tiny", durationMs: 0.1 }], 30),
		).toThrow(/tiny/);
		expect(() => calculateSequenceTimeline([], NaN)).toThrow(/fps/);
	});
	it("ends delayed layers at their scene boundary without mutating inputs", () => {
		const layer = { id: "late", kind: "box" as const, startFrame: 30 };
		const sequence = Sequence.create().addScene({
			id: "a",
			durationFrames: 60,
			layout: [layer],
		});
		expect(sequence.toProgram().layout[0]).toMatchObject({
			startFrame: 30,
			durationFrames: 30,
		});
		expect(sequence.toProgram()).toEqual(sequence.toProgram());
		expect(layer).not.toHaveProperty("durationFrames");
	});
	it("rejects explicit windows outside their owning scene", () => {
		for (const node of [
			{ id: "late", kind: "box" as const, startFrame: 60 },
			{ id: "long", kind: "box" as const, startFrame: 30, durationFrames: 31 },
		]) {
			expect(() =>
				Sequence.create()
					.addScene({ id: "a", durationFrames: 60, layout: [node] })
					.toProgram(),
			).toThrow(/a.*window/);
		}
	});
});