feat(studio): the console errors panel reads a sealed preview over its editing port (#7824)

This commit is contained in:
Miguel Ángel
2026-11-15 17:14:34 +00:00
committed by GitHub
parent 39dc1e232d
commit 5341d7255c
8 changed files with 232 additions and 13 deletions
@@ -43,6 +43,7 @@ describe("installEditingAgent", () => {
delete window.__hfStartupError;
delete window.__hfWaitForSeekCompletion;
delete window.__hf;
Reflect.deleteProperty(window, "__hfPreviewErrors");
});
const connectedPort = (): MessagePort => {
@@ -166,6 +167,7 @@ describe("installEditingAgent", () => {
"layers",
"draft",
"gesture-start",
"console-errors",
],
},
});
@@ -207,6 +209,9 @@ describe("installEditingAgent", () => {
"invalid-params",
],
[{ v: 1, id: 16, kind: "computed-styles", params: { selector: "p" } }, 16, "invalid-params"],
[{ v: 1, id: 160, kind: "console-errors", params: {} }, 160, "invalid-params"],
[{ v: 1, id: 161, kind: "console-errors", params: { from: -1 } }, 161, "invalid-params"],
[{ v: 1, id: 162, kind: "console-errors", params: { from: 1.5 } }, 162, "invalid-params"],
[
{ v: 1, id: 17, kind: "computed-styles", params: { selector: "", properties: [] } },
17,
@@ -390,6 +395,62 @@ describe("installEditingAgent", () => {
expect(setLoopStart).not.toHaveBeenCalled();
});
describe("console errors", () => {
const errorsFrom = async (port: MessagePort, from: number) =>
(await ask(port, { v: 1, id: 30, kind: "console-errors", params: { from } })).result;
let logged: unknown[][];
beforeEach(() => {
logged = [];
vi.spyOn(console, "error").mockImplementation((...args) => void logged.push(args));
});
afterEach(() => {
agent.dispose();
vi.restoreAllMocks();
});
it("starts from what the page raised before it was asked, then keeps what follows", async () => {
Reflect.set(window, "__hfPreviewErrors", ["Uncaught Error: early"]);
const port = connectedPort();
expect(await errorsFrom(port, 0)).toEqual({
errors: ["Uncaught Error: early"],
truncated: false,
});
console.error("GSAP target", new Error("not found"), 3);
console.error("GET /favicon.ico 404");
window.dispatchEvent(new ErrorEvent("error", { message: "Uncaught TypeError: x" }));
expect(await errorsFrom(port, 1)).toEqual({
errors: ["GSAP target not found 3", "Uncaught TypeError: x"],
truncated: false,
});
expect(logged).toHaveLength(2);
});
it("sends a long list in pages", async () => {
const raised = Array.from({ length: 2_050 }, (_, i) => `e${i}`);
Reflect.set(window, "__hfPreviewErrors", raised);
const port = connectedPort();
const first = (await errorsFrom(port, 0)) as { errors: string[]; truncated: boolean };
expect(first.errors).toHaveLength(2_048);
expect(first.truncated).toBe(true);
expect(await errorsFrom(port, 2_048)).toEqual({
errors: ["e2048", "e2049"],
truncated: false,
});
});
it("leaves the page's console alone until asked, and puts it back when disposed", async () => {
const own = console.error;
const port = connectedPort();
expect(console.error).toBe(own);
await errorsFrom(port, 0);
expect(console.error).not.toBe(own);
agent.dispose();
expect(console.error).toBe(own);
});
});
it("answers computed styles for the element a selector names", async () => {
document.body.innerHTML = `<p id="title" style="color: rgb(1, 2, 3); opacity: 0.5">Hi</p>
<canvas data-hf-preview-video-canvas style="opacity: 0.25"></canvas>
+36 -1
View File
@@ -32,7 +32,13 @@ import { pointerTargetsAt } from "./editingTargets";
import { layersOf } from "./editingLayers";
import { drawDrafts } from "./editingDraft";
import { gestureStart } from "./editingGestureStart";
import { getLogicalOpacity, servedToAnotherSite } from "../studioPreviewMark";
import {
getLogicalOpacity,
previewConsoleErrorText,
servedToAnotherSite,
STUDIO_PREVIEW_ERRORS,
} from "../studioPreviewMark";
import { MAX_QUERY_MATCHES } from "./editingElement";
type Handlers = {
[K in EditingRequestKind]: (
@@ -48,6 +54,28 @@ function clipParents(nodes: readonly ClipNode[], out: Array<[string, string]> =
return out;
}
let consoleWatch: { seen: string[]; stop: () => void } | null = null;
function watchConsoleErrors(): string[] {
if (consoleWatch) return consoleWatch.seen;
const raised: unknown = Reflect.get(window, STUDIO_PREVIEW_ERRORS);
const seen = Array.isArray(raised) ? raised.map(String) : [];
const original = console.error;
console.error = (...args: unknown[]) => {
original.apply(console, args);
const text = previewConsoleErrorText(args);
if (text !== null) seen.push(text);
};
const onError = (e: ErrorEvent) => seen.push(e.message || String(e));
window.addEventListener("error", onError);
const stop = () => {
console.error = original;
window.removeEventListener("error", onError);
};
consoleWatch = { seen, stop };
return seen;
}
const HANDLERS: Handlers = {
hello: () => ({ version: EDITING_PROTOCOL_VERSION, kinds: [...EDITING_REQUEST_KINDS] }),
"runtime-snapshot": () => ({
@@ -93,6 +121,11 @@ const HANDLERS: Handlers = {
layers: ({ group, offset }) => layersOf(group, offset),
draft: ({ drafts }) => drawDrafts(drafts),
"gesture-start": ({ handles }) => gestureStart(handles),
"console-errors": ({ from }) => {
const seen = watchConsoleErrors();
const errors = seen.slice(from, from + MAX_QUERY_MATCHES);
return { errors, truncated: from + errors.length < seen.length };
},
};
function serve(port: MessagePort): void {
@@ -168,6 +201,8 @@ export function installEditingAgent(parent: Window = window.parent): { dispose:
window.removeEventListener("message", onMessage);
for (const port of ports) port.close();
ports.clear();
consoleWatch?.stop();
consoleWatch = null;
},
};
}
@@ -75,6 +75,7 @@ describe("createEditingPortClient", () => {
"layers",
"draft",
"gesture-start",
"console-errors",
],
});
} finally {
+4
View File
@@ -106,6 +106,7 @@ export const EDITING_REQUEST_KINDS = [
"layers",
"draft",
"gesture-start",
"console-errors",
] as const;
export type EditingRequestKind = (typeof EDITING_REQUEST_KINDS)[number];
@@ -192,6 +193,7 @@ export interface EditingRequests {
params: { handles: EditingElementHandle[] };
result: { elements: Array<EditingGestureStart | null>; snap: EditingElementBox[] };
};
"console-errors": { params: { from: number }; result: { errors: string[]; truncated: boolean } };
}
export type EditingParams<K extends EditingRequestKind> = EditingRequests[K]["params"];
export type EditingResult<K extends EditingRequestKind> = EditingRequests[K]["result"];
@@ -349,6 +351,8 @@ const PARAM_PARSERS: {
layers: (params) => noParams(params) ?? layerParams(params),
draft: draftList,
"gesture-start": handleList,
"console-errors": (params) =>
hasKeys(params, "from") && isOffset(params.from) ? { from: params.from } : null,
};
/** Validates one request off the wire. Never throws: anything unusable becomes a typed error. */
+4
View File
@@ -43,6 +43,10 @@ export const STUDIO_PREVIEW_UPCOMING_ATTR = "data-hf-upcoming";
export const STUDIO_PREVIEW_LAZY_ATTR = "data-hf-preview-lazy";
export const STUDIO_PREVIEW_ERRORS = "__hfPreviewErrors";
export const STUDIO_PREVIEW_ERROR_KINDS = "__hfPreviewErrorKinds";
export function previewConsoleErrorText(args: readonly unknown[]): string | null {
const text = args.map((a) => (a instanceof Error ? a.message : String(a))).join(" ");
return text.includes("favicon") ? null : text;
}
export const refusedPreviewMessage = (status: number) =>
`The preview page could not be loaded (HTTP ${status}).`;
@@ -2,10 +2,14 @@
import React, { act } from "react";
import { createRoot, type Root } from "react-dom/client";
import { afterEach, expect, it } from "vitest";
import { afterEach, expect, it, vi } from "vitest";
import { STUDIO_PREVIEW_ERRORS } from "@hyperframes/core/studio-preview-mark";
import { announcePreviewDocumentLoaded } from "../player/sceneSwap";
import { useConsoleErrorCapture } from "./useConsoleErrorCapture";
import {
detachedFakeIframe,
serveEditingRequests,
} from "../player/hooks/timelinePlayerTestHarness";
Object.assign(globalThis, { IS_REACT_ACT_ENVIRONMENT: true });
@@ -24,10 +28,42 @@ function previewFrame() {
const shown = () => capture.consoleErrors?.map((finding) => finding.message);
/** A frame whose window refuses Studio's reads; its runtime answers `console-errors` from `raised`. */
function sealedFrame(
raised: string[],
page = (from: number) => {
const errors = raised.slice(from, from + 2);
return { errors, truncated: from + errors.length < raised.length };
},
) {
const frame: Record<string, unknown> = {};
const iframe = detachedFakeIframe(frame);
Object.defineProperty(iframe, "contentDocument", { value: null });
Object.defineProperty(frame, "document", {
get: () => {
throw new DOMException("blocked", "SecurityError");
},
});
const asked: number[] = [];
const askedAt: number[] = [];
closers.push(
serveEditingRequests(frame, (kind, params) => {
if (kind !== "console-errors") return null;
const { from } = params as { from: number };
asked.push(from);
askedAt.push(performance.now());
return page(from);
}),
);
return { iframe, asked, askedAt };
}
const closers: Array<() => void> = [];
let root: Root | null = null;
afterEach(async () => {
await act(async () => root?.unmount());
root = null;
closers.splice(0).forEach((close) => close());
});
it("shows the errors a preview raised before its load, once each", async () => {
@@ -104,3 +140,35 @@ it("keeps a page's errors through its own late load, and clears them for the nex
await act(async () => announcePreviewDocumentLoaded(iframe));
expect(shown()).toEqual(["Uncaught Error: new page"]);
});
it("shows a sealed preview's errors, read over its editing port a page at a time", async () => {
const raised = ["Uncaught Error: a", "Uncaught Error: b", "Uncaught Error: c"];
const { iframe, asked } = sealedFrame(raised);
root = createRoot(document.createElement("div"));
await act(async () => root?.render(React.createElement(Harness, { iframe })));
await act(async () => announcePreviewDocumentLoaded(iframe));
const shows = (expected: string[]) =>
vi.waitFor(
async () => {
await act(async () => {});
expect(shown()).toEqual(expected);
},
{ timeout: 3_000 },
);
await shows(raised);
expect(asked).toContain(2);
raised.push("Uncaught Error: later");
await shows(raised);
});
it("waits for its next read when a sealed preview's page says more but brings nothing", async () => {
const { iframe, askedAt } = sealedFrame([], () => ({ errors: [], truncated: true }));
root = createRoot(document.createElement("div"));
await act(async () => root?.render(React.createElement(Harness, { iframe })));
await act(async () => announcePreviewDocumentLoaded(iframe));
await vi.waitFor(() => expect(askedAt.length).toBeGreaterThanOrEqual(3), { timeout: 3_000 });
expect(askedAt[2] - askedAt[1]).toBeGreaterThan(500);
});
@@ -1,8 +1,14 @@
import { useCallback, useEffect, useRef, useState } from "react";
import { STUDIO_PREVIEW_ERRORS } from "@hyperframes/core/studio-preview-mark";
import {
previewConsoleErrorText,
STUDIO_PREVIEW_ERRORS,
} from "@hyperframes/core/studio-preview-mark";
import { onPreviewDocumentLoaded } from "../player/sceneSwap";
import { previewConsoleErrors, previewFrameOpaque } from "../player/lib/previewChannel";
import type { LintFinding } from "../components/LintModal";
const SEALED_POLL_MS = 1_000;
/**
* Captures `console.error` and `window.onerror` events from a preview iframe
* and exposes them as LintFinding[] for the console errors modal.
@@ -24,8 +30,42 @@ export function useConsoleErrorCapture(previewIframe: HTMLIFrameElement | null)
let patchedWin: (Window & typeof globalThis) | null = null;
let origConsoleError: ((...args: unknown[]) => void) | null = null;
let errorHandler: ((e: ErrorEvent) => void) | null = null;
let stopSealedReads: (() => void) | null = null;
const record = (texts: readonly string[]) => {
if (texts.length === 0) return;
consoleErrorsRef.current = [
...consoleErrorsRef.current,
...texts.map((message) => ({ severity: "error" as const, message })),
];
setConsoleErrors([...consoleErrorsRef.current]);
};
const readSealedErrors = (iframe: HTMLIFrameElement) => {
let live = true;
let read = 0;
let timer: ReturnType<typeof setTimeout> | undefined;
const poll = async () => {
for (;;) {
const page = await previewConsoleErrors(iframe, read);
if (!live) return;
if (!page) break;
read += page.errors.length;
record(page.errors);
if (!page.truncated || page.errors.length === 0) break;
}
timer = setTimeout(poll, SEALED_POLL_MS);
};
void poll();
return () => {
live = false;
clearTimeout(timer);
};
};
const detachErrorCapture = () => {
stopSealedReads?.();
stopSealedReads = null;
const win = patchedWin;
if (!win) return;
patchedWin = null;
@@ -44,25 +84,21 @@ export function useConsoleErrorCapture(previewIframe: HTMLIFrameElement | null)
const attachErrorCapture = () => {
detachErrorCapture();
resetErrors();
if (previewFrameOpaque(previewIframe)) {
stopSealedReads = readSealedErrors(previewIframe);
return;
}
try {
const win = previewIframe.contentWindow as (Window & typeof globalThis) | null;
if (!win) return;
if ((win as unknown as Record<string, unknown>).__hfErrorCapture) return;
(win as unknown as Record<string, unknown>).__hfErrorCapture = true;
patchedWin = win;
const record = (texts: readonly string[]) => {
if (texts.length === 0) return;
consoleErrorsRef.current = [
...consoleErrorsRef.current,
...texts.map((message) => ({ severity: "error" as const, message })),
];
setConsoleErrors([...consoleErrorsRef.current]);
};
origConsoleError = win.console.error.bind(win.console);
win.console.error = function (...args: unknown[]) {
origConsoleError!(...args);
const text = args.map((a) => (a instanceof Error ? a.message : String(a))).join(" ");
if (!text.includes("favicon")) record([text]);
const text = previewConsoleErrorText(args);
if (text !== null) record([text]);
};
errorHandler = (e: ErrorEvent) => record([e.message || String(e)]);
win.addEventListener("error", errorHandler);
@@ -97,6 +97,16 @@ export async function previewClipManifest(iframe: HTMLIFrameElement): Promise<Cl
return manifest as ClipManifest;
}
export async function previewConsoleErrors(
iframe: HTMLIFrameElement,
from: number,
): Promise<{ errors: string[]; truncated: boolean } | null> {
const reply = await previewRequest(iframe, "console-errors", { from });
const errors: unknown = reply?.errors;
if (!Array.isArray(errors) || typeof reply?.truncated !== "boolean") return null;
return { errors: errors.map(String), truncated: reply.truncated };
}
/** The runtime's computed `properties` for the element `target` names; null when it has none. */
export async function previewComputedStyles(
iframe: HTMLIFrameElement,