Skip to content

Write HTML. Render video. Built for agents.

fix(engine): fail the render when an injected video frame cannot decode (#4974)

Miguel Ángel8e457d4224c5
diff --git a/packages/engine/src/services/frameCapture-freshFallback.test.ts b/packages/engine/src/services/frameCapture-freshFallback.test.ts
index ab7575da65..6b3470d51e 100644
--- a/packages/engine/src/services/frameCapture-freshFallback.test.ts
+++ b/packages/engine/src/services/frameCapture-freshFallback.test.ts
@@ -122,6 +122,28 @@ describe("fresh screenshot fallback", () => {
expect(existsSync(join(s.outputDir, "diagnostics", "frame-error-7.json"))).toBe(true);
});
+ // A BeginFrame page paints only when the engine sends a frame, so a diagnostic
+ // page.screenshot never resolves there and held the real error until the stall watchdog.
+ it.each(["beginframe", "drawelement"] as const)(
+ "rejects a %s capture failure on a BeginFrame launch with its own error, without a page screenshot",
+ async (captureMode) => {
+ const s = await session();
+ s.launchCaptureMode = "beginframe";
+ s.captureMode = captureMode;
+ s.onBeforeCapture = async () => {
+ throw new Error('Video frame for "clip" failed to load (inline frame)');
+ };
+ const screenshot = vi.fn(() => new Promise<Buffer>(() => {}));
+ Object.assign(s.page, { screenshot, content: async () => "<html></html>" });
+
+ await expect(captureFrameToBuffer(s, 7, 7 / 30)).rejects.toThrow(
+ 'Video frame for "clip" failed to load',
+ );
+ expect(screenshot).not.toHaveBeenCalled();
+ expect(existsSync(join(s.outputDir, "diagnostics", "frame-error-7.json"))).toBe(true);
+ },
+ );
+
it("rejects a suspect tiny frame without substituting a stale screenshot", async () => {
vi.mocked(captureDrawElementFrame).mockResolvedValueOnce(Buffer.alloc(100));
await expect(captureFrameToBuffer(await session(), 7, 7 / 30)).rejects.toThrow(
diff --git a/packages/engine/src/services/frameCapture.ts b/packages/engine/src/services/frameCapture.ts
index 64c644d02f..339d148f2f 100644
--- a/packages/engine/src/services/frameCapture.ts
+++ b/packages/engine/src/services/frameCapture.ts
@@ -2638,7 +2638,10 @@ async function captureFrameErrorDiagnostics(
const diagnosticsDir = join(session.outputDir, "diagnostics");
if (!existsSync(diagnosticsDir)) mkdirSync(diagnosticsDir, { recursive: true });
const base = join(diagnosticsDir, `frame-error-${frameIndex}`);
- await session.page.screenshot({ path: `${base}.png`, type: "png", fullPage: true });
+ const pageScreenshotCanResolve = session.launchCaptureMode !== "beginframe";
+ if (pageScreenshotCanResolve) {
+ await session.page.screenshot({ path: `${base}.png`, type: "png", fullPage: true });
+ }
const html = await session.page.content();
writeFileSync(`${base}.html`, html, "utf-8");
writeFileSync(
diff --git a/packages/engine/src/services/screenshotService.test.ts b/packages/engine/src/services/screenshotService.test.ts
index 4ff0b360e7..4f25011927 100644
--- a/packages/engine/src/services/screenshotService.test.ts
+++ b/packages/engine/src/services/screenshotService.test.ts
@@ -240,6 +240,54 @@ describe("initTransparentBackground", () => {
});
});
+describe("injectVideoFramesBatch load failures", () => {
+ it("rejects naming the video when an injected frame fails to decode", async () => {
+ const { window, document } = parseHTML(
+ '<html><body><div id="root"><video id="clip" style="position:absolute;width:100%;height:100%"></video></div></body></html>',
+ );
+ Object.defineProperty(window.HTMLImageElement.prototype, "decode", {
+ configurable: true,
+ value: async () => {
+ throw new Error("The source image cannot be decoded.");
+ },
+ });
+ const video = document.getElementById("clip") as HTMLVideoElement;
+ video.getBoundingClientRect = () => ({ width: 1920, height: 1080 }) as DOMRect;
+ const computedStyle = document.createElement("div").style;
+ computedStyle.opacity = "1";
+ Object.defineProperty(window, "getComputedStyle", {
+ configurable: true,
+ value: () => computedStyle,
+ });
+ const globals = globalThis as unknown as { window?: typeof window; document?: Document };
+ const previousWindow = globals.window;
+ const previousDocument = globals.document;
+ globals.window = window;
+ globals.document = document;
+ try {
+ const page = {
+ evaluate: async (
+ fn: (
+ updates: Array<{ videoId: string; dataUri: string }>,
+ visualProperties: string[],
+ ) => Promise<void>,
+ updates: Array<{ videoId: string; dataUri: string }>,
+ visualProperties: string[],
+ ) => fn(updates, visualProperties),
+ } as unknown as Page;
+
+ await expect(
+ injectVideoFramesBatch(page, [{ videoId: "clip", dataUri: "data:image/jpeg;base64,AAAA" }]),
+ ).rejects.toThrow(
+ 'Video frame for "clip" failed to load (inline frame): The source image cannot be decoded.',
+ );
+ } finally {
+ globals.window = previousWindow;
+ globals.document = previousDocument;
+ }
+ });
+});
+
describe("injectVideoFramesBatch replacement layout", () => {
it("does not copy opposing inset constraints onto the injected frame image", async () => {
const { window, document } = parseHTML(
diff --git a/packages/engine/src/services/screenshotService.ts b/packages/engine/src/services/screenshotService.ts
index 3618c773dd..0a9784fbc5 100644
--- a/packages/engine/src/services/screenshotService.ts
+++ b/packages/engine/src/services/screenshotService.ts
@@ -795,11 +795,15 @@ export async function injectVideoFramesBatch(
img.decoding = "sync";
if (img.getAttribute("src") !== item.dataUri) {
img.src = item.dataUri;
+ const source = item.dataUri.startsWith("data:") ? "inline frame" : item.dataUri;
pendingDecodes.push(
- img
- .decode()
- .catch(() => undefined)
- .then(() => undefined),
+ img.decode().catch((error: unknown) => {
+ throw new Error(
+ `Video frame for "${item.videoId}" failed to load (${source}): ${
+ error instanceof Error ? error.message : String(error)
+ }`,
+ );
+ }),
);
}
img.style.opacity = String(computedOpacity);