harness/browser_debug.py

"""Headless-Chromium console-error capture for a world.html.

Deliberately does NOT try to verify anything about rendering (no screenshot,
no waiting on a render/camera signal, no GPU flag tuning). It only needs the
page's JS to execute far enough to throw or not — console.error calls and
uncaught exceptions fire from the JS engine regardless of whether WebGL ever
paints a pixel, so this sidesteps the swiftshader/rAF-throttling uncertainty
that sank the earlier headless-rendering spike (see project memory
avoid-headless-browser-infra). If that assumption stops holding for some
world.html, treat it as a fresh signal to revisit, not something to force
through by adding rendering waits here.

Each returned error string carries a `(line N, col N)` suffix when a source
location could be found — this is what lets the fix node send the model a
small windowed excerpt around the error instead of the entire file (see
generate.py's _build_fix_context). Getting that location isn't free:
Playwright's `pageerror` gives a full call-stack for a runtime error
(TypeError, ReferenceError, ...) but an EMPTY stack for a parse-time
SyntaxError — confirmed directly against a real broken world.html, not
assumed — because V8 never builds a call stack for a script that failed to
parse in the first place. A `window.addEventListener('error'/'unhandled
rejection')` listener injected via `add_init_script` gets lineno/colno for
both cases, since the ErrorEvent/PromiseRejectionEvent carries source
position independent of whether a stack exists. `console.error()` calls
get their location straight from Playwright's own `msg.location`, no
injection needed.

The suffix reports the CALLER FRAMES too, not just the throw site:
`(line 104, col 27; called from line 383, line 397)`. This is not
cosmetic — for a whole class of JS errors the throw site is correct code
and the bug is in the caller. Seen for real: a world.html defined
`jit=(c,rnd)=>c*(0.9+rnd()*0.2)` on line 104 and called it as
`jit(color, Rv())` — passing the RNG's *result* instead of the RNG
itself — on lines 383/397/412. `rnd is not a function` was reported at
line 104, the fix node windowed +/-40 lines around it, and the model was
handed a perfectly correct arrow function and asked what was wrong with
it. Three fix rounds produced zero edits, which was the only honest
answer available to it. The caller frames were sitting in `exc.stack`
the whole time and were being discarded here. Frames are filtered to
this document (CDN/three.module.js frames are noise for a fix window),
deduplicated for recursion, and capped at MAX_CALLER_FRAMES so a deep
in-file stack can't expand the "windowed" excerpt into the whole file.
"""

from __future__ import annotations

import json
import re
from pathlib import Path

from playwright.sync_api import sync_playwright

DEFAULT_TIMEOUT_MS = 5000
DEFAULT_NAV_TIMEOUT_MS = 15000
# How many caller frames (beyond the throw site) to report. Each one becomes
# another +/-FIX_CONTEXT_LINES window in the fix prompt, so this is the knob
# that keeps a "windowed" fix round actually windowed: 4 callers x 81 lines is
# a worst case of ~405 lines before overlap-merging, still a small fraction of
# a typical several-hundred-to-thousand-line world.html. Frames past this are
# dropped from the deepest end — the immediate caller is where these bugs
# overwhelmingly live, and top-level init frames add the least.
MAX_CALLER_FRAMES = 4

_LOC_MARKER = "__WB_LOC__"
_ERR_STACK_MARKER = "__WB_ERRSTACK__"
_LOCATION_INIT_SCRIPT = f"""
window.addEventListener('error', (e) => {{
  try {{
    console.log({_LOC_MARKER!r}, JSON.stringify({{lineno: e.lineno, colno: e.colno}}));
  }} catch (_) {{}}
}});
// console.error carries no stack of its own, and when a library logs it
// (three.module.js's `computeBoundingSphere(): radius is NaN`) its location is
// the library's line, which the fix node can't edit or window. Record the JS
// stack at the call so the page's own frames — the code that handed the
// library bad data — can be reported instead. Keyed by the first argument
// so it's matched to its console message by text, not by arrival order:
// the browser emits console errors of its own (failed resource loads) that
// never pass through this wrapper, and an ordering queue would desync.
(() => {{
  const original = console.error.bind(console);
  console.error = (...args) => {{
    try {{
      console.debug({_ERR_STACK_MARKER!r}, JSON.stringify({{first: String(args[0]), stack: new Error().stack}}));
    }} catch (_) {{}}
    original(...args);
  }};
}})();
window.addEventListener('unhandledrejection', (e) => {{
  try {{
    const r = e.reason;
    const m = r && r.stack ? String(r.stack).match(/:(\\d+):(\\d+)\\)?\\s*$/m) : null;
    console.log({_LOC_MARKER!r}, JSON.stringify({{lineno: m ? +m[1] : null, colno: m ? +m[2] : null}}));
  }} catch (_) {{}}
}});
"""


