From f3e5b81dfebb2460338dfefd31d4e3509b05ca08 Mon Sep 17 00:00:00 2001 From: James Russo Date: Thu, 5 Nov 2026 04:59:48 +0000 Subject: [PATCH] test(engine): pin the motion blur sweep defects A to O by their symptoms (#7149) Adds 13 text-free fixtures from the 60-composition capture motion blur sweep and one test per defect, each pinned by its current symptom so it fails once the fix lands. Pins use the existing outside and inside invariants where they see the defect, and a second check against the engine's 32-sample sub-frame blur where they do not (E, J, K, M). Co-authored-by: Claude Opus 5.5 (1M context) --- .../__fixtures__/motionBlur/sweepFixtures.ts | 159 +++++++ .../__fixtures__/motionBlur/thresholds.ts | 27 ++ .../captureMotionBlur.sweep.browser.test.ts | 390 ++++++++++++++++++ 3 files changed, 576 insertions(+) create mode 100644 packages/engine/src/services/__fixtures__/motionBlur/sweepFixtures.ts create mode 100644 packages/engine/src/services/captureMotionBlur.sweep.browser.test.ts diff --git a/packages/engine/src/services/__fixtures__/motionBlur/sweepFixtures.ts b/packages/engine/src/services/__fixtures__/motionBlur/sweepFixtures.ts new file mode 100644 index 0000000000..297ae7dddd --- /dev/null +++ b/packages/engine/src/services/__fixtures__/motionBlur/sweepFixtures.ts @@ -0,0 +1,159 @@ +import { readFileSync } from "node:fs"; +import { createRequire } from "node:module"; +import { resolve } from "node:path"; + +// One composition per defect from the 60-composition motion blur sweep. Each is 640x360, 30 fps, 1 s, +// and its mover #m travels x 0 to 480 between 0.25 s and 0.75 s (32 px a frame). No text anywhere, so +// no pin depends on how a host rasterises glyphs. + +export type Tier = "capture" | "filter"; + +interface SweepFixture { + name: string; + width: 640; + height: 360; + dpr: 1; + durationSeconds: 1; + fps: 30; + html(blur: "on" | "off", tier: Tier): string; +} + +const repoRoot = resolve(import.meta.dirname, "../../../../../.."); +const GSAP = readFileSync( + createRequire(resolve(repoRoot, "packages/core/package.json")).resolve("gsap/dist/gsap.min.js"), + "utf8", +); + +const BASE_CSS = ` + * { margin: 0; padding: 0; box-sizing: border-box } + html, body { width: 640px; height: 360px; overflow: hidden; background: #000 } + #root { position: relative; width: 640px; height: 360px; overflow: hidden; + background: linear-gradient(135deg, #1d3557 0%, #457b9d 50%, #2a9d8f 100%) } + .deco { position: absolute; width: 40px; height: 40px; border-radius: 50%; background: #f1faee } + .m { position: absolute; left: 40px; top: 140px; width: 120px; height: 80px; background: #e76f51; border: 4px solid #fff }`; + +const DECO = Array.from( + { length: 9 }, + (_, i) => `
`, +).join(""); + +const MOVER = `
`; +const SLIDE = `tl.fromTo("#m", { x: 0 }, { x: 480, duration: 0.5, ease: "none" }, 0.25);`; +const STRIPES = `
`; + +interface Spec { + name: string; + css?: string; + body?: string; + script?: string; +} + +const rootAttrs = (blur: "on" | "off", tier: Tier): string => + blur === "off" + ? 'data-motion-blur="off"' + : `data-motion-blur="on" data-motion-blur-tier="${tier}"`; + +function sweepFixture(spec: Spec): SweepFixture { + return { + name: spec.name, + width: 640, + height: 360, + dpr: 1, + durationSeconds: 1, + fps: 30, + html: (blur, tier) => ` +
${DECO}${spec.body ?? MOVER}
+ + `, + }; +} + +const card = (style: string): string => + `
`; + +const SWEEP_FIXTURES = [ + // Control: a plain mover. Both tiers draw it the way the oracle does. + sweepFixture({ name: "plain" }), + // A: a static panel painted over the mover. + sweepFixture({ + name: "behind-panel", + css: ".m { z-index: 1 }", + body: `${MOVER}
`, + }), + // B: the mover blends with what is under it. + sweepFixture({ + name: "blend-difference", + css: ".m { background: #fff; mix-blend-mode: difference }", + body: STRIPES + MOVER, + }), + // C: an ancestor casts a drop shadow from the mover. + sweepFixture({ + name: "ancestor-drop-shadow", + body: `
${MOVER}
`, + }), + // D: generated content drawn outside the mover's box. + sweepFixture({ + name: "pseudo-after", + css: ".m::after { content: ''; position: absolute; left: 130px; top: 10px; width: 60px; height: 60px; background: #ffd166; border-radius: 50% }", + }), + // E: the mover's own clip-path. + sweepFixture({ + name: "own-clip-polygon", + css: ".m { clip-path: polygon(50% 0, 100% 100%, 0 100%) }", + }), + // F: a position:fixed child of a mover that moves through left. + sweepFixture({ + name: "fixed-child-left", + body: `
`, + script: `tl.fromTo("#m", { left: 40 }, { left: 520, duration: 0.5, ease: "none" }, 0.25);`, + }), + // H: an author selector that goes through the root's parent. + sweepFixture({ name: "body-child-selector", css: "body > #root > .m { background: #06d6a0 }" }), + // I: an author selector on the root's last child. + sweepFixture({ + name: "last-child-selector", + css: "#root > :last-child { outline: 6px solid #ffd166 }", + body: `${MOVER}
`, + }), + // J: an overflow:hidden card the mover slides into. + sweepFixture({ name: "overflow-card", body: card("overflow:hidden;border-radius:24px") }), + // K: two movers that cross. + sweepFixture({ + name: "overlapping-movers", + css: ".m2 { position: absolute; left: 480px; top: 150px; width: 120px; height: 80px; background: #2a9d8f; border: 4px solid #000 }", + body: `${MOVER}
`, + script: `${SLIDE} tl.fromTo("#m2", { x: 0 }, { x: -440, duration: 0.5, ease: "none" }, 0.25);`, + }), + // M: movers that rise in from below the frame edge. + sweepFixture({ + name: "rise-from-below", + css: ".r { position: absolute; top: 300px; width: 40px; height: 40px; background: #ffd166; border: 3px solid #000 }", + body: Array.from( + { length: 9 }, + (_, i) => `
`, + ).join(""), + script: `tl.from(".r", { y: 120, duration: 0.3, ease: "none", stagger: 0.012 }, 0.2);`, + }), + // O: the mover is hidden half way through a frame's shutter. + sweepFixture({ + name: "visibility-toggle", + script: `${SLIDE} tl.set("#m", { visibility: "hidden" }, 0.5);`, + }), +] as const satisfies readonly SweepFixture[]; + +export type SweepFixtureName = (typeof SWEEP_FIXTURES)[number]["name"]; + +export function sweepFixtureNamed(name: SweepFixtureName): SweepFixture { + const f = SWEEP_FIXTURES.find((x) => x.name === name); + if (!f) throw new Error(`missing sweep fixture ${name}`); + return f; +} diff --git a/packages/engine/src/services/__fixtures__/motionBlur/thresholds.ts b/packages/engine/src/services/__fixtures__/motionBlur/thresholds.ts index a64e573c6b..774308bfb4 100644 --- a/packages/engine/src/services/__fixtures__/motionBlur/thresholds.ts +++ b/packages/engine/src/services/__fixtures__/motionBlur/thresholds.ts @@ -42,3 +42,30 @@ export const INVARIANTS = { minCheckedFraction: 0.5, shutterSamples: 8, }; + +// Oracle: the engine's 32-sample sub-frame blur. Noise: worst tile MAE on the sweep fixtures' clean frames. +export const MEASURED_ORACLE_NOISE = 3.94; +export const MEASURED_ORACLE_SMALLEST_SYMPTOM = 14.47; + +export const ORACLE = { + samples: 32, + maxMae: geometricMean(MEASURED_ORACLE_NOISE, MEASURED_ORACLE_SMALLEST_SYMPTOM), +}; + +export const SWEEP_SYMPTOMS = { + A: 47.67, + B: 148.63, + C: 73.02, + D_CAPTURE: 107.66, + D_FILTER: 107.66, + E: 27.6, + F_CAPTURE: 40.62, + F_FILTER: 126.54, + H: 135.67, + I: 53.63, + J: 25.79, + K: MEASURED_ORACLE_SMALLEST_SYMPTOM, + M: 18.31, + O_CAPTURE: 50.38, + O_FILTER: 50.38, +} as const; diff --git a/packages/engine/src/services/captureMotionBlur.sweep.browser.test.ts b/packages/engine/src/services/captureMotionBlur.sweep.browser.test.ts new file mode 100644 index 0000000000..8ffe1cede1 --- /dev/null +++ b/packages/engine/src/services/captureMotionBlur.sweep.browser.test.ts @@ -0,0 +1,390 @@ +import type { Browser, Page } from "puppeteer-core"; +import { afterAll, beforeAll, describe, expect, it } from "vitest"; +import { + compareTiles, + meanFrame, + tilesOutsideRegion, + trailMask, + withinSymptomBand, + type Differential, + type Rect, + type Rgba, +} from "./__fixtures__/blurDifferential.js"; +import { closeTestChrome } from "./__fixtures__/loopback.js"; +import { + captureFrame, + hasBrowser, + launch, + openFixture, + type BlurWindow, +} from "./__fixtures__/motionBlur/blurPage.js"; +import { + sweepFixtureNamed, + type SweepFixtureName, + type Tier, +} from "./__fixtures__/motionBlur/sweepFixtures.js"; +import { INVARIANTS, ORACLE, SWEEP_SYMPTOMS } from "./__fixtures__/motionBlur/thresholds.js"; +import { motionBlurSampleTimes, resolveMotionBlurPlan } from "./motionBlur.js"; + +const FPS = 30; +const frameTime = (n: number): number => n / FPS; +const SHUTTER_DIVISIONS = 24; +const SHUTTER_SECONDS = 240 / 360 / FPS; +const RADIUS_PX = 2; +const CASE_TIMEOUT_MS = 60_000; + +const ORACLE_PLAN = resolveMotionBlurPlan({ + samplesPerFrame: ORACLE.samples, + shutterAngle: 240, + shutterPhase: -120, + blend: "srgb", +}); + +/** + * outside: blur on equals blur off away from every trail (invariant 1). + * inside: blur on is close to the mean of 8 blur-off shutter samples inside the trail (invariant 2). + * oracle: blur on is close, over the whole frame, to the engine's own 32-sample sub-frame blur. It is + * stricter than the shutter mean and sees defects too small or too spread out for the two invariants. + */ +type Check = "outside" | "inside" | "oracle"; + +interface KnownBug { + finding: string; + reason: string; + /** Every bad tile must touch one of these rects, in CSS px. */ + regions: readonly Rect[]; + measuredMae: number; +} + +interface SweepCase { + fixture: SweepFixtureName; + tier: Tier; + frame: number; + check: Check; + bug?: KnownBug; +} + +const rect = (x: number, y: number, width: number, height: number): Rect => ({ + x, + y, + width, + height, +}); + +const S = SWEEP_SYMPTOMS; +const mover = (left: number): Rect => rect(left, 140, 120, 80); +// A trail: the mover's box widened by the 21 px it travels in one 240 degree shutter. +const trail = (left: number): Rect => rect(left - 21, 140, 162, 80); + +const CASES: readonly SweepCase[] = [ + { fixture: "plain", tier: "capture", frame: 14, check: "oracle" }, + { fixture: "plain", tier: "filter", frame: 14, check: "oracle" }, + { + fixture: "behind-panel", + tier: "capture", + frame: 14, + check: "outside", + bug: { + finding: "A", + reason: "a static panel in front of the mover is painted over by its trail", + regions: [rect(260, 100, 120, 160)], + measuredMae: S.A, + }, + }, + { + fixture: "blend-difference", + tier: "capture", + frame: 11, + check: "inside", + bug: { + finding: "B", + reason: "a mix-blend-mode mover is captured alone, so it blends with nothing", + regions: [trail(152)], + measuredMae: S.B, + }, + }, + { + fixture: "ancestor-drop-shadow", + tier: "capture", + frame: 14, + check: "inside", + bug: { + finding: "C", + reason: "the drop shadow an ancestor casts from the mover is missing", + regions: [rect(227, 140, 176, 100)], + measuredMae: S.C, + }, + }, + ...(["capture", "filter"] as const).map( + (tier): SweepCase => ({ + fixture: "pseudo-after", + tier, + frame: 14, + check: "inside", + bug: { + finding: "D", + reason: "an ::after drawn outside the mover's box is cut off", + regions: [rect(376, 150, 72, 68)], + measuredMae: tier === "capture" ? S.D_CAPTURE : S.D_FILTER, + }, + }), + ), + { + fixture: "own-clip-polygon", + tier: "filter", + frame: 14, + check: "oracle", + bug: { + finding: "E", + reason: "the mover's own clip-path cuts its smear to a hard edge", + regions: [trail(248)], + measuredMae: S.E, + }, + }, + { + fixture: "fixed-child-left", + tier: "capture", + frame: 11, + check: "outside", + bug: { + finding: "F", + reason: "a fixed child of a mover that moves through left is smeared along the path", + regions: [rect(10, 10, 60, 30)], + measuredMae: S.F_CAPTURE, + }, + }, + { + fixture: "fixed-child-left", + tier: "filter", + frame: 11, + check: "outside", + bug: { + finding: "F", + reason: + "the blur filter makes the mover a containing block, so its fixed child jumps into it", + regions: [rect(10, 10, 60, 30), trail(152)], + measuredMae: S.F_FILTER, + }, + }, + { + fixture: "body-child-selector", + tier: "capture", + frame: 4, + check: "outside", + bug: { + finding: "H", + reason: + "a selector through the root's parent stops matching once the root is wrapped, still frames included", + regions: [mover(40)], + measuredMae: S.H, + }, + }, + { + fixture: "last-child-selector", + tier: "filter", + frame: 11, + check: "outside", + bug: { + finding: "I", + reason: "the filter tier's svg becomes the root's last child, so :last-child moves to it", + regions: [rect(0, 0, 0, 0), rect(494, 14, 112, 62)], + measuredMae: S.I, + }, + }, + { + fixture: "overflow-card", + tier: "capture", + frame: 11, + check: "oracle", + bug: { + finding: "J", + reason: "the clip edge of an overflow:hidden card travels with the mover sliding into it", + regions: [rect(200, 140, 0, 80)], + measuredMae: S.J, + }, + }, + { + fixture: "overlapping-movers", + tier: "capture", + frame: 15, + check: "oracle", + bug: { + finding: "K", + reason: "two crossing movers each carry a ghost of the other in their trail", + regions: [rect(260, 150, 140, 70)], + measuredMae: S.K, + }, + }, + { + fixture: "rise-from-below", + tier: "capture", + frame: 14, + check: "oracle", + bug: { + finding: "M", + reason: "content rising in from below the frame leaves a band at the bottom edge", + regions: [rect(0, 350, 640, 10)], + measuredMae: S.M, + }, + }, + ...(["capture", "filter"] as const).map( + (tier): SweepCase => ({ + fixture: "visibility-toggle", + tier, + frame: 15, + check: "inside", + bug: { + finding: "O", + reason: "a mover hidden half way through the shutter is drawn at full strength, not half", + regions: [trail(280)], + measuredMae: tier === "capture" ? S.O_CAPTURE : S.O_FILTER, + }, + }), + ), +]; + +function neighbourTimes(n: number): number[] { + const r = INVARIANTS.radiusFrames; + return Array.from({ length: 2 * r + 1 }, (_, k) => frameTime(n - r + k)); +} + +function shutterTimes(n: number): number[] { + const t = frameTime(n); + const samples = INVARIANTS.shutterSamples; + return Array.from( + { length: samples }, + (_, k) => t - SHUTTER_SECONDS / 2 + ((k + 0.5) * SHUTTER_SECONDS) / samples, + ); +} + +async function captureInOrder( + page: Page, + times: readonly number[], + options?: { subFrameDivisions?: number }, +): Promise { + const frames: Rgba[] = []; + for (const t of times) frames.push(await captureFrame(page, t, options)); + return frames; +} + +async function blurOffReference( + page: Page, + c: SweepCase, +): Promise<{ reference: Rgba; mask: Uint8Array }> { + if (c.check === "outside") { + const frames = await captureInOrder(page, neighbourTimes(c.frame)); + const reference = frames[INVARIANTS.radiusFrames]; + if (!reference) throw new Error("missing reference frame"); + return { reference, mask: trailMask(frames, RADIUS_PX) }; + } + if (c.check === "inside") { + const samples = await captureInOrder(page, shutterTimes(c.frame), { + subFrameDivisions: SHUTTER_DIVISIONS, + }); + return { reference: meanFrame(samples), mask: trailMask(samples, RADIUS_PX) }; + } + if (!ORACLE_PLAN) throw new Error("no oracle plan"); + const samples = await captureInOrder( + page, + motionBlurSampleTimes(ORACLE_PLAN, c.frame, FPS, ORACLE.samples), + { subFrameDivisions: ORACLE_PLAN.subFrameDivisions }, + ); + const reference = meanFrame(samples); + return { reference, mask: new Uint8Array(reference.width * reference.height).fill(1) }; +} + +const MAX_MAE: Record = { + outside: INVARIANTS.outsideMaxMae, + inside: INVARIANTS.insideMaxMae, + oracle: ORACLE.maxMae, +}; + +async function measure( + browser: Browser, + c: SweepCase, +): Promise<{ d: Differential; tier: string | null | undefined }> { + const f = sweepFixtureNamed(c.fixture); + const size = { width: f.width, height: f.height }; + const off = await openFixture(browser, f.html("off", c.tier), f.dpr, size); + let reference: { reference: Rgba; mask: Uint8Array }; + try { + reference = await blurOffReference(off, c); + } finally { + await off.close(); + } + const on = await openFixture(browser, f.html("on", c.tier), f.dpr, size); + try { + const onFrame = await captureFrame(on, frameTime(c.frame)); + const report = await on.evaluate(() => (window as BlurWindow).__hfMotionBlur?.probe()); + const d = compareTiles( + reference.reference, + onFrame, + reference.mask, + c.check === "outside" ? "outside" : "inside", + { + block: INVARIANTS.block, + maxMae: MAX_MAE[c.check], + }, + ); + return { d, tier: report?.tier }; + } finally { + await on.close(); + } +} + +const tilesOutsideRegions = (d: Differential, regions: readonly Rect[]): Differential["bad"] => + regions.reduce((bad, region) => tilesOutsideRegion(bad, INVARIANTS.block, region, 1), d.bad); + +const firstFive = (d: Differential): string => JSON.stringify(d.bad.slice(0, 5)); + +function describeCase(c: SweepCase): string { + const where = `${c.check}, ${c.tier} tier, ${c.fixture} frame ${c.frame}`; + return c.bug + ? `KNOWN BUG on main: ${c.bug.finding}: ${c.bug.reason} (${where})` + : `blur on matches the reference (${where})`; +} + +let launched: Browser | undefined; +let supported = false; + +function chrome(): Browser { + if (!launched) throw new Error("Chrome did not launch"); + return launched; +} + +describe.skipIf(!hasBrowser)("capture motion blur sweep defects in Chrome", () => { + beforeAll(async () => { + ({ browser: launched, supported } = await launch()); + }, 30_000); + afterAll(() => closeTestChrome(launched)); + + for (const c of CASES) { + it( + describeCase(c), + async (ctx) => { + if (!supported) ctx.skip(); + const { d, tier } = await measure(chrome(), c); + expect(tier, `${c.fixture} did not blur on the ${c.tier} tier`).toBe(c.tier); + expect(d.checkedBlocks).toBeGreaterThan(0); + const { bug } = c; + if (!bug) { + expect(d.bad, `${c.fixture} ${firstFive(d)}`).toEqual([]); + return; + } + expect( + d.bad.length, + `${bug.finding} looks fixed: delete this case's \`bug\`, which keeps it as a check that blur on matches the reference`, + ).toBeGreaterThan(0); + expect( + tilesOutsideRegions(d, bug.regions), + `a new defect outside ${JSON.stringify(bug.regions)}: ${firstFive(d)}`, + ).toEqual([]); + expect( + withinSymptomBand(d.worstMae, bug.measuredMae), + `the pinned symptom changed: re-measure (worst MAE ${d.worstMae.toFixed(2)}, pinned at ${bug.measuredMae})`, + ).toBe(true); + }, + CASE_TIMEOUT_MS, + ); + } +});