diff --git a/packages/core/src/runtime/editingAgent.test.ts b/packages/core/src/runtime/editingAgent.test.ts
index f20dbca530..0bc8f6eb41 100644
--- a/packages/core/src/runtime/editingAgent.test.ts
+++ b/packages/core/src/runtime/editingAgent.test.ts
@@ -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 = `
Hi
diff --git a/packages/core/src/runtime/editingAgent.ts b/packages/core/src/runtime/editingAgent.ts
index 1379d03d45..57310ecc11 100644
--- a/packages/core/src/runtime/editingAgent.ts
+++ b/packages/core/src/runtime/editingAgent.ts
@@ -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;
},
};
}
diff --git a/packages/core/src/runtime/editingPort.test.ts b/packages/core/src/runtime/editingPort.test.ts
index 9fdcfaf147..de6e9ccb45 100644
--- a/packages/core/src/runtime/editingPort.test.ts
+++ b/packages/core/src/runtime/editingPort.test.ts
@@ -75,6 +75,7 @@ describe("createEditingPortClient", () => {
"layers",
"draft",
"gesture-start",
+ "console-errors",
],
});
} finally {
diff --git a/packages/core/src/runtime/editingPort.ts b/packages/core/src/runtime/editingPort.ts
index 149b18b47e..5cae0410dc 100644
--- a/packages/core/src/runtime/editingPort.ts
+++ b/packages/core/src/runtime/editingPort.ts
@@ -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; snap: EditingElementBox[] };
};
+ "console-errors": { params: { from: number }; result: { errors: string[]; truncated: boolean } };
}
export type EditingParams = EditingRequests[K]["params"];
export type EditingResult = 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. */
diff --git a/packages/core/src/studioPreviewMark.ts b/packages/core/src/studioPreviewMark.ts
index 0a0012c692..418a36b945 100644
--- a/packages/core/src/studioPreviewMark.ts
+++ b/packages/core/src/studioPreviewMark.ts
@@ -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}).`;
diff --git a/packages/studio/src/hooks/useConsoleErrorCapture.test.tsx b/packages/studio/src/hooks/useConsoleErrorCapture.test.tsx
index 5543344797..dd74f3cae6 100644
--- a/packages/studio/src/hooks/useConsoleErrorCapture.test.tsx
+++ b/packages/studio/src/hooks/useConsoleErrorCapture.test.tsx
@@ -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 = {};
+ 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);
+});
diff --git a/packages/studio/src/hooks/useConsoleErrorCapture.ts b/packages/studio/src/hooks/useConsoleErrorCapture.ts
index f4d416927d..af0460f2dd 100644
--- a/packages/studio/src/hooks/useConsoleErrorCapture.ts
+++ b/packages/studio/src/hooks/useConsoleErrorCapture.ts
@@ -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 | 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).__hfErrorCapture) return;
(win as unknown as Record).__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);
diff --git a/packages/studio/src/player/lib/previewChannel.ts b/packages/studio/src/player/lib/previewChannel.ts
index e63e0ec570..7c0c79bca3 100644
--- a/packages/studio/src/player/lib/previewChannel.ts
+++ b/packages/studio/src/player/lib/previewChannel.ts
@@ -97,6 +97,16 @@ export async function previewClipManifest(iframe: HTMLIFrameElement): Promise {
+ 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,