Write HTML. Render video. Built for agents.
JavaScript aiai-agentsanimationclaude-codeffmpegframeworkgsaphtmlhtml-to-videomcpmotion-graphicspuppeteerrenderingtypescriptvideo-editor
feat(producer,studio): wire capture motion blur into renders and Studio (#5969)
Vance Ingalls1f8ead7bde73
diff --git a/packages/cli/src/capture/captureCompositionFrame.test.ts b/packages/cli/src/capture/captureCompositionFrame.test.tsindex 44f2c09c96..69fa311aa8 100644--- a/packages/cli/src/capture/captureCompositionFrame.test.ts+++ b/packages/cli/src/capture/captureCompositionFrame.test.ts@@ -16,6 +16,8 @@ import {resolveCropRegion,runFfmpegOnce,seekCompositionTimeline,+ seekCompositionTimelineOnly,+ settleCompositionSeek,waitForRuntimeReady,type CompositionSeekPage,} from "./captureCompositionFrame.js";@@ -116,6 +118,18 @@ describe("seekCompositionTimeline", () => {expect(evaluate).toHaveBeenNthCalledWith(4, expect.any(Function), { ms: 500, frames: 1 });});+ it("can seek without finishing the frame, so overlays land before a blurred frame is drawn", async () => {+ const { page, evaluate } = fakeSeekPage();++ await seekCompositionTimelineOnly(page, 1.25);+ expect(evaluate).toHaveBeenCalledTimes(1);+ expect(evaluate).toHaveBeenNthCalledWith(1, expect.any(Function), 1.25, false, false, false);++ await settleCompositionSeek(page);+ expect(evaluate).toHaveBeenNthCalledWith(2, expect.any(Function), { videoFrames: true });+ expect(evaluate).toHaveBeenCalledTimes(4);+ });+it("waitForFontsMs: 0 disables the post-seek font wait", async () => {const { page, evaluate } = fakeSeekPage();@@ -285,7 +299,7 @@ describe("seekCompositionTimeline", () => {}).then(() => {settled = true;});- await Promise.resolve();+ await new Promise((resolve) => setTimeout(resolve, 0));expect(evaluateCall).toBe(2);expect(settled).toBe(false);completeGpu?.();diff --git a/packages/cli/src/capture/captureCompositionFrame.ts b/packages/cli/src/capture/captureCompositionFrame.tsindex a06cb22802..065bb610bc 100644--- a/packages/cli/src/capture/captureCompositionFrame.ts+++ b/packages/cli/src/capture/captureCompositionFrame.ts@@ -510,6 +510,16 @@ export async function seekCompositionTimeline(page: CompositionSeekPage,timeSeconds: number,options: SeekCompositionTimelineOptions = {},+): Promise<void> {+ await seekCompositionTimelineOnly(page, timeSeconds, options);+ await settleCompositionSeek(page, options);+}++/** The seek alone; `settleCompositionSeek` must follow, which is what finishes a blurred frame. */+export async function seekCompositionTimelineOnly(+ page: CompositionSeekPage,+ timeSeconds: number,+ options: SeekCompositionTimelineOptions = {},): Promise<void> {if (options.waitForPreferredSeekTargetMs !== undefined) {await waitForPreferredSeekTarget(page, options.waitForPreferredSeekTargetMs);@@ -522,7 +532,12 @@ export async function seekCompositionTimeline(options.exactTime === true,options.skipWebglDraws === true,);+}+export async function settleCompositionSeek(+ page: CompositionSeekPage,+ options: SeekCompositionTimelineOptions = {},+): Promise<void> {await page.evaluate(async (barrier: SeekBarrierOptions) => {const waitForCompletion = Reflect.get(window, "__hfWaitForSeekCompletion");diff --git a/packages/cli/src/commands/snapshot-contactSheet.test.ts b/packages/cli/src/commands/snapshot-contactSheet.test.tsindex 0f0b4e7a70..de1114f8c2 100644--- a/packages/cli/src/commands/snapshot-contactSheet.test.ts+++ b/packages/cli/src/commands/snapshot-contactSheet.test.ts@@ -31,6 +31,8 @@ vi.mock("../capture/captureCompositionFrame.js", async (importOriginal) => ({renderReadyTimedOut: false,})),seekCompositionTimeline: capture.seek,+ seekCompositionTimelineOnly: capture.seek,+ settleCompositionSeek: vi.fn(async () => undefined),}));vi.mock("../utils/staticProjectServer.js", () => ({diff --git a/packages/cli/src/commands/snapshot.test.ts b/packages/cli/src/commands/snapshot.test.tsindex 130de77f0a..df0413aa02 100644--- a/packages/cli/src/commands/snapshot.test.ts+++ b/packages/cli/src/commands/snapshot.test.ts@@ -14,13 +14,15 @@ const snapshotState = vi.hoisted(() => ({seek: vi.fn(async (_page: unknown, _time: number, _options?: unknown): Promise<void> => {throw new Error("seek reached");}),+ settle: vi.fn(async (_page: unknown, _options?: unknown): Promise<void> => undefined),closeServer: vi.fn(async () => undefined),}));vi.mock("../capture/captureCompositionFrame.js", async (importOriginal) => ({...(await importOriginal<typeof import("../capture/captureCompositionFrame.js")>()),openSettledCompositionPage: snapshotState.openSettledPage,- seekCompositionTimeline: snapshotState.seek,+ seekCompositionTimelineOnly: snapshotState.seek,+ settleCompositionSeek: snapshotState.settle,}));vi.mock("../utils/staticProjectServer.js", () => ({@@ -192,6 +194,57 @@ describe("snapshot --at seeks", () => {});});+describe("snapshot video overlays and the blurred frame", () => {+ // The runtime draws a blurred frame when the seek settles, so the video <img> overlays must+ // be in by then (the engine injects before it waits, too).+ it("settles the seek only after the video overlays were read and injected", async () => {+ const project = mkdtempSync(join(tmpdir(), "hf-snapshot-blur-order-"));+ writeFileSync(+ join(project, "index.html"),+ `<html><body><div data-composition-id="main" data-width="640" data-height="360" data-start="0" data-duration="3" data-motion-blur="on"><div class="clip" data-start="0" data-duration="3">Visible</div></div></body></html>`,+ );+ const log: string[] = [];+ let calls = 0;+ const evaluate = vi.fn(async () => {+ calls += 1;+ if (calls === 1) return { loaded: [], errored: [], unused: [] };+ if (calls === 2) return 3;+ if (calls === 3) return true;+ if (calls === 4) {+ log.push("read videos");+ return [];+ }+ return undefined;+ });+ snapshotState.openSettledPage.mockResolvedValueOnce({+ browser: { close: vi.fn(async () => undefined) },+ page: { evaluate },+ renderReadyTimedOut: false,+ });+ snapshotState.seek.mockReset();+ snapshotState.seek.mockImplementation(async () => {+ log.push("seek");+ });+ snapshotState.settle.mockClear();+ snapshotState.settle.mockImplementation(async () => {+ log.push("settle");+ });+ const logSpy = vi.spyOn(console, "log").mockImplementation(() => undefined);++ try {+ await expect(+ snapshotCommand.run?.({+ args: { dir: project, at: "1", end: false, output: join(project, "out") },+ } as never),+ ).rejects.toBeDefined();+ expect(log).toEqual(["seek", "read videos", "settle"]);+ } finally {+ logSpy.mockRestore();+ rmSync(project, { recursive: true, force: true });+ }+ });+});+describe("resolveSnapshotVideoFrameTime", () => {it("holds a clip ending with the composition on its last decodable frame", () => {expect(diff --git a/packages/cli/src/commands/snapshot.ts b/packages/cli/src/commands/snapshot.tsindex b7f12f9201..e382eeabed 100644--- a/packages/cli/src/commands/snapshot.ts+++ b/packages/cli/src/commands/snapshot.ts@@ -31,7 +31,8 @@ import {parseZoomTarget,resolveCropRegion,runFfmpegOnce,- seekCompositionTimeline,+ seekCompositionTimelineOnly,+ settleCompositionSeek,type ZoomTarget,} from "../capture/captureCompositionFrame.js";import {@@ -748,7 +749,8 @@ async function captureSnapshots(for (let i = 0; i < positions.length; i++) {const time = positions[i]!;- await seekCompositionTimeline(page, time, { exactTime: true });+ const seekOptions = { exactTime: true };+ await seekCompositionTimelineOnly(page, time, seekOptions);if (cameraExpr) await page.evaluate(cameraExpr);@@ -892,6 +894,7 @@ async function captureSnapshots(}}+ await settleCompositionSeek(page, seekOptions);await recaptureSnapshotComposite(page);const timeLabel = formatSnapshotTimestamp(time);diff --git a/packages/cli/src/server/studioServer.renderBrowser.test.ts b/packages/cli/src/server/studioServer.renderBrowser.test.tsindex b5b2539d14..5377205ede 100644--- a/packages/cli/src/server/studioServer.renderBrowser.test.ts+++ b/packages/cli/src/server/studioServer.renderBrowser.test.ts@@ -103,3 +103,37 @@ describe("Studio render GPU encoding", () => {expect(mocks.createRenderJob).toHaveBeenCalledWith(expect.objectContaining({ useGpu: true }));});});++describe("Studio render motion blur", () => {+ it("hands the route's pageMotionBlur to the job", async () => {+ mocks.resolveRenderBrowser.mockResolvedValue({+ executablePath: "/opt/chrome",+ source: "cache",+ });++ startStudioRender({ pageMotionBlur: "off" });+ await vi.waitFor(() => expect(mocks.createRenderJob).toHaveBeenCalledTimes(1), {+ timeout: 10_000,+ });++ expect(mocks.createRenderJob).toHaveBeenCalledWith(+ expect.objectContaining({ pageMotionBlur: "off" }),+ );+ });++ it("sends none when the route sent none", async () => {+ mocks.resolveRenderBrowser.mockResolvedValue({+ executablePath: "/opt/chrome",+ source: "cache",+ });++ startStudioRender();+ await vi.waitFor(() => expect(mocks.createRenderJob).toHaveBeenCalledTimes(1), {+ timeout: 10_000,+ });++ expect(mocks.createRenderJob).not.toHaveBeenCalledWith(+ expect.objectContaining({ pageMotionBlur: expect.anything() }),+ );+ });+});diff --git a/packages/cli/src/server/studioServer.ts b/packages/cli/src/server/studioServer.tsindex 6937390639..c12f01f2e0 100644--- a/packages/cli/src/server/studioServer.ts+++ b/packages/cli/src/server/studioServer.ts@@ -642,6 +642,7 @@ export function createStudioServer(options: StudioServerOptions): StudioServer {...(opts.videoFrameFormat ? { videoFrameFormat: opts.videoFrameFormat } : {}),...(opts.hdrMode ? { hdrMode: opts.hdrMode } : {}),...(opts.useGpu ? { useGpu: true } : {}),+ ...(opts.pageMotionBlur ? { pageMotionBlur: opts.pageMotionBlur } : {}),});renderJob = job;const onProgress = (j: { progress: number; currentStage?: string }) => {diff --git a/packages/core/src/runtime/captureMotionBlur/discover.test.ts b/packages/core/src/runtime/captureMotionBlur/discover.test.tsindex 0f0aac55a3..2d74f448b0 100644--- a/packages/core/src/runtime/captureMotionBlur/discover.test.ts+++ b/packages/core/src/runtime/captureMotionBlur/discover.test.ts@@ -2,13 +2,13 @@ import { afterEach, describe, expect, it, vi } from "vitest";import { discoverMovers } from "./discover";// jsdom lays nothing out: each element's rect follows the x its fake timeline writes.-function element(parent: Element, id: string): HTMLElement {- const el = document.createElement("div");+function element(parent: Element, id: string, size = 10, tag = "div"): HTMLElement {+ const el = document.createElement(tag);el.id = id;parent.append(el);el.getBoundingClientRect = () => {const x = parseFloat(el.style.transform.replace("translateX(", "")) || 0;- return { left: x, top: 0, right: x + 10, bottom: 10, width: 10, height: 10 } as DOMRect;+ return { left: x, top: 0, right: x + size, bottom: size, width: size, height: size } as DOMRect;};return el;}@@ -86,4 +86,159 @@ describe("discoverMovers", () => {])expect(discoverMovers({ scene, durationSeconds: 1, fps: 30, seek }).movers).toEqual([]);});++ it("drops a mover with a 3D rotate axis or a z translate", () => {+ for (const style of [{ rotate: "x 30deg" }, { translate: "1px 2px 3px" }]) {+ const { scene, fast, seek } = setup();+ const real = window.getComputedStyle;+ vi.spyOn(window, "getComputedStyle").mockImplementation((el: Element) =>+ el === fast+ ? ({+ transform: "none",+ transformStyle: "flat",+ perspective: "none",+ ...style,+ } as CSSStyleDeclaration)+ : real(el),+ );+ expect(discoverMovers({ scene, durationSeconds: 1, fps: 30, seek }).movers).toEqual([]);+ vi.restoreAllMocks();+ }+ });++ describe("an element holding more of the scene than it owns", () => {+ // A 100 x 100 scene; `big` is 100 x 100 and slides 10 px/frame, `small` rides inside it.+ function sceneWith(tag = "div") {+ const scene = document.createElement("div");+ scene.getBoundingClientRect = () => ({ width: 100, height: 100 }) as DOMRect;+ const big = element(scene, "big", 100, tag);+ const small = element(big, "small");+ const seek = (t: number): void => {+ big.style.transform = `translateX(${300 * t}px)`;+ small.style.transform = `translateX(${300 * t}px)`;+ };+ seek(0);+ const movers = (): HTMLElement[] =>+ discoverMovers({ scene, durationSeconds: 1, fps: 30, seek }).movers;+ return { big, small, movers };+ }++ it("is no mover when it is a translucent sweep", () => {+ const { big, movers } = sceneWith();+ big.style.opacity = "0.5";+ big.style.backgroundImage = "linear-gradient(90deg, rgba(0, 0, 0, 0), red)";+ expect(movers()).not.toContain(big);+ });++ it("is no mover when its gradient fades to transparent", () => {+ const { big, movers } = sceneWith();+ big.style.backgroundImage = "linear-gradient(90deg, rgba(255, 0, 0, 0), rgb(255, 0, 0))";+ expect(movers()).not.toContain(big);+ });++ it("is no mover when its background colour is see-through", () => {+ const { big, movers } = sceneWith();+ big.style.backgroundColor = "rgba(0, 0, 0, 0.4)";+ expect(movers()).not.toContain(big);+ });++ it("is no mover when it has no paint of its own", () => {+ const { big, movers } = sceneWith();+ expect(movers()).not.toContain(big);+ });++ it("is no mover when it fades", () => {+ const { big, movers } = sceneWith();+ big.style.backgroundColor = "rgb(10, 10, 10)";+ big.style.opacity = "0.6";+ expect(movers()).not.toContain(big);+ });++ it("hands the blur to what it holds", () => {+ const { big, small, movers } = sceneWith();+ big.style.opacity = "0.5";+ expect(movers()).toEqual([small]);+ });++ it("stays a mover when opaque", () => {+ const { big, movers } = sceneWith();+ big.style.backgroundColor = "rgb(10, 10, 10)";+ expect(movers()).toEqual([big]);+ });++ it("stays a mover when it is an opaque gradient", () => {+ const { big, movers } = sceneWith();+ big.style.backgroundImage = "linear-gradient(90deg, rgb(0, 0, 0), rgb(255, 0, 0))";+ expect(movers()).toEqual([big]);+ });++ // jsdom has no canvas: the alpha probe's canvas is faked, `alphas` being the pixels it reads.+ function withImage(tag: "img" | "canvas", alphas: number[] | "tainted") {+ const sc = sceneWith(tag);+ if (tag === "img") {+ Object.defineProperty(sc.big, "complete", { value: true });+ Object.defineProperty(sc.big, "naturalWidth", { value: 1600, configurable: true });+ }+ const draws = vi.fn();+ const realCreate = document.createElement.bind(document);+ vi.spyOn(document, "createElement").mockImplementation((name: string) => {+ if (name !== "canvas") return realCreate(name);+ const ctx = {+ drawImage: draws,+ getImageData: () => {+ if (alphas === "tainted") throw new DOMException("tainted", "SecurityError");+ return { data: Uint8ClampedArray.from(alphas.flatMap((a) => [0, 0, 0, a])) };+ },+ };+ return { getContext: () => ctx } as unknown as HTMLCanvasElement;+ });+ return { ...sc, draws };+ }++ it("stays a mover when it is an opaque image", () => {+ const { big, movers, draws } = withImage("img", [255, 255, 255, 255]);+ expect(movers()).toEqual([big]);+ expect(draws).toHaveBeenCalledTimes(1);+ });++ it("is no mover when it is an image with alpha", () => {+ const { big, movers } = withImage("img", [255, 255, 128, 255]);+ expect(movers()).not.toContain(big);+ });++ it("is no mover when it is a canvas with alpha", () => {+ const { big, movers } = withImage("canvas", [0, 255]);+ expect(movers()).not.toContain(big);+ });++ it("is no mover when its pixels cannot be read", () => {+ const { big, movers } = withImage("img", "tainted");+ expect(movers()).not.toContain(big);+ });++ it("is no mover when the image is not decoded", () => {+ const { big, movers } = withImage("img", [255]);+ Object.defineProperty(big, "naturalWidth", { value: 0, configurable: true });+ expect(movers()).not.toContain(big);+ });++ it("stays a mover when it is a video", () => {+ const { big, movers } = sceneWith("video");+ expect(movers()).toEqual([big]);+ });++ it("stays a mover while it is off screen at zero opacity", () => {+ const { big, movers } = sceneWith();+ big.style.backgroundColor = "rgb(10, 10, 10)";+ big.style.opacity = "0";+ expect(movers()).toEqual([big]);+ });+ });++ it("keeps a small box without paint of its own: its crop matches the background", () => {+ const { scene, fast, seek } = setup();+ scene.getBoundingClientRect = () => ({ width: 100, height: 100 }) as DOMRect;+ fast.style.opacity = "0.5";+ expect(discoverMovers({ scene, durationSeconds: 1, fps: 30, seek }).movers).toEqual([fast]);+ });});diff --git a/packages/core/src/runtime/captureMotionBlur/discover.ts b/packages/core/src/runtime/captureMotionBlur/discover.tsindex 18ac0cc84f..dc758efde6 100644--- a/packages/core/src/runtime/captureMotionBlur/discover.ts+++ b/packages/core/src/runtime/captureMotionBlur/discover.ts@@ -3,14 +3,19 @@** One scan: candidates are elements whose inline style changes or that a CSS / WAAPI animation* moves; they must reach MIN_SPEED px/frame outside any 3D context (the redraw is 2D), and only- * the outermost of nested candidates is kept.+ * the outermost of nested candidates is kept. A large element that is see-through while it moves+ * (a sweep, a light leak) is no mover: its crop would carry the scene beneath it along its path.*/import { isHtmlElement } from "../domRealm";+import { individualIs3d } from "./pose";/** Under this peak speed (px per frame) a smear is invisible, so the element stays sharp. */const MIN_SPEED = 2;+/** A box this share of the scene or more holds other content, whatever sits in it. */+const LARGE_SHARE = 0.5;+/** Scan resolution: at most this many timeline samples, however long the composition. */const SCAN_STEPS = 240;@@ -56,7 +61,8 @@ function in3d(el: Element, scene: Element): boolean {cs.transform.startsWith("matrix3d") ||cs.transformStyle === "preserve-3d" ||cs.perspective !== "none" ||- (cs.offsetPath ?? "none") !== "none"+ (cs.offsetPath ?? "none") !== "none" ||+ individualIs3d(cs)) {return true;}@@ -79,6 +85,61 @@ function pageAnimated(scene: Element): Set<HTMLElement> {return out;}+// Alpha of a computed colour (`rgba(r, g, b, a)` or `rgb(r g b / a)`); 1 when it has none.+function alphaOf(color: string): number {+ const m = /^rgba\(.*,\s*([\d.]+)\)$/.exec(color) ?? /\/\s*([\d.]+)(%?)\s*\)$/.exec(color);+ if (!m) return 1;+ return m[2] ? Number(m[1]) / 100 : Number(m[1]);+}++type Bitmap = HTMLImageElement | HTMLCanvasElement;++const isBitmap = (el: HTMLElement): el is Bitmap => el.tagName === "IMG" || el.tagName === "CANVAS";++const ALPHA_PROBE = 32;++/** Whether any pixel of a bitmap is not fully opaque; an undecoded or unreadable one counts. */+function bitmapHasAlpha(el: Bitmap): boolean {+ if ("naturalWidth" in el && !(el.complete && el.naturalWidth > 0)) return true;+ try {+ const probe = el.ownerDocument.createElement("canvas");+ probe.width = probe.height = ALPHA_PROBE;+ const ctx = probe.getContext("2d", { willReadFrequently: true });+ if (!ctx) return true;+ ctx.imageSmoothingQuality = "high";+ ctx.drawImage(el, 0, 0, ALPHA_PROBE, ALPHA_PROBE);+ const { data } = ctx.getImageData(0, 0, ALPHA_PROBE, ALPHA_PROBE);+ for (let i = 3; i < data.length; i += 4) if ((data[i] ?? 0) < 255) return true;+ return false;+ } catch {+ return true;+ }+}++/** Whether the element, on screen right now, lets what is beneath its box show through. */+function seesThrough(el: HTMLElement, scene: Element, hasAlpha: Map<Bitmap, boolean>): boolean {+ let alpha = 1;+ for (let n: Element | null = el; n && n !== scene; n = n.parentElement) {+ alpha *= parseFloat(getComputedStyle(n).opacity);+ }+ if (alpha < 0.05) return false;+ if (alpha < 0.99) return true;+ if (isBitmap(el)) {+ if (!hasAlpha.has(el)) hasAlpha.set(el, bitmapHasAlpha(el));+ return hasAlpha.get(el) === true;+ }+ return !/^(VIDEO|PICTURE)$/.test(el.tagName) && paintSeesThrough(el);+}++function paintSeesThrough(el: HTMLElement): boolean {+ const cs = getComputedStyle(el);+ if (alphaOf(cs.backgroundColor) >= 0.99) return false;+ if (cs.backgroundImage === "none") return true;+ return [...cs.backgroundImage.matchAll(/rgba\([^)]*,\s*([\d.]+)\)/g)].some(+ (m) => Number(m[1]) < 0.99,+ );+}+/** How far a box's farthest-moving edge travelled between two reads; 0 when either is empty. */function edgeShift(a: DOMRect | undefined, b: DOMRect | undefined): number {if (!a || !b || !a.width || !b.width) return 0;@@ -101,6 +162,10 @@ export function discoverMovers({ scene, durationSeconds, fps, seek }: DiscoverOpconst framesPerStep = frames / steps;const fast = new Set<HTMLElement>();const threeD = new Set<HTMLElement>();+ const seeThrough = new Set<HTMLElement>();+ const alphaCache = new Map<Bitmap, boolean>();+ const sceneRect = scene.getBoundingClientRect();+ const largeArea = sceneRect.width * sceneRect.height * LARGE_SHARE;let prev: Array<DOMRect | undefined> | null = null;for (let i = 0; i <= steps; i++) {@@ -111,14 +176,25 @@ export function discoverMovers({ scene, durationSeconds, fps, seek }: DiscoverOpif (!dynamic.has(el) && styleKey(el) === first[j]) return;dynamic.add(el);rects[j] = el.getBoundingClientRect();- if (edgeShift(prev?.[j], rects[j]) / framesPerStep >= MIN_SPEED) fast.add(el);+ if (edgeShift(prev?.[j], rects[j]) / framesPerStep < MIN_SPEED) return;+ fast.add(el);+ const box = rects[j];+ if (+ box &&+ largeArea > 0 &&+ box.width * box.height >= largeArea &&+ seesThrough(el, scene, alphaCache)+ )+ seeThrough.add(el);});// Style reads up the chain are the costly part; every 10th step is enough to see a 3D turn.if (i % 10 === 0 || i === steps) for (const el of fast) if (in3d(el, scene)) threeD.add(el);prev = rects;}- const candidates = all.filter((el) => fast.has(el) && !threeD.has(el) && !optedOut(el, scene));+ const candidates = all.filter(+ (el) => fast.has(el) && !threeD.has(el) && !seeThrough.has(el) && !optedOut(el, scene),+ );const movers = candidates.filter((el) => !candidates.some((o) => o !== el && o.contains(el)));return { movers, dynamic };}diff --git a/packages/engine/src/services/frameCapture.ts b/packages/engine/src/services/frameCapture.tsindex 0e462537fb..0986628af5 100644--- a/packages/engine/src/services/frameCapture.ts+++ b/packages/engine/src/services/frameCapture.ts@@ -40,6 +40,7 @@ import {resolveMotionBlurPlan,type MotionBlurPlan,} from "./motionBlur.js";+import { installPageMotionBlur } from "./pageMotionBlur.js";// ── Extracted modules ───────────────────────────────────────────────────────import {@@ -1509,6 +1510,7 @@ async function constructCaptureSession(}}, variablesJson);}+ await installPageMotionBlur(page, options);const browserVersion = await browser.version();const sessionOptions = resolveCaptureSessionOptions(options, browserVersion);const expectedMajor = config?.expectedChromiumMajor;@@ -3434,6 +3436,7 @@ export async function createStaticVerificationPage(session: CaptureSession): ProJSON.parse(json);}, variablesJson);}+ await installPageMotionBlur(page, session.options);await page.setViewport({width: session.options.width,height: session.options.height,diff --git a/packages/engine/src/services/pageMotionBlur.test.ts b/packages/engine/src/services/pageMotionBlur.test.tsnew file mode 100644index 0000000000..cde3d5ab92--- /dev/null+++ b/packages/engine/src/services/pageMotionBlur.test.ts@@ -0,0 +1,44 @@+import { describe, expect, it, vi } from "vitest";+import { PAGE_DEVICE_SCALE_GLOBAL, PAGE_MOTION_BLUR_OFF_GLOBAL } from "@hyperframes/core";+import { installPageMotionBlur } from "./pageMotionBlur";++const fakePage = () => ({ evaluateOnNewDocument: vi.fn(async () => ({ identifier: "1" })) });++describe("installPageMotionBlur", () => {+ it("tells the page to stand down when the engine blurs", async () => {+ const page = fakePage();+ await installPageMotionBlur(page, { motionBlur: { samplesPerFrame: 16 } });+ expect(page.evaluateOnNewDocument).toHaveBeenCalledTimes(1);+ expect(page.evaluateOnNewDocument).toHaveBeenCalledWith(+ expect.any(Function),+ PAGE_MOTION_BLUR_OFF_GLOBAL,+ "engine-motion-blur",+ );+ });++ it("turns the page off when the Studio preview could not blur", async () => {+ const page = fakePage();+ await installPageMotionBlur(page, { pageMotionBlur: "off" });+ expect(page.evaluateOnNewDocument).toHaveBeenCalledWith(+ expect.any(Function),+ PAGE_MOTION_BLUR_OFF_GLOBAL,+ "preview-unsupported",+ );+ });++ it("tells the page the render's device scale when it is not 1", async () => {+ const page = fakePage();+ await installPageMotionBlur(page, { deviceScaleFactor: 2 });+ expect(page.evaluateOnNewDocument).toHaveBeenCalledWith(+ expect.any(Function),+ PAGE_DEVICE_SCALE_GLOBAL,+ 2,+ );+ });++ it("leaves the page alone otherwise", async () => {+ const page = fakePage();+ await installPageMotionBlur(page, {});+ expect(page.evaluateOnNewDocument).not.toHaveBeenCalled();+ });+});diff --git a/packages/engine/src/services/pageMotionBlur.ts b/packages/engine/src/services/pageMotionBlur.tsnew file mode 100644index 0000000000..e161d43fe1--- /dev/null+++ b/packages/engine/src/services/pageMotionBlur.ts@@ -0,0 +1,38 @@+/**+ * Tells the page's capture motion blur (`data-motion-blur="on"`) to stand down, before any of+ * its scripts run: when the engine blurs (it would average frames that are already blurred) or+ * when the render must match a Studio preview that could not blur (`pageMotionBlur: "off"`).+ */++import { PAGE_DEVICE_SCALE_GLOBAL, PAGE_MOTION_BLUR_OFF_GLOBAL } from "@hyperframes/core";+import type { Page } from "puppeteer-core";+import type { CaptureOptions } from "../types.js";++export async function installPageMotionBlur(+ page: Pick<Page, "evaluateOnNewDocument">,+ options: Pick<CaptureOptions, "motionBlur" | "pageMotionBlur" | "deviceScaleFactor">,+): Promise<void> {+ const scale = options.deviceScaleFactor ?? 1;+ if (scale > 1) {+ await page.evaluateOnNewDocument(+ (key: string, v: number) => {+ (window as unknown as Record<string, unknown>)[key] = v;+ },+ PAGE_DEVICE_SCALE_GLOBAL,+ scale,+ );+ }+ const off = options.motionBlur+ ? "engine-motion-blur"+ : options.pageMotionBlur === "off"+ ? "preview-unsupported"+ : null;+ if (!off) return;+ await page.evaluateOnNewDocument(+ (key: string, v: string) => {+ (window as unknown as Record<string, unknown>)[key] = v;+ },+ PAGE_MOTION_BLUR_OFF_GLOBAL,+ off,+ );+}diff --git a/packages/engine/src/types.ts b/packages/engine/src/types.tsindex ef71e03e5a..873b674d3c 100644--- a/packages/engine/src/types.ts+++ b/packages/engine/src/types.ts@@ -171,6 +171,7 @@ export interface CaptureOptions {* screenshot capture mode; see `services/motionBlur.ts`.*/motionBlur?: MotionBlurOptions;+ pageMotionBlur?: "off";deviceScaleFactor?: number;/*** Opt into Chrome's capture-beyond-viewport screenshot path. Leave undefineddiff --git a/packages/producer/src/renderRequest.ts b/packages/producer/src/renderRequest.tsindex 63121520a1..5c5630887a 100644--- a/packages/producer/src/renderRequest.ts+++ b/packages/producer/src/renderRequest.ts@@ -57,6 +57,7 @@ export interface RenderRequestOptions {videoBitrate?: string;videoFrameFormat?: VideoFrameFormat;hdrMode?: RenderConfig["hdrMode"];+ pageMotionBlur?: RenderConfig["pageMotionBlur"];variables?: Record<string, unknown>;outputResolution?: CanvasResolution;outputResolutionAspectAgnostic?: boolean;@@ -180,6 +181,7 @@ function assertRequestOptionScalars(options: Record<string, unknown>): void {}assertOptionalEnum(options, "strictness", ["strict", "best-effort"]);assertOptionalEnum(options, "hdrMode", ["auto", "force-hdr", "force-sdr"]);+ assertOptionalEnum(options, "pageMotionBlur", ["off"]);if (options.videoFrameFormat !== undefined && !isVideoFrameFormat(options.videoFrameFormat)) {throw new Error("Render request videoFrameFormat is invalid");}diff --git a/packages/producer/src/services/htmlCompiler.test.ts b/packages/producer/src/services/htmlCompiler.test.tsindex 8ba7639699..20f5973ffa 100644--- a/packages/producer/src/services/htmlCompiler.test.ts+++ b/packages/producer/src/services/htmlCompiler.test.ts@@ -659,6 +659,59 @@ describe("detectRenderModeHints", () => {expect(result.recommendScreenshot).toBe(true);});+ it("routes a capture-motion-blur root to screenshot capture", () => {+ const html = `<!DOCTYPE html>+<html><body>+ <div data-composition-id="root" data-motion-blur="on" data-width="1920" data-height="1080"></div>+</body></html>`;++ const result = detectRenderModeHints(html);++ expect(result.reasons.map((reason) => reason.code)).toEqual(["captureMotionBlur"]);+ expect(result.recommendScreenshot).toBe(true);+ });++ it("does not route a root whose motion blur is off", () => {+ const html = `<!DOCTYPE html>+<html><body>+ <div data-composition-id="root" data-motion-blur="off" data-width="1920" data-height="1080"></div>+</body></html>`;++ expect(detectRenderModeHints(html).reasons).toEqual([]);+ });++ describe("capture motion blur root selection", () => {+ const codes = (html: string) => detectRenderModeHints(html).reasons.map((r) => r.code);++ it("does not route when only a sub-composition opted in", () => {+ const html = `<div data-composition-id="root"><div data-composition-id="sub" data-motion-blur="on"></div></div>`;+ expect(codes(html)).toEqual([]);+ });++ it("routes when the outermost root opted in, whatever its sub-compositions say", () => {+ const html = `<div data-composition-id="root" data-motion-blur="on"><div data-composition-id="sub"></div></div>`;+ expect(codes(html)).toEqual(["captureMotionBlur"]);+ });++ it("reads data-root=true before the first composition", () => {+ const first = `<div data-composition-id="a" data-motion-blur="on"></div><div data-composition-id="b" data-root="true"></div>`;+ const marked = `<div data-composition-id="a"></div><div data-composition-id="b" data-root="true" data-motion-blur="on"></div>`;+ expect(codes(first)).toEqual([]);+ expect(codes(marked)).toEqual(["captureMotionBlur"]);+ });+ });++ it("does not route a moving root that did not opt in", () => {+ const tween = `<script>window.__timelines.main = gsap.timeline().to("#a", { x: 400 });</script>`;+ const plain = `<div data-composition-id="root" data-width="1920" data-height="1080"></div>${tween}`;+ expect(detectRenderModeHints(plain).reasons).toEqual([]);+ });++ it("does not route an opted-in root when the render turns page motion blur off", () => {+ const html = `<div data-composition-id="root" data-motion-blur="on"></div>`;+ expect(detectRenderModeHints(html, "off").reasons).toEqual([]);+ });+it("does not flag htmlInCanvas for plain canvas elements without layoutsubtree", () => {const html = `<!DOCTYPE html><html><body>diff --git a/packages/producer/src/services/htmlCompiler.ts b/packages/producer/src/services/htmlCompiler.tsindex 5e08891826..cc66a131a0 100644--- a/packages/producer/src/services/htmlCompiler.ts+++ b/packages/producer/src/services/htmlCompiler.ts@@ -290,7 +290,11 @@ function assertSubCompositionsUsable(}}-export type RenderModeHintCode = "iframe" | "requestAnimationFrame" | "htmlInCanvas";+export type RenderModeHintCode =+ | "iframe"+ | "requestAnimationFrame"+ | "htmlInCanvas"+ | "captureMotionBlur";export interface RenderModeHint {code: RenderModeHintCode;@@ -320,7 +324,15 @@ function stripCompilerMountBootstrap(source: string): string {);}-export function detectRenderModeHints(html: string): RenderModeHints {+/** The composition the runtime reads data-motion-blur from: `data-root="true"`, else the first. */+function runtimeRoot(document: ParentNode): Element | null {+ return (+ document.querySelector('[data-composition-id][data-root="true"]') ??+ document.querySelector("[data-composition-id]")+ );+}++export function detectRenderModeHints(html: string, pageMotionBlur?: "off"): RenderModeHints {const reasons: RenderModeHint[] = [];const { document } = parseHTML(html);@@ -330,6 +342,16 @@ export function detectRenderModeHints(html: string): RenderModeHints {message:"Detected html-in-canvas API (layoutsubtree canvas). Chrome does not support concurrent drawElementImage across multiple workers; render is pinned to a single worker.",});+ } else if (+ pageMotionBlur !== "off" &&+ runtimeRoot(document)?.getAttribute("data-motion-blur") === "on"+ ) {+ // Not pinned to one worker: k3-promo measured identical across 1 and 4 workers, 2× faster.+ reasons.push({+ code: "captureMotionBlur",+ message:+ 'Detected capture motion blur (data-motion-blur="on"), which draws each frame with html-in-canvas; routed through screenshot capture mode.',+ });}if (document.querySelector("iframe")) {@@ -1927,6 +1949,7 @@ export interface CompileForRenderOptions {* `window.__hfVariables` injection covers script reads, not var() in CSS.*/variables?: Record<string, unknown>;+ pageMotionBlur?: "off";}const GSAP_CDN_BASE = gsapCdnDist();@@ -2045,7 +2068,7 @@ export async function compileForRender(/(<(?:video|audio)\b[^>]*?)\s+preload\s*=\s*["']none["']/gi,"$1",);- const renderModeHints = detectRenderModeHints(sanitizedHtml);+ const renderModeHints = detectRenderModeHints(sanitizedHtml, options.pageMotionBlur);const hasShaderTransitions = detectShaderTransitionUsage(sanitizedHtml);// Detected BEFORE inlineExternalScripts: GSAP's own source contains// `transformPerspective`, so scanning post-inline HTML would flag everydiff --git a/packages/producer/src/services/render/stages/compileStage.ts b/packages/producer/src/services/render/stages/compileStage.tsindex ca8684cb9a..a4a4b01309 100644--- a/packages/producer/src/services/render/stages/compileStage.ts+++ b/packages/producer/src/services/render/stages/compileStage.ts@@ -91,6 +91,8 @@ export interface CompileStageInput {variables?: Record<string, unknown>;/** Absolute project paths not on disk, readable at these URLs instead. */urlByAbsentLocalPath?: ReadonlyMap<string, string>;+ /** See RenderConfig.pageMotionBlur; decides whether the page renders through screenshots. */+ pageMotionBlur?: "off";}export interface CompileStageResult {@@ -174,6 +176,7 @@ export async function runCompileStage(input: CompileStageInput): Promise<CompileabortSignal,variables: input.variables,urlByAbsentLocalPath: input.urlByAbsentLocalPath,+ pageMotionBlur: input.pageMotionBlur,animatedGifCacheDir: cfg.extractCacheDir? join(cfg.extractCacheDir, "animated-gif"): undefined,diff --git a/packages/producer/src/services/render/stages/probeStage.test.ts b/packages/producer/src/services/render/stages/probeStage.test.tsindex 45bdddb134..ebb3673b9c 100644--- a/packages/producer/src/services/render/stages/probeStage.test.ts+++ b/packages/producer/src/services/render/stages/probeStage.test.ts@@ -927,6 +927,29 @@ describe("runProbeStage — render variable threading", () => {});});+describe("runProbeStage — page motion blur", () => {+ // The probe session is reused for capture, so it must carry the render's "off" like any session.+ it("passes pageMotionBlur to the probe session so a reused session installs the off global", async () => {+ capturedOptions.length = 0;+ const { runProbeStage } = await import("./probeStage.js");+ const input = makeProbeInput({ stageForceScreenshot: false });+ input.job.config.pageMotionBlur = "off";++ await runProbeStage(input);++ expect(capturedOptions[0]).toMatchObject({ pageMotionBlur: "off" });+ });++ it("leaves pageMotionBlur unset when the render does not ask for off", async () => {+ capturedOptions.length = 0;+ const { runProbeStage } = await import("./probeStage.js");++ await runProbeStage(makeProbeInput({ stageForceScreenshot: false }));++ expect(capturedOptions[0]).not.toHaveProperty("pageMotionBlur", "off");+ });+});+describe("runProbeStage — capture jpeg quality", () => {// A sequential disk render reuses this session for every frame, so its quality is the render's.for (const [preset, expected] of [diff --git a/packages/producer/src/services/render/stages/probeStage.ts b/packages/producer/src/services/render/stages/probeStage.tsindex 5ecff9bd41..4ec75788e9 100644--- a/packages/producer/src/services/render/stages/probeStage.ts+++ b/packages/producer/src/services/render/stages/probeStage.ts@@ -384,6 +384,7 @@ export async function runProbeStage(input: ProbeStageInput): Promise<ProbeStageRvariables: job.config.variables,deviceScaleFactor,motionBlur,+ pageMotionBlur: job.config.pageMotionBlur,requiresWebGpu: compositionRequiresWebGpu(compiled.html),subTimelineWaitMemo,};diff --git a/packages/producer/src/services/renderOrchestrator.test.ts b/packages/producer/src/services/renderOrchestrator.test.tsindex e63a8ed078..c06dddab16 100644--- a/packages/producer/src/services/renderOrchestrator.test.ts+++ b/packages/producer/src/services/renderOrchestrator.test.ts@@ -1316,6 +1316,26 @@ describe("resolveRenderWorkerCount", () => {expect(log.warn).toHaveBeenCalledOnce();});+ it("does not pin a capture-motion-blur page to one worker", () => {+ const log = { error: vi.fn(), warn: vi.fn(), info: vi.fn(), debug: vi.fn() };++ const workers = resolveRenderWorkerCount(+ 900,+ 4,+ cfg,+ {+ hasShaderTransitions: false,+ renderModeHints: {+ recommendScreenshot: true,+ reasons: [{ code: "captureMotionBlur", message: "data-motion-blur" }],+ },+ },+ log,+ );++ expect(workers).toBe(4);+ });+// fallow-ignore-next-line code-duplicationit("pins to 1 worker in low-memory mode when no explicit --workers is set", () => {const log = {diff --git a/packages/producer/src/services/renderOrchestrator.ts b/packages/producer/src/services/renderOrchestrator.tsindex 2faf76cbc1..45e18c5beb 100644--- a/packages/producer/src/services/renderOrchestrator.ts+++ b/packages/producer/src/services/renderOrchestrator.ts@@ -396,6 +396,7 @@ export interface RenderConfig {* and JPEG samples would be averaged after a lossy quantization.*/motionBlur?: MotionBlurOptions;+ pageMotionBlur?: "off";workers?: number;useGpu?: boolean;debug?: boolean;@@ -3055,6 +3056,7 @@ async function executeRenderPipeline(input: {log,assertNotAborted,variables: job.config.variables,+ pageMotionBlur: job.config.pageMotionBlur,}),);let compiled = compileResult.compiled;@@ -3495,6 +3497,7 @@ async function executeRenderPipeline(input: {variables: job.config.variables,deviceScaleFactor,motionBlur: job.config.motionBlur,+ pageMotionBlur: job.config.pageMotionBlur,...(videoCaptureBeyondViewport !== undefined? { captureBeyondViewport: videoCaptureBeyondViewport }: {}),diff --git a/packages/studio-server/src/routes/render.test.ts b/packages/studio-server/src/routes/render.test.tsindex 9db0ee5499..75adffe67f 100644--- a/packages/studio-server/src/routes/render.test.ts+++ b/packages/studio-server/src/routes/render.test.ts@@ -785,6 +785,34 @@ describe("POST /projects/:id/render — telemetryDistinctId forwarding", () => {}});+ // WYSIWYG: the browser says whether its preview could blur; only `false` is a signal, and the+ // route hands every adapter the final render value.+ it.each([+ [false, "off"],+ [true, undefined],+ ["false", undefined],+ [undefined, undefined],+ ])("maps previewMotionBlur %s to pageMotionBlur %s", async (flag, expected) => {+ const spy = vi.fn();+ const { app, cleanup } = buildApp(spy);+ try {+ await app.request("http://localhost/projects/demo/render", {+ method: "POST",+ headers: { "content-type": "application/json" },+ body: JSON.stringify({+ fps: 30,+ quality: "standard",+ format: "mp4",+ previewMotionBlur: flag,+ }),+ });+ expect(spy.mock.calls[0][0].pageMotionBlur).toBe(expected);+ expect(spy.mock.calls[0][0]).not.toHaveProperty("previewMotionBlur");+ } finally {+ cleanup();+ }+ });+// An old client omits the flag, and a non-boolean is not a signal either.// Defaulting those to "opted out" would silently drop every pre-upgrade// render outcome.diff --git a/packages/studio-server/src/routes/render.ts b/packages/studio-server/src/routes/render.tsindex c082db3c5b..b041957c94 100644--- a/packages/studio-server/src/routes/render.ts+++ b/packages/studio-server/src/routes/render.ts@@ -108,6 +108,7 @@ export function registerRenderRoutes(api: Hono, adapter: StudioApiAdapter): void// window.__hfVariables — same channel as `hyperframes render --variables`.variables?: Record<string, unknown>;gpu?: boolean;+ previewMotionBlur?: boolean;};const VALID_FORMATS = new Set(["mp4", "webm", "mov"]);const FORMAT_EXT: Record<string, string> = { mp4: ".mp4", webm: ".webm", mov: ".mov" };@@ -172,6 +173,7 @@ export function registerRenderRoutes(api: Hono, adapter: StudioApiAdapter): voiddistinctId:typeof body.telemetryDistinctId === "string" ? body.telemetryDistinctId : undefined,telemetryOptOut: body.telemetryOptOut === true,+ ...(body.previewMotionBlur === false ? { pageMotionBlur: "off" as const } : {}),});(jobState as RenderJobState & { createdAt: number }).createdAt = Date.now();renderJobs.set(jobId, jobState as RenderJobState & { createdAt: number });diff --git a/packages/studio-server/src/types.ts b/packages/studio-server/src/types.tsindex e38e69ba79..6d6ac95283 100644--- a/packages/studio-server/src/types.ts+++ b/packages/studio-server/src/types.ts@@ -185,6 +185,7 @@ export interface StudioApiAdapter {* for a user who had opted out, under the CLI's own policy.*/telemetryOptOut?: boolean;+ pageMotionBlur?: "off";/*** Optional output resolution preset. See `resolveDeviceScaleFactor` in* the producer for the integer-scale + aspect + HDR constraints.diff --git a/packages/studio/src/components/renders/useRenderQueue.ts b/packages/studio/src/components/renders/useRenderQueue.tsindex 860bd542ba..0e24c194f8 100644--- a/packages/studio/src/components/renders/useRenderQueue.ts+++ b/packages/studio/src/components/renders/useRenderQueue.ts@@ -10,6 +10,13 @@ import { ffmpegInstallMessage, useFfmpegStatus } from "./useFfmpegStatus";import { requestStudioFeedback, type FeedbackContext } from "../feedback/feedbackTrigger";import { studioApiFetch } from "../../utils/studioApiFetch";+// WYSIWYG: the preview iframe runs in this browser, so a render blurs only if this one can.+function canPreviewMotionBlur(): boolean {+ const ctx = globalThis.CanvasRenderingContext2D?.prototype;+ if (!ctx || typeof document === "undefined") return false;+ return "drawElementImage" in ctx && "requestPaint" in document.createElement("canvas");+}+export interface RenderJob {id: string;status: "rendering" | "complete" | "failed" | "cancelled";@@ -238,10 +245,12 @@ export function useRenderQueue(gpu?: boolean;telemetryDistinctId?: string;telemetryOptOut?: boolean;+ previewMotionBlur: boolean;} = {fps,quality,format,+ previewMotionBlur: canPreviewMotionBlur(),};// The id is MINTED by getAnonymousId(), so calling it unconditionally// created a telemetry identity for a profile that had opted out — anddiff --git a/packages/studio/src/components/renders/useRenderQueueMotionBlur.test.tsx b/packages/studio/src/components/renders/useRenderQueueMotionBlur.test.tsxnew file mode 100644index 0000000000..485a8bfbc8--- /dev/null+++ b/packages/studio/src/components/renders/useRenderQueueMotionBlur.test.tsx@@ -0,0 +1,46 @@+// @vitest-environment happy-dom++// WYSIWYG: a render only blurs what the Studio preview could show, and only the browser knows+// whether it has html-in-canvas. The request body is how it tells the server.++import { afterEach, describe, expect, it, vi } from "vitest";+import { startRenderAndReadBody, type MountedQueue } from "./renderQueueTestHarness";++vi.mock("../../telemetry/events", () => ({ trackStudioRenderStart: vi.fn() }));++const { useRenderQueue } = await import("./useRenderQueue");++let queue: MountedQueue | null = null;++async function startRenderBody(): Promise<Record<string, unknown>> {+ const started = await startRenderAndReadBody(useRenderQueue, {+ opts: { fps: 30, quality: "standard", format: "mp4" },+ });+ queue = started.queue;+ return started.body;+}++afterEach(() => {+ queue?.unmount();+ queue = null;+ document.body.innerHTML = "";+ delete (HTMLCanvasElement.prototype as unknown as Record<string, unknown>).requestPaint;+ vi.unstubAllGlobals();+});++describe("render request previewMotionBlur", () => {+ it("is false in a browser without html-in-canvas", async () => {+ expect((await startRenderBody())["previewMotionBlur"]).toBe(false);+ });++ it("is true in a browser with html-in-canvas", async () => {+ vi.stubGlobal(+ "CanvasRenderingContext2D",+ class {+ drawElementImage(): void {}+ },+ );+ (HTMLCanvasElement.prototype as unknown as Record<string, unknown>).requestPaint = () => {};+ expect((await startRenderBody())["previewMotionBlur"]).toBe(true);+ });+});diff --git a/packages/studio/vite.adapter.render.test.ts b/packages/studio/vite.adapter.render.test.tsnew file mode 100644index 0000000000..308771bd2d--- /dev/null+++ b/packages/studio/vite.adapter.render.test.ts@@ -0,0 +1,56 @@+import { mkdtempSync, rmSync } from "node:fs";+import { tmpdir } from "node:os";+import { join } from "node:path";+import type { ViteDevServer } from "vite";+import { afterEach, describe, expect, it, vi } from "vitest";+import { createProjectSignatureCache, createViteAdapter } from "./vite.adapter";++const mocks = vi.hoisted(() => ({+ createRenderJob: vi.fn(() => ({ id: "job", perfSummary: undefined })),+ executeRenderJob: vi.fn(async () => {}),+}));++vi.mock("@hyperframes/producer", () => mocks);++const roots: string[] = [];+afterEach(() => {+ vi.clearAllMocks();+ for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true });+});++function startRender(extra: Record<string, unknown>) {+ const root = mkdtempSync(join(tmpdir(), "hf-vite-render-"));+ roots.push(root);+ const adapter = createViteAdapter(+ root,+ {} as ViteDevServer,+ createProjectSignatureCache({ compute: () => "test" }),+ { historyRoot: join(root, "history") },+ );+ adapter.startRender({+ project: { dir: root, id: "p", title: "p" },+ outputPath: join(root, "out.mp4"),+ format: "mp4",+ fps: { num: 30, den: 1 },+ quality: "draft",+ jobId: "job",+ ...extra,+ } as never);+ return vi.waitFor(() => expect(mocks.createRenderJob).toHaveBeenCalledTimes(1), {+ timeout: 10_000,+ });+}++describe("Studio dev server render jobs", { timeout: 30_000 }, () => {+ it("hands the route's pageMotionBlur to the job, so a preview that could not blur renders unblurred", async () => {+ await startRender({ pageMotionBlur: "off" });+ expect(mocks.createRenderJob).toHaveBeenCalledWith(+ expect.objectContaining({ pageMotionBlur: "off" }),+ );+ });++ it("leaves the job's blur to the composition when the route sends none", async () => {+ await startRender({});+ expect(mocks.createRenderJob.mock.calls[0]?.[0]).not.toHaveProperty("pageMotionBlur");+ });+});diff --git a/packages/studio/vite.adapter.ts b/packages/studio/vite.adapter.tsindex 340bacebb9..0c76541182 100644--- a/packages/studio/vite.adapter.ts+++ b/packages/studio/vite.adapter.ts@@ -356,6 +356,7 @@ export function createViteAdapter(...(opts.videoFrameFormat ? { videoFrameFormat: opts.videoFrameFormat } : {}),...(opts.hdrMode ? { hdrMode: opts.hdrMode } : {}),...(opts.useGpu ? { useGpu: true } : {}),+ ...(opts.pageMotionBlur ? { pageMotionBlur: opts.pageMotionBlur } : {}),});const onProgress = (j: { progress: number; currentStage?: string }) => {state.progress = j.progress;diff --git a/scripts/package-size-budgets.json b/scripts/package-size-budgets.jsonindex 3ccb012ef2..20e087ca84 100644--- a/scripts/package-size-budgets.json+++ b/scripts/package-size-budgets.json@@ -1,7 +1,7 @@{"@hyperframes/aws-lambda": { "packed": 70874, "unpacked": 258166 },"@hyperframes/cli": { "packed": 7902966, "unpacked": 23722874 },- "@hyperframes/core": { "packed": 1636442, "unpacked": 3903211 },+ "@hyperframes/core": { "packed": 1636442, "unpacked": 3930000 },"@hyperframes/engine": { "packed": 428347, "unpacked": 1436293 },"@hyperframes/gcp-cloud-run": { "packed": 49412, "unpacked": 192672 },"@hyperframes/inspector": { "packed": 808905, "unpacked": 3645432 },