Write HTML. Render video. Built for agents.
JavaScript aiai-agentsanimationclaude-codeffmpegframeworkgsaphtmlhtml-to-videomcpmotion-graphicspuppeteerrenderingtypescriptvideo-editor
import { describe, expect, it } from "vitest";
import {
collectSamplingTargets,
evaluateMotion,
type FrameSample,
type MotionFrame,
} from "./motionAudit.js";
import type { LayoutIssue } from "./layoutAudit.js";
import type { MotionAssertion } from "./motionSpec.js";
const CANVAS = { width: 1920, height: 1080 };
function expectOne(issues: LayoutIssue[]): LayoutIssue {
expect(issues).toHaveLength(1);
const issue = issues[0];
if (!issue) throw new Error("expected exactly one issue");
return issue;
}
function rect(left: number, top: number, width: number, height: number) {
return { left, top, right: left + width, bottom: top + height, width, height };
}
function visible(r = rect(100, 100, 200, 80), opacity = 1): FrameSample {
return { rect: r, opacity, visible: true };
}
const hidden: FrameSample = { rect: rect(0, 0, 0, 0), opacity: 0, visible: false };
/** Build frames at the given times; `at(time)` supplies per-selector samples + liveness. */
function frames(
times: number[],
at: (time: number) => {
data?: Record<string, FrameSample | null>;
liveness?: Record<string, string>;
},
): MotionFrame[] {
return times.map((time) => {
const { data = {}, liveness = {} } = at(time);
return { time, data, liveness: { "*": "x", ...liveness } };
});
}
describe("appearsBy", () => {
const assertion: MotionAssertion = { kind: "appearsBy", selector: "#h", bySec: 0.5 };
it("passes when visible by the deadline", () => {
const f = frames([0.1, 0.3, 0.6], (t) => ({ data: { "#h": t >= 0.3 ? visible() : hidden } }));
expect(evaluateMotion(f, [assertion], CANVAS)).toEqual([]);
});
it("flags a late entrance with both times", () => {
const f = frames([0.3, 0.83, 1.2], (t) => ({ data: { "#h": t >= 0.83 ? visible() : hidden } }));
const issue = expectOne(evaluateMotion(f, [assertion], CANVAS));
expect(issue.code).toBe("motion_appears_late");
expect(issue.message).toContain("0.83s");
expect(issue.message).toContain("0.5s");
});
it("flags an element that never reaches visible opacity", () => {
const f = frames([0.3, 0.6], () => ({
data: { "#h": { rect: rect(0, 0, 10, 10), opacity: 0.2, visible: true } },
}));
const issue = expectOne(evaluateMotion(f, [assertion], CANVAS));
expect(issue.code).toBe("motion_appears_late");
expect(issue.message).toContain("never");
});
it("flags a selector that matches nothing", () => {
const f = frames([0.3, 0.6], () => ({ data: { "#h": null } }));
const issue = expectOne(evaluateMotion(f, [assertion], CANVAS));
expect(issue.code).toBe("motion_selector_missing");
});
});
describe("before", () => {
const assertion: MotionAssertion = { kind: "before", a: "#a", b: "#b" };
it("passes when a appears before b", () => {
const f = frames([0.2, 0.4], (t) => ({
data: { "#a": visible(), "#b": t >= 0.4 ? visible() : hidden },
}));
expect(evaluateMotion(f, [assertion], CANVAS)).toEqual([]);
});
it("flags reversed order", () => {
const f = frames([0.2, 0.4], (t) => ({
data: { "#a": t >= 0.4 ? visible() : hidden, "#b": visible() },
}));
const issue = expectOne(evaluateMotion(f, [assertion], CANVAS));
expect(issue.code).toBe("motion_out_of_order");
});
it("treats a simultaneous appearance as out of order (strict before)", () => {
const f = frames([0.2, 0.4], () => ({ data: { "#a": visible(), "#b": visible() } }));
const issue = expectOne(evaluateMotion(f, [assertion], CANVAS));
expect(issue.code).toBe("motion_out_of_order");
});
});
describe("staysInFrame", () => {
const assertion: MotionAssertion = { kind: "staysInFrame", selector: ".card" };
it("passes when the box stays inside the canvas", () => {
const f = frames([0, 1, 2], () => ({ data: { ".card": visible(rect(100, 100, 200, 80)) } }));
expect(evaluateMotion(f, [assertion], CANVAS)).toEqual([]);
});
it("flags drift past the right edge", () => {
const f = frames([0, 1, 2], (t) => ({
data: { ".card": visible(rect(t >= 2 ? 1850 : 100, 100, 200, 80)) },
}));
const issue = expectOne(evaluateMotion(f, [assertion], CANVAS));
expect(issue.code).toBe("motion_off_frame");
expect(issue.time).toBe(2);
});
it("ignores off-canvas position before the element is first visible", () => {
const f = frames([0, 1], (t) => ({
data: {
".card":
t < 1
? { rect: rect(5000, 0, 100, 100), opacity: 0, visible: false }
: visible(rect(100, 100, 200, 80)),
},
}));
expect(evaluateMotion(f, [assertion], CANVAS)).toEqual([]);
});
});
describe("keepsMoving", () => {
it("passes when the signature changes every frame", () => {
const assertion: MotionAssertion = { kind: "keepsMoving" };
const f = frames([0, 1, 2, 3], (t) => ({ liveness: { "*": `sig-${t}` } }));
expect(evaluateMotion(f, [assertion], CANVAS)).toEqual([]);
});
it("flags a static window longer than the threshold", () => {
const assertion: MotionAssertion = { kind: "keepsMoving", maxStaticSec: 2 };
// frozen 1s..4s (3s static) then moves
const f = frames([0, 1, 2, 3, 4, 5], (t) => ({
liveness: { "*": t >= 1 && t <= 4 ? "frozen" : `m-${t}` },
}));
const issue = expectOne(evaluateMotion(f, [assertion], CANVAS));
expect(issue.code).toBe("motion_frozen");
expect(issue.time).toBe(1);
});
it("scopes liveness to withinSelector", () => {
const assertion: MotionAssertion = {
kind: "keepsMoving",
withinSelector: ".scene",
maxStaticSec: 1,
};
// .scene frozen the whole time, whole-canvas "*" moving — only the scope matters
const f = frames([0, 1, 2, 3], (t) => ({ liveness: { "*": `m-${t}`, ".scene": "frozen" } }));
const issue = expectOne(evaluateMotion(f, [assertion], CANVAS));
expect(issue.code).toBe("motion_frozen");
expect(issue.selector).toBe(".scene");
});
it("leaves a 3 s still end card out of the static run when the film's duration is known", () => {
const assertion: MotionAssertion = { kind: "keepsMoving" };
const times = Array.from({ length: 21 }, (_, index) => index);
const endCard = frames(times, (t) => ({ liveness: { "*": t >= 17 ? "card" : `m-${t}` } }));
expect(evaluateMotion(endCard, [assertion], CANVAS)).toHaveLength(1);
expect(evaluateMotion(endCard, [assertion], CANVAS, 20)).toEqual([]);
});
it("still flags stillness that starts before the end card", () => {
const assertion: MotionAssertion = { kind: "keepsMoving" };
const times = Array.from({ length: 21 }, (_, index) => index);
const longHold = frames(times, (t) => ({ liveness: { "*": t >= 14 ? "card" : `m-${t}` } }));
const issue = expectOne(evaluateMotion(longHold, [assertion], CANVAS, 20));
expect(issue.code).toBe("motion_frozen");
expect(issue.message).toContain("between 14s and 17s");
});
it("flags a missing withinSelector instead of reporting it frozen", () => {
const assertion: MotionAssertion = { kind: "keepsMoving", withinSelector: ".nope" };
const f = frames([0, 1, 2], () => ({ liveness: { "*": "moving" } }));
const issue = expectOne(evaluateMotion(f, [assertion], CANVAS));
expect(issue.code).toBe("motion_selector_missing");
});
});
describe("evaluateMotion edge cases", () => {
it("returns nothing for an empty frame set", () => {
expect(evaluateMotion([], [{ kind: "appearsBy", selector: "#h", bySec: 1 }], CANVAS)).toEqual(
[],
);
});
});
describe("collectSamplingTargets", () => {
it("collects selectors and liveness scopes without duplicates", () => {
const targets = collectSamplingTargets([
{ kind: "appearsBy", selector: "#h", bySec: 0.5 },
{ kind: "before", a: "#h", b: "#cta" },
{ kind: "staysInFrame", selector: ".card" },
{ kind: "keepsMoving", withinSelector: ".scene" },
{ kind: "keepsMoving" },
]);
expect(targets.selectors.sort()).toEqual(["#cta", "#h", ".card"]);
expect(targets.livenessScopes.sort()).toEqual(["*", ".scene"]);
});
});