def _loc_suffix(lineno: int | None, colno: int | None, callers: list[int] | None = None) -> str:
    """Render the `(line N, col N; called from line A, line B)` suffix.

    generate.py's _LOCATION_RE parses this exact shape back out, so the
    two must change together — the whole parenthesized group is isolated
    there and every `line N` inside it becomes a fix-context window.
    """
    if not lineno:
        # 0 is not a line: the browser reports lineno 0 for failures with no
        # position in the page (a module that fails to resolve inside an
        # imported file). Printing `(line 0, col 0)` pointed the fix node at
        # the top of world.html for a problem that wasn't in it.
        return ""
    head = f"line {lineno}, col {colno}" if colno is not None else f"line {lineno}"
    if callers:
        head += "; called from " + ", ".join(f"line {n}" for n in callers)
    return f" ({head})"


def _stack_frames(stack: str, page_url: str) -> list[tuple[int, int]]:
    """Every `(line, col)` in `stack` belonging to `page_url`, in call order.

    Frames from the Three.js CDN are deliberately excluded: they're not
    editable by the fix node, and windowing around them would waste the
    context budget on library internals. Deduplicated because a recursive
    or per-frame throw repeats the same frame many times over.
    """
    frame_re = re.compile(re.escape(page_url) + r":(\d+):(\d+)")
    frames: dict[tuple[int, int], None] = {}
    for line in stack.split("\n"):
        m = frame_re.search(line)
        if m:
            frames.setdefault((int(m.group(1)), int(m.group(2))), None)
    return list(frames.keys())


_UNRESOLVED_RE = re.compile(r'Failed to resolve module specifier "([^"]+)"')


def _importers(specifier: str, sources: dict[str, str]) -> list[tuple[str, int]]:
    """(url, line) of every `from 'X'` / `import 'X'` / `import('X')` of `specifier`."""
    rx = re.compile(r"""(?:\bfrom|\bimport)\s*\(?\s*['"]""" + re.escape(specifier) + r"""['"]""")
    hits = []
    for url, text in sources.items():
        for i, line in enumerate(text.split("\n"), 1):
            if rx.search(line):
                hits.append((url, i))
    return hits


def check_console_errors(
    html_path: Path,
    *,
    timeout_ms: int = DEFAULT_TIMEOUT_MS,
    nav_timeout_ms: int = DEFAULT_NAV_TIMEOUT_MS,
    modules: dict[str, str] | None = None,
) -> list[str]:
    """Load `html_path` headless and return distinct console/page errors seen,
    each suffixed with `(line N, col N)` when a location could be found, plus
    `; called from line A, line B` for up to MAX_CALLER_FRAMES in-document
    caller frames when the error carries a stack.

    Order-preserving de-duplication: a per-frame throw inside an animation
    loop (requestAnimationFrame) repeats the identical message every frame
    and would otherwise flood the result with hundreds of copies of the same
    error (seen for real: 604 identical entries for one bug) — collapsed to
    one here since that's one bug, not six hundred.

    `modules`, if given, is filled with {url: source} for every script module
    the page fetched over http(s) — the imported files an error can live in
    but that no tool looking at world.html alone can see. A bare-specifier
    failure (`Failed to resolve module specifier "three"`) raised inside an
    imported file is annotated with the file and line that imported it.
    """
    html_path = Path(html_path).resolve()
    page_url = f"file://{html_path}"
    seen: dict[str, None] = {}
    # window.onerror/unhandledrejection fire in the same browser-side order as
    # the pageerror events they correspond to, so a FIFO queue correlates them
    # without needing to text-match the two independent event streams.
    loc_queue: list[tuple[int | None, int | None]] = []
    # (first console.error argument, in-document frames), see the init script.
    error_stacks: list[tuple[str, list[tuple[int, int]]]] = []

    def _record(text: str) -> None:
        seen.setdefault(text, None)

    def _on_console(msg) -> None:
        if msg.text.startswith(_LOC_MARKER):
            try:
                data = json.loads(msg.text[len(_LOC_MARKER) :].strip())
            except (json.JSONDecodeError, ValueError):
                return
            loc_queue.append((data.get("lineno"), data.get("colno")))
            return
        if msg.text.startswith(_ERR_STACK_MARKER):
            try:
                data = json.loads(msg.text[len(_ERR_STACK_MARKER) :].strip())
            except (json.JSONDecodeError, ValueError):
                return
            error_stacks.append((data.get("first") or "", _stack_frames(data.get("stack") or "", page_url)))
            return
        if msg.type == "error":
            frames: list[tuple[int, int]] = []
            for i, (first, stack_frames) in enumerate(error_stacks):
                if msg.text.startswith(first):
                    frames = stack_frames
                    del error_stacks[i]
                    break
            loc = msg.location or {}
            lineno, colno = loc.get("lineNumber"), loc.get("columnNumber")
            if loc.get("url") != page_url:
                # Logged from inside a library: its line is the library's, not
                # ours. The page's own frames say which of our lines called in.
                lineno, colno = frames[0] if frames else (None, None)
            callers = [ln for ln, _ in frames if ln != lineno][:MAX_CALLER_FRAMES]
            _record(f"[console.error] {msg.text}{_loc_suffix(lineno, colno, callers)}")

    def _on_pageerror(exc) -> None:
        # Runtime errors (unlike parse-time SyntaxErrors, which V8 never
        # builds a stack for) carry a real stack. Parse it always, not just
        # as a fallback for a missing primary location: the frames AFTER the
        # throw site are the point — see the module docstring's jit/rnd case.
        frames = _stack_frames(getattr(exc, "stack", "") or "", page_url)
        lineno = colno = None
        if loc_queue:
            lineno, colno = loc_queue.pop(0)
        if not lineno and frames:
            lineno, colno = frames[0]
        callers = [ln for ln, _ in frames if ln != lineno][:MAX_CALLER_FRAMES]
        _record(f"[uncaught] {exc}{_loc_suffix(lineno, colno, callers)}")

    with sync_playwright() as p:
        browser = p.chromium.launch(headless=True)
        page = browser.new_page()
        page.add_init_script(_LOCATION_INIT_SCRIPT)
        page.on("console", _on_console)
        page.on("pageerror", _on_pageerror)
        script_responses: list = []
        page.on(
            "response",
            lambda r: script_responses.append(r)
            if r.request.resource_type == "script" and r.url.startswith(("http://", "https://"))
            else None,
        )

        try:
            page.goto(page_url, timeout=nav_timeout_ms)
        except Exception as exc:  # noqa: BLE001 — navigation failure is itself a finding
            _record(f"[navigation] {exc}")
        else:
            page.wait_for_timeout(timeout_ms)

        # Read bodies after the page settled, not inside the event callback
        # (the sync API must not block inside its own event dispatch).
        fetched: dict[str, str] = {}
        for response in script_responses:
            try:
                fetched.setdefault(response.url, response.text())
            except Exception:  # noqa: BLE001 — a body that can't be read is simply not available
                pass
        browser.close()

    if modules is not None:
        modules.update(fetched)
    page_source = html_path.read_text(encoding="utf-8", errors="ignore")
    return [_annotate_unresolved(e, fetched, page_source) for e in seen]


def _annotate_unresolved(error: str, fetched: dict[str, str], page_source: str) -> str:
    """Name where an unresolvable import actually is.

    The browser gives no position for this failure, and the culprit is often
    not the page: a CDN module like OrbitControls.js does `from 'three'`, a
    bare specifier that only resolves through an import map in the page. A
    fix agent told only the message searches world.html, finds nothing but
    full URLs, and has nothing left but guesses.
    """
    m = _UNRESOLVED_RE.search(error)
    if not m or "imported by" in error:
        return error
    spec = m.group(1)
    in_page = _importers(spec, {"": page_source})
    if in_page:
        return f"{error} (line {in_page[0][1]})"
    where = _importers(spec, fetched)
    if not where:
        return error
    by = "; ".join(f"{url} line {line}" for url, line in where[:4])
    return (
        f"{error} — imported by {by}, not by world.html. A bare specifier in an "
        f"imported module only resolves through an import map in the page "
        f"(<script type=\"importmap\">) that maps \"{spec}\" to a URL."
    )