Skip to content

Lightpanda: the headless browser designed for AI and automation

ops: capture and expose page issue summary

Karl Seguinf875090d447f
diff --git a/src/browser/Frame.zig b/src/browser/Frame.zig
index 328b10577..e6c9226be 100644
--- a/src/browser/Frame.zig
+++ b/src/browser/Frame.zig
@@ -869,6 +869,10 @@ pub fn navigate(self: *Frame, request_url: [:0]const u8, opts: NavigateOpts) !vo
return;
}
+ if (is_root) {
+ // Status counts are per top-level navigation.
+ page.status = .{};
+ }
self._http_status = null;
self._bot_challenge = null;
self._http_headers = .empty;
@@ -2267,7 +2271,7 @@ pub fn iframeAddedCallback(self: *Frame, iframe: *IFrame) !void {
return;
}
if (self._session.load_resources.iframe == false) {
- log.warnDisabledIFrame();
+ self.page.status.noteSkipped(.iframe);
iframe._executed = true;
return;
}
@@ -2732,6 +2736,7 @@ pub fn loadExternalStylesheet(self: *Frame, link: *Element.Html.Link, href: []co
const session = self._session;
if (session.load_resources.stylesheet == false) {
+ self.page.status.noteSkipped(.stylesheet);
return self.queueLoad(Factory.protoOf(link));
}
diff --git a/src/browser/Page.zig b/src/browser/Page.zig
index f23794cd3..7283e44c6 100644
--- a/src/browser/Page.zig
+++ b/src/browser/Page.zig
@@ -26,6 +26,7 @@ const Session = @import("Session.zig");
const Factory = @import("Factory.zig");
const Viewport = @import("Viewport.zig");
const EventManagerBase = @import("EventManagerBase.zig");
+const PageStatus = @import("PageStatus.zig");
const Blob = @import("webapi/Blob.zig");
const Node = @import("webapi/Node.zig");
@@ -80,9 +81,8 @@ style_version: usize = 0,
// when it was called
broadcast_sequence: u64 = 0,
-// Uncaught JS errors attributed to this Page (all of its frames and workers):
-// Not exhaustive: some swallowed-callback paths aren't routed here.
-js_error_count: usize = 0,
+// Health signals for this Page
+status: PageStatus = .{},
// Entered (logScope) around any work done on this Page's behalf.
log_context: log.PageContext,
@@ -393,7 +393,7 @@ pub fn deinit(self: *Page) void {
}
pub fn recordJsError(self: *Page, err: anyerror) void {
- self.js_error_count += 1;
+ self.status.js_errors += 1;
lp.metrics.js_errors.incr(if (err == error.JsException) .js_exception else .other);
}
@@ -576,13 +576,12 @@ fn appendFrameExecutions(frame: *Frame, origin: []const u8, arena: Allocator, li
const testing = @import("../testing.zig");
-test "Page: js_error_count" {
- testing.expectLog(&.{ .page_error, .page_error });
-
+test "Page: status counts uncaught JS errors" {
// One uncaught top-level script exception, one uncaught timer-callback
// exception.
+ testing.expectLog(&.{ .page_error, .page_error });
const page = try testing.pageTest("page_js_error.html", .{});
defer page.close();
- try testing.expectEqual(2, page.frame().?.page.js_error_count);
+ try testing.expectEqual(2, page.frame().?.page.status.js_errors);
}
diff --git a/src/browser/PageStatus.zig b/src/browser/PageStatus.zig
new file mode 100644
index 000000000..c61bf7408
--- /dev/null
+++ b/src/browser/PageStatus.zig
@@ -0,0 +1,235 @@
+// Copyright (C) 2023-2026 Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <[email protected]>
+// Pierre Tachoire <[email protected]>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+const std = @import("std");
+const lp = @import("lightpanda");
+
+const log = lp.log;
+
+const PageStatus = @This();
+
+pub const Unsupported = enum {
+ webgl,
+ canvas2d,
+};
+
+pub const Skipped = enum {
+ iframe,
+ worker,
+ image,
+ stylesheet,
+};
+
+js_errors: u32 = 0,
+skipped: Counts(Skipped) = .{},
+unsupported: Counts(Unsupported) = .{},
+// Globals that uncaught ReferenceErrors named. Most of what a page needs and
+// we lack shows up here first, before any call we could count: TradingView
+// dies at `new Path2D()` and never reaches getContext. Deduped and capped;
+// the names are whatever V8 put in the message, site bugs included.
+missing_globals: MissingGlobals = .{},
+
+// Missing globals that stand for a feature we already count, so the common
+// cases stay a one-field check. Only globals we don't register.
+const global_features = std.StaticStringMap(Unsupported).initComptime(.{
+ .{ "Path2D", .canvas2d },
+ .{ "ImageBitmap", .canvas2d },
+ .{ "createImageBitmap", .canvas2d },
+ .{ "WebGL2RenderingContext", .webgl },
+});
+
+// A bit of a hack. Say we want to report that canvas was used, but some sites
+// will try to create a Path2D first and fail there. We do have a
+// unknownObjectPropertyCallback in bridge, but that gets called on the global
+// before v8 tries to resolve it itself, so it's very noisy and full of site
+// and framework-specific globals. Instead, we try to parse an uncaught error.
+// (which has its own issues, what if the site catches it, but presumably, the
+// site catches it because it can handle it).
+pub fn noteException(self: *PageStatus, message: []const u8) void {
+ const prefix = "ReferenceError: ";
+ const suffix = " is not defined";
+ if (message.len <= prefix.len + suffix.len) {
+ return;
+ }
+
+ if (std.mem.startsWith(u8, message, prefix) == false) {
+ return;
+ }
+ if (std.mem.endsWith(u8, message, suffix) == false) {
+ return;
+ }
+
+ const name = message[prefix.len .. message.len - suffix.len];
+ for (name) |c| {
+ if (std.ascii.isAlphanumeric(c) == false and c != '_' and c != '$') return;
+ }
+ if (self.missing_globals.add(name) == false) return;
+
+ log.info(.not_implemented, "missing global", .{ .name = name });
+ if (global_features.get(name)) |feature| {
+ self.noteUnsupported(feature);
+ }
+}
+
+pub fn noteUnsupported(self: *PageStatus, what: Unsupported) void {
+ if (self.unsupported.incr(what) == 1) {
+ log.info(.not_implemented, "unsupported feature used", .{ .feature = what });
+ }
+}
+
+pub fn noteSkipped(self: *PageStatus, what: Skipped) void {
+ if (self.skipped.incr(what) != 1) {
+ return;
+ }
+
+ const level: log.Level = switch (what) {
+ .iframe, .worker => .warn,
+ .image, .stylesheet => .debug,
+ };
+
+ switch (what) {
+ inline else => |w| log.log(.disabled, level, "resource skipped", .{ .resource = w, .hint = "enable via --load-resources " ++ @tagName(w) }),
+ }
+}
+
+pub const MissingGlobals = struct {
+ const max = 8;
+ const max_len = 48;
+
+ _count: u8 = 0,
+ _lens: [max]u8 = @splat(0),
+ _names: [max][max_len]u8 = undefined,
+
+ pub fn get(self: *const MissingGlobals, i: usize) []const u8 {
+ return self._names[i][0..self._lens[i]];
+ }
+
+ pub fn count(self: *const MissingGlobals) usize {
+ return self._count;
+ }
+
+ fn add(self: *MissingGlobals, name: []const u8) bool {
+ if (name.len > max_len) {
+ // too long to store
+ return false;
+ }
+ for (0..self._count) |i| {
+ if (std.mem.eql(u8, self.get(i), name)) {
+ // already present
+ return false;
+ }
+ }
+ if (self._count == max) {
+ // our list is full
+ return false;
+ }
+ @memcpy(self._names[self._count][0..name.len], name);
+ self._lens[self._count] = @intCast(name.len);
+ self._count += 1;
+ return true;
+ }
+
+ pub fn jsonStringify(self: *const MissingGlobals, w: anytype) !void {
+ try w.beginArray();
+ for (0..self._count) |i| {
+ try w.write(self.get(i));
+ }
+ try w.endArray();
+ }
+};
+
+fn Counts(comptime E: type) type {
+ return struct {
+ _values: std.EnumArray(E, u32) = .initFill(0),
+
+ const Self = @This();
+
+ pub fn get(self: *const Self, tag: E) u32 {
+ return self._values.get(tag);
+ }
+
+ fn incr(self: *Self, tag: E) u32 {
+ const ptr = self._values.getPtr(tag);
+ ptr.* += 1;
+ return ptr.*;
+ }
+
+ pub fn jsonStringify(self: *const Self, w: anytype) !void {
+ try w.beginObject();
+ inline for (comptime std.enums.values(E)) |tag| {
+ try w.objectField(@tagName(tag));
+ try w.write(self._values.get(tag));
+ }
+ try w.endObject();
+ }
+ };
+}
+
+const testing = @import("../testing.zig");
+test "PageStatus: missing globals from uncaught ReferenceErrors" {
+ const page = try testing.pageTest("page_missing_global.html", .{});
+ defer page.close();
+
+ const status = &page.frame().?.page.status;
+ try testing.expectEqual(5, status.js_errors);
+ try testing.expectEqual(1, status.unsupported.get(.canvas2d));
+ try testing.expectEqual(1, status.unsupported.get(.webgl));
+
+ const json = try std.json.Stringify.valueAlloc(testing.allocator, status.missing_globals, .{});
+ defer testing.allocator.free(json);
+ try testing.expectEqual("[\"Path2D\",\"someUndefinedThing\",\"WebGL2RenderingContext\"]", json);
+}
+
+test "PageStatus: noteException only takes well-formed ReferenceErrors" {
+ var status: PageStatus = .{};
+ status.noteException("TypeError: Path2D is not defined");
+ status.noteException("ReferenceError: is not defined");
+ status.noteException("ReferenceError: a b is not defined");
+ status.noteException("ReferenceError: x is not defined, really");
+ try testing.expectEqual(0, status.missing_globals.count());
+
+ status.noteException("ReferenceError: $_ok1 is not defined");
+ status.noteException("ReferenceError: $_ok1 is not defined");
+ try testing.expectEqual(1, status.missing_globals.count());
+ try testing.expectEqual("$_ok1", status.missing_globals.get(0));
+
+ // Capped: the ninth distinct name is dropped, the first eight kept.
+ inline for (0..9) |i| {
+ status.noteException(std.fmt.comptimePrint("ReferenceError: g{d} is not defined", .{i}));
+ }
+ try testing.expectEqual(8, status.missing_globals.count());
+ try testing.expectEqual("g6", status.missing_globals.get(7));
+}
+
+test "PageStatus: counts serialize as an object with every tag" {
+ testing.expectLog(&.{.disabled});
+
+ var status: PageStatus = .{};
+ status.noteUnsupported(.webgl);
+ status.noteUnsupported(.webgl);
+ status.noteSkipped(.iframe);
+
+ try testing.expectEqual(2, status.unsupported.get(.webgl));
+ try testing.expectEqual(0, status.unsupported.get(.canvas2d));
+
+ const json = try std.json.Stringify.valueAlloc(testing.arena_allocator, status.unsupported, .{});
+ try testing.expectEqual("{\"webgl\":2,\"canvas2d\":0}", json);
+
+ const skipped = try std.json.Stringify.valueAlloc(testing.arena_allocator, status.skipped, .{});
+ try testing.expectEqual("{\"iframe\":1,\"worker\":0,\"image\":0,\"stylesheet\":0}", skipped);
+}
diff --git a/src/browser/tests/cdp/page_status.html b/src/browser/tests/cdp/page_status.html
new file mode 100644
index 000000000..e4c277502
--- /dev/null
+++ b/src/browser/tests/cdp/page_status.html
@@ -0,0 +1,27 @@
+<!DOCTYPE html>
+<html>
+<head>
+ <!-- Fixture for LP.getPageStatus: every resource type is skipped (the test
+ turns them all off), two WebGL probes, three 2D paints, one uncaught
+ error. Nothing here is ever fetched, so the targets need not exist. -->
+ <link rel="stylesheet" href="/src/browser/tests/cdp/page_status.css">
+</head>
+<body>
+ <iframe src="/src/browser/tests/cdp/iframe/target.html"></iframe>
+ <img src="/src/browser/tests/cdp/page_status.png">
+ <canvas id="c" width="10" height="10"></canvas>
+ <script>
+ const c = document.getElementById('c');
+ c.getContext('webgl');
+ c.getContext('experimental-webgl');
+ const ctx = c.getContext('2d');
+ ctx.beginPath();
+ ctx.rect(0, 0, 5, 5);
+ ctx.fill();
+ ctx.fillRect(0, 0, 1, 1);
+ ctx.fillText('x', 0, 0);
+ new Worker('/src/browser/tests/cdp/page_status_worker.js');
+ throw new Error('boom');
+ </script>
+</body>
+</html>
diff --git a/src/browser/tests/page_missing_global.html b/src/browser/tests/page_missing_global.html
new file mode 100644
index 000000000..c5ea27a31
--- /dev/null
+++ b/src/browser/tests/page_missing_global.html
@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+<body>
+ <!-- Fixture for PageStatus.missing_globals: each script is its own
+ uncaught error. Path2D twice (deduped), a lowercase site-style
+ name, a TypeError (ignored), and a ReferenceError that arrives as
+ an unhandled rejection. -->
+ <script>new Path2D();</script>
+ <script>Path2D.prototype;</script>
+ <script>someUndefinedThing();</script>
+ <script>null.x;</script>
+ <script>(async () => { new WebGL2RenderingContext(); })();</script>
+</body>
+</html>
diff --git a/src/browser/tools.zig b/src/browser/tools.zig
index 8e8723f7c..45764039d 100644
--- a/src/browser/tools.zig
+++ b/src/browser/tools.zig
@@ -1061,6 +1061,9 @@ fn callInner(
if (session.currentFrame()) |frame| result.navigated = frame._frame_id != frame_before;
if (opts.nav_note) {
if (session.currentFrame()) |frame| {
+ if (result.navigated) {
+ if (try weaknessNote(arena, frame)) |n| result.text = try arena.print("{s}\n\n{s}", .{ n, result.text });
+ }
const note = if (result.navigated)
try navErrorNote(arena, frame)
else if (tool.navigatesToUrl())
@@ -1253,6 +1256,25 @@ fn movedNote(arena: std.mem.Allocator, arguments: ?std.json.Value, frame: *const
return try arena.print("The page is at {s}, not {s}: a redirect or an in-page navigation moved it, and this reads it as it is. Use goto to reload {s}.", .{ frame.url, url, url });
}
+/// What a full browser would have shown that this page's reads will lack.
+/// Only the signals that change what the model should do; canvas 2D is left
+/// out because fingerprinting scripts paint on most pages.
+fn weaknessNote(arena: std.mem.Allocator, frame: *const lp.Frame) !?[]const u8 {
+ const status = &frame.page.status;
+ var notes: std.ArrayList([]const u8) = .empty;
+ if (status.unsupported.get(.webgl) > 0) {
+ try notes.append(arena, "The page asked for WebGL, which Lightpanda does not provide: anything it renders that way is missing.");
+ }
+ const iframes = status.skipped.get(.iframe);
+ if (iframes > 0) {
+ try notes.append(arena, try arena.print("{d} iframe(s) were not loaded: subframe loading is off.", .{iframes}));
+ }
+ if (notes.items.len == 0) {
+ return null;
+ }
+ return try std.mem.join(arena, " ", notes.items);
+}
+
/// Error and challenge pages would otherwise read as the requested content.
fn navErrorNote(arena: std.mem.Allocator, frame: *const lp.Frame) !?[]const u8 {
if (frame._bot_challenge) |challenge| {
@@ -3006,6 +3028,26 @@ test "tools: goto flags an error status instead of reporting success" {
try std.testing.expectEqualStrings("HTTP 429 Too Many Requests: this is likely an error or rate-limit page, not the requested content.\n\nNavigated. HTTP 429 Too Many Requests.", r.text);
}
+test "tools: goto says what a full browser would have shown" {
+ var registry: NodeRegistry = .init(std.testing.allocator);
+ defer registry.deinit();
+
+ const session = testing.test_session;
+ defer if (session.primaryPage()) |page| page.close();
+
+ const iframes = session.load_resources.iframe;
+ session.load_resources.iframe = false;
+ defer session.load_resources.iframe = iframes;
+ testing.expectLog(&.{.disabled});
+
+ const aa = testing.arena_allocator;
+ const args = try std.json.parseFromSliceLeaky(std.json.Value, aa,
+ \\{"url":"http://localhost:9582/src/browser/tests/cdp/page_status.html"}
+ , .{});
+ const r = try call(aa, session, &registry, "goto", args, .{ .nav_note = true, .source = .user });
+ try std.testing.expectEqualStrings("The page asked for WebGL, which Lightpanda does not provide: anything it renders that way is missing. 1 iframe(s) were not loaded: subframe loading is off.\n\nNavigated. HTTP 200 OK.", r.text);
+}
+
test "tools: a read tool navigating by url flags an error status" {
var registry: NodeRegistry = .init(std.testing.allocator);
defer registry.deinit();
diff --git a/src/browser/webapi/SharedWorkerGlobalScope.zig b/src/browser/webapi/SharedWorkerGlobalScope.zig
index 189bc2594..c72a220b5 100644
--- a/src/browser/webapi/SharedWorkerGlobalScope.zig
+++ b/src/browser/webapi/SharedWorkerGlobalScope.zig
@@ -85,7 +85,7 @@ pub fn init(frame: *Frame, url: [:0]const u8, name: []const u8, worker_type: Wor
errdefer proto.deinit();
if (session.load_resources.worker == false) {
- log.warnDisabledWorker();
+ frame.page.status.noteSkipped(.worker);
return self;
}
diff --git a/src/browser/webapi/Window.zig b/src/browser/webapi/Window.zig
index b89d6735e..d0b3f8e34 100644
--- a/src/browser/webapi/Window.zig
+++ b/src/browser/webapi/Window.zig
@@ -502,6 +502,7 @@ pub fn reportError(self: *Window, err: js.Value, frame: *Frame) !void {
defer frame.js.call_depth = call_depth;
frame.page.recordJsError(error.JsException);
+ frame.page.status.noteException(err.toStringSlice() catch "");
const location = err.errorLocation(frame.call_arena) catch js.Value.ErrorLocation{};
@@ -908,6 +909,9 @@ pub fn unhandledPromiseRejection(self: *Window, no_handler: bool, rejection: js.
if (no_handler) {
frame.page.recordJsError(error.JsException);
+ if (rejection.reason()) |reason| {
+ frame.page.status.noteException(reason.toStringSlice() catch "");
+ }
}
const target = self.asEventTarget();
diff --git a/src/browser/webapi/Worker.zig b/src/browser/webapi/Worker.zig
index 2a8f0be32..2353e2d74 100644
--- a/src/browser/webapi/Worker.zig
+++ b/src/browser/webapi/Worker.zig
@@ -89,7 +89,7 @@ pub fn init(url: []const u8, options: ?WorkerOptions, frame: *Frame) !*Worker {
try frame.trackWorker(self);
if (session.load_resources.worker == false) {
- log.warnDisabledWorker();
+ frame.page.status.noteSkipped(.worker);
return self;
}
diff --git a/src/browser/webapi/WorkerGlobalScope.zig b/src/browser/webapi/WorkerGlobalScope.zig
index 35ebbe5c6..493780aaa 100644
--- a/src/browser/webapi/WorkerGlobalScope.zig
+++ b/src/browser/webapi/WorkerGlobalScope.zig
@@ -340,6 +340,9 @@ pub fn unhandledPromiseRejection(self: *WorkerGlobalScope, no_handler: bool, rej
if (no_handler) {
self.page.recordJsError(error.JsException);
+ if (rejection.reason()) |reason| {
+ self.page.status.noteException(reason.toStringSlice() catch "");
+ }
}
const target = self.asEventTarget();
@@ -435,6 +438,7 @@ pub fn reportError(self: *WorkerGlobalScope, err: JS.Value) !void {
defer self.js.call_depth = call_depth;
self.page.recordJsError(error.JsException);
+ self.page.status.noteException(err.toStringSlice() catch "");
self._reporting_error = true;
defer self._reporting_error = false;
diff --git a/src/browser/webapi/canvas/CanvasRenderingContext2D.zig b/src/browser/webapi/canvas/CanvasRenderingContext2D.zig
index cbd80fbe9..cc780adb7 100644
--- a/src/browser/webapi/canvas/CanvasRenderingContext2D.zig
+++ b/src/browser/webapi/canvas/CanvasRenderingContext2D.zig
@@ -83,11 +83,15 @@ fn createImageData(
}
}
-fn putImageData(_: *const CanvasRenderingContext2D, _: *ImageData, _: f64, _: f64, _: ?f64, _: ?f64, _: ?f64, _: ?f64) void {}
+fn putImageData(_: *const CanvasRenderingContext2D, _: *ImageData, _: f64, _: f64, _: ?f64, _: ?f64, _: ?f64, _: ?f64, exec: *const Execution) void {
+ painted(exec);
+}
// CanvasImageSource (HTMLImageElement, HTMLCanvasElement, ImageBitmap, ...) is
// just taken as a js.Value for now since we don't use it, and that's much easier.
-fn drawImage(_: *const CanvasRenderingContext2D, _: js.Value, _: f64, _: f64, _: ?f64, _: ?f64, _: ?f64, _: ?f64, _: ?f64, _: ?f64) void {}
+fn drawImage(_: *const CanvasRenderingContext2D, _: js.Value, _: f64, _: f64, _: ?f64, _: ?f64, _: ?f64, _: ?f64, _: ?f64, _: ?f64, exec: *const Execution) void {
+ painted(exec);
+}
fn getImageData(
_: *const CanvasRenderingContext2D,
@@ -162,8 +166,12 @@ pub fn transform(_: *CanvasRenderingContext2D, _: f64, _: f64, _: f64, _: f64, _
fn setTransform(_: *CanvasRenderingContext2D, _: f64, _: f64, _: f64, _: f64, _: f64, _: f64) void {}
fn resetTransform(_: *CanvasRenderingContext2D) void {}
fn clearRect(_: *CanvasRenderingContext2D, _: f64, _: f64, _: f64, _: f64) void {}
-fn fillRect(_: *CanvasRenderingContext2D, _: f64, _: f64, _: f64, _: f64) void {}
-fn strokeRect(_: *CanvasRenderingContext2D, _: f64, _: f64, _: f64, _: f64) void {}
+fn fillRect(_: *CanvasRenderingContext2D, _: f64, _: f64, _: f64, _: f64, exec: *const Execution) void {
+ painted(exec);
+}
+fn strokeRect(_: *CanvasRenderingContext2D, _: f64, _: f64, _: f64, _: f64, exec: *const Execution) void {
+ painted(exec);
+}
fn beginPath(_: *CanvasRenderingContext2D) void {}
fn closePath(_: *CanvasRenderingContext2D) void {}
fn moveTo(_: *CanvasRenderingContext2D, _: f64, _: f64) void {}
@@ -173,11 +181,23 @@ fn bezierCurveTo(_: *CanvasRenderingContext2D, _: f64, _: f64, _: f64, _: f64, _
pub fn arc(_: *CanvasRenderingContext2D, _: f64, _: f64, _: f64, _: f64, _: f64, _: ?bool) void {}
fn arcTo(_: *CanvasRenderingContext2D, _: f64, _: f64, _: f64, _: f64, _: f64) void {}
pub fn rect(_: *CanvasRenderingContext2D, _: f64, _: f64, _: f64, _: f64) void {}
-pub fn fill(_: *CanvasRenderingContext2D) void {}
-pub fn stroke(_: *CanvasRenderingContext2D) void {}
+pub fn fill(_: *CanvasRenderingContext2D, exec: *const Execution) void {
+ painted(exec);
+}
+pub fn stroke(_: *CanvasRenderingContext2D, exec: *const Execution) void {
+ painted(exec);
+}
pub fn clip(_: *CanvasRenderingContext2D) void {}
-fn fillText(_: *CanvasRenderingContext2D, _: []const u8, _: f64, _: f64, _: ?f64) void {}
-fn strokeText(_: *CanvasRenderingContext2D, _: []const u8, _: f64, _: f64, _: ?f64) void {}
+fn fillText(_: *CanvasRenderingContext2D, _: []const u8, _: f64, _: f64, _: ?f64, exec: *const Execution) void {
+ painted(exec);
+}
+fn strokeText(_: *CanvasRenderingContext2D, _: []const u8, _: f64, _: f64, _: ?f64, exec: *const Execution) void {
+ painted(exec);
+}
+
+fn painted(exec: *const Execution) void {
+ exec.page.status.noteUnsupported(.canvas2d);
+}
pub const JsApi = struct {
pub const bridge = js.Bridge(CanvasRenderingContext2D);
@@ -226,8 +246,8 @@ pub const JsApi = struct {
pub const fillStyle = bridge.accessor(CanvasRenderingContext2D.getFillStyle, CanvasRenderingContext2D.setFillStyle, .{});
pub const createImageData = bridge.function(CanvasRenderingContext2D.createImageData, .{});
- pub const putImageData = bridge.function(CanvasRenderingContext2D.putImageData, .{ .noop = true });
- pub const drawImage = bridge.function(CanvasRenderingContext2D.drawImage, .{ .noop = true });
+ pub const putImageData = bridge.function(CanvasRenderingContext2D.putImageData, .{});
+ pub const drawImage = bridge.function(CanvasRenderingContext2D.drawImage, .{});
pub const getImageData = bridge.function(CanvasRenderingContext2D.getImageData, .{});
pub const save = bridge.function(CanvasRenderingContext2D.save, .{ .noop = true });
pub const restore = bridge.function(CanvasRenderingContext2D.restore, .{ .noop = true });
@@ -238,8 +258,8 @@ pub const JsApi = struct {
pub const setTransform = bridge.function(CanvasRenderingContext2D.setTransform, .{ .noop = true });
pub const resetTransform = bridge.function(CanvasRenderingContext2D.resetTransform, .{ .noop = true });
pub const clearRect = bridge.function(CanvasRenderingContext2D.clearRect, .{ .noop = true });
- pub const fillRect = bridge.function(CanvasRenderingContext2D.fillRect, .{ .noop = true });
- pub const strokeRect = bridge.function(CanvasRenderingContext2D.strokeRect, .{ .noop = true });
+ pub const fillRect = bridge.function(CanvasRenderingContext2D.fillRect, .{});
+ pub const strokeRect = bridge.function(CanvasRenderingContext2D.strokeRect, .{});
pub const beginPath = bridge.function(CanvasRenderingContext2D.beginPath, .{ .noop = true });
pub const closePath = bridge.function(CanvasRenderingContext2D.closePath, .{ .noop = true });
pub const moveTo = bridge.function(CanvasRenderingContext2D.moveTo, .{ .noop = true });
@@ -249,11 +269,11 @@ pub const JsApi = struct {
pub const arc = bridge.function(CanvasRenderingContext2D.arc, .{ .noop = true });
pub const arcTo = bridge.function(CanvasRenderingContext2D.arcTo, .{ .noop = true });
pub const rect = bridge.function(CanvasRenderingContext2D.rect, .{ .noop = true });
- pub const fill = bridge.function(CanvasRenderingContext2D.fill, .{ .noop = true });
- pub const stroke = bridge.function(CanvasRenderingContext2D.stroke, .{ .noop = true });
+ pub const fill = bridge.function(CanvasRenderingContext2D.fill, .{});
+ pub const stroke = bridge.function(CanvasRenderingContext2D.stroke, .{});
pub const clip = bridge.function(CanvasRenderingContext2D.clip, .{ .noop = true });
- pub const fillText = bridge.function(CanvasRenderingContext2D.fillText, .{ .noop = true });
- pub const strokeText = bridge.function(CanvasRenderingContext2D.strokeText, .{ .noop = true });
+ pub const fillText = bridge.function(CanvasRenderingContext2D.fillText, .{});
+ pub const strokeText = bridge.function(CanvasRenderingContext2D.strokeText, .{});
};
const testing = @import("../../../testing.zig");
diff --git a/src/browser/webapi/canvas/OffscreenCanvas.zig b/src/browser/webapi/canvas/OffscreenCanvas.zig
index d5eb948e9..04f24cbab 100644
--- a/src/browser/webapi/canvas/OffscreenCanvas.zig
+++ b/src/browser/webapi/canvas/OffscreenCanvas.zig
@@ -20,6 +20,7 @@ const std = @import("std");
const js = @import("../../js/js.zig");
const Blob = @import("../Blob.zig");
+const Canvas = @import("../element/html/Canvas.zig");
const OffscreenCanvasRenderingContext2D = @import("OffscreenCanvasRenderingContext2D.zig");
const Execution = js.Execution;
@@ -75,6 +76,9 @@ fn getContext(self: *OffscreenCanvas, context_type: []const u8, exec: *Execution
return self._cached;
}
+ if (Canvas.isWebGL(context_type)) {
+ exec.page.status.noteUnsupported(.webgl);
+ }
return null;
}
diff --git a/src/browser/webapi/canvas/OffscreenCanvasRenderingContext2D.zig b/src/browser/webapi/canvas/OffscreenCanvasRenderingContext2D.zig
index 9fb10ebfe..a7168b6f1 100644
--- a/src/browser/webapi/canvas/OffscreenCanvasRenderingContext2D.zig
+++ b/src/browser/webapi/canvas/OffscreenCanvasRenderingContext2D.zig
@@ -82,7 +82,9 @@ fn createImageData(
}
}
-fn putImageData(_: *const OffscreenCanvasRenderingContext2D, _: *ImageData, _: f64, _: f64, _: ?f64, _: ?f64, _: ?f64, _: ?f64) void {}
+fn putImageData(_: *const OffscreenCanvasRenderingContext2D, _: *ImageData, _: f64, _: f64, _: ?f64, _: ?f64, _: ?f64, _: ?f64, exec: *const Execution) void {
+ painted(exec);
+}
fn getImageData(
_: *const OffscreenCanvasRenderingContext2D,
@@ -157,8 +159,12 @@ pub fn transform(_: *OffscreenCanvasRenderingContext2D, _: f64, _: f64, _: f64,
fn setTransform(_: *OffscreenCanvasRenderingContext2D, _: f64, _: f64, _: f64, _: f64, _: f64, _: f64) void {}
fn resetTransform(_: *OffscreenCanvasRenderingContext2D) void {}
fn clearRect(_: *OffscreenCanvasRenderingContext2D, _: f64, _: f64, _: f64, _: f64) void {}
-fn fillRect(_: *OffscreenCanvasRenderingContext2D, _: f64, _: f64, _: f64, _: f64) void {}
-fn strokeRect(_: *OffscreenCanvasRenderingContext2D, _: f64, _: f64, _: f64, _: f64) void {}
+fn fillRect(_: *OffscreenCanvasRenderingContext2D, _: f64, _: f64, _: f64, _: f64, exec: *const Execution) void {
+ painted(exec);
+}
+fn strokeRect(_: *OffscreenCanvasRenderingContext2D, _: f64, _: f64, _: f64, _: f64, exec: *const Execution) void {
+ painted(exec);
+}
fn beginPath(_: *OffscreenCanvasRenderingContext2D) void {}
fn closePath(_: *OffscreenCanvasRenderingContext2D) void {}
fn moveTo(_: *OffscreenCanvasRenderingContext2D, _: f64, _: f64) void {}
@@ -168,11 +174,23 @@ fn bezierCurveTo(_: *OffscreenCanvasRenderingContext2D, _: f64, _: f64, _: f64,
pub fn arc(_: *OffscreenCanvasRenderingContext2D, _: f64, _: f64, _: f64, _: f64, _: f64, _: ?bool) void {}
fn arcTo(_: *OffscreenCanvasRenderingContext2D, _: f64, _: f64, _: f64, _: f64, _: f64) void {}
pub fn rect(_: *OffscreenCanvasRenderingContext2D, _: f64, _: f64, _: f64, _: f64) void {}
-pub fn fill(_: *OffscreenCanvasRenderingContext2D) void {}
-pub fn stroke(_: *OffscreenCanvasRenderingContext2D) void {}
+pub fn fill(_: *OffscreenCanvasRenderingContext2D, exec: *const Execution) void {
+ painted(exec);
+}
+pub fn stroke(_: *OffscreenCanvasRenderingContext2D, exec: *const Execution) void {
+ painted(exec);
+}
pub fn clip(_: *OffscreenCanvasRenderingContext2D) void {}
-fn fillText(_: *OffscreenCanvasRenderingContext2D, _: []const u8, _: f64, _: f64, _: ?f64) void {}
-fn strokeText(_: *OffscreenCanvasRenderingContext2D, _: []const u8, _: f64, _: f64, _: ?f64) void {}
+fn fillText(_: *OffscreenCanvasRenderingContext2D, _: []const u8, _: f64, _: f64, _: ?f64, exec: *const Execution) void {
+ painted(exec);
+}
+fn strokeText(_: *OffscreenCanvasRenderingContext2D, _: []const u8, _: f64, _: f64, _: ?f64, exec: *const Execution) void {
+ painted(exec);
+}
+
+fn painted(exec: *const Execution) void {
+ exec.page.status.noteUnsupported(.canvas2d);
+}
pub const JsApi = struct {
pub const bridge = js.Bridge(OffscreenCanvasRenderingContext2D);
@@ -221,7 +239,7 @@ pub const JsApi = struct {
pub const fillStyle = bridge.accessor(OffscreenCanvasRenderingContext2D.getFillStyle, OffscreenCanvasRenderingContext2D.setFillStyle, .{});
pub const createImageData = bridge.function(OffscreenCanvasRenderingContext2D.createImageData, .{});
- pub const putImageData = bridge.function(OffscreenCanvasRenderingContext2D.putImageData, .{ .noop = true });
+ pub const putImageData = bridge.function(OffscreenCanvasRenderingContext2D.putImageData, .{});
pub const getImageData = bridge.function(OffscreenCanvasRenderingContext2D.getImageData, .{});
pub const save = bridge.function(OffscreenCanvasRenderingContext2D.save, .{ .noop = true });
pub const restore = bridge.function(OffscreenCanvasRenderingContext2D.restore, .{ .noop = true });
@@ -232,8 +250,8 @@ pub const JsApi = struct {
pub const setTransform = bridge.function(OffscreenCanvasRenderingContext2D.setTransform, .{ .noop = true });
pub const resetTransform = bridge.function(OffscreenCanvasRenderingContext2D.resetTransform, .{ .noop = true });
pub const clearRect = bridge.function(OffscreenCanvasRenderingContext2D.clearRect, .{ .noop = true });
- pub const fillRect = bridge.function(OffscreenCanvasRenderingContext2D.fillRect, .{ .noop = true });
- pub const strokeRect = bridge.function(OffscreenCanvasRenderingContext2D.strokeRect, .{ .noop = true });
+ pub const fillRect = bridge.function(OffscreenCanvasRenderingContext2D.fillRect, .{});
+ pub const strokeRect = bridge.function(OffscreenCanvasRenderingContext2D.strokeRect, .{});
pub const beginPath = bridge.function(OffscreenCanvasRenderingContext2D.beginPath, .{ .noop = true });
pub const closePath = bridge.function(OffscreenCanvasRenderingContext2D.closePath, .{ .noop = true });
pub const moveTo = bridge.function(OffscreenCanvasRenderingContext2D.moveTo, .{ .noop = true });
@@ -243,9 +261,9 @@ pub const JsApi = struct {
pub const arc = bridge.function(OffscreenCanvasRenderingContext2D.arc, .{ .noop = true });
pub const arcTo = bridge.function(OffscreenCanvasRenderingContext2D.arcTo, .{ .noop = true });
pub const rect = bridge.function(OffscreenCanvasRenderingContext2D.rect, .{ .noop = true });
- pub const fill = bridge.function(OffscreenCanvasRenderingContext2D.fill, .{ .noop = true });
- pub const stroke = bridge.function(OffscreenCanvasRenderingContext2D.stroke, .{ .noop = true });
+ pub const fill = bridge.function(OffscreenCanvasRenderingContext2D.fill, .{});
+ pub const stroke = bridge.function(OffscreenCanvasRenderingContext2D.stroke, .{});
pub const clip = bridge.function(OffscreenCanvasRenderingContext2D.clip, .{ .noop = true });
- pub const fillText = bridge.function(OffscreenCanvasRenderingContext2D.fillText, .{ .noop = true });
- pub const strokeText = bridge.function(OffscreenCanvasRenderingContext2D.strokeText, .{ .noop = true });
+ pub const fillText = bridge.function(OffscreenCanvasRenderingContext2D.fillText, .{});
+ pub const strokeText = bridge.function(OffscreenCanvasRenderingContext2D.strokeText, .{});
};
diff --git a/src/browser/webapi/element/html/Canvas.zig b/src/browser/webapi/element/html/Canvas.zig
index fa644c761..206878bd6 100644
--- a/src/browser/webapi/element/html/Canvas.zig
+++ b/src/browser/webapi/element/html/Canvas.zig
@@ -94,8 +94,8 @@ fn getContext(self: *Canvas, context_type: []const u8, frame: *Frame) !?DrawingC
// catch the throw, reset, re-render, and loop forever.
// Spec-correct signal for "no WebGL" is null, so apps that check
// (Three.js does) can degrade gracefully.
- if (std.mem.eql(u8, context_type, "webgl") or std.mem.eql(u8, context_type, "experimental-webgl")) {
- return null;
+ if (isWebGL(context_type)) {
+ frame.page.status.noteUnsupported(.webgl);
}
return null;
};
@@ -103,6 +103,15 @@ fn getContext(self: *Canvas, context_type: []const u8, frame: *Frame) !?DrawingC
return drawing_context;
}
+pub fn isWebGL(context_type: []const u8) bool {
+ inline for (&.{ "webgl", "webgl2", "experimental-webgl" }) |needle| {
+ if (std.mem.eql(u8, context_type, needle)) {
+ return true;
+ }
+ }
+ return false;
+}
+
fn hasBitmap(self: *const Canvas) bool {
return BlankPNG.hasBitmap(self.getWidth(), self.getHeight());
}
diff --git a/src/browser/webapi/element/html/Image.zig b/src/browser/webapi/element/html/Image.zig
index 9733528f3..b3f1d4007 100644
--- a/src/browser/webapi/element/html/Image.zig
+++ b/src/browser/webapi/element/html/Image.zig
@@ -147,6 +147,7 @@ fn imageAddedCallback(self: *Image, frame: *Frame) !void {
// If image loading not desired, we just do fake "load" event.
if (frame._session.load_resources.image == false) {
+ frame.page.status.noteSkipped(.image);
return frame.queueImageEvent(self, .load);
}
diff --git a/src/lightpanda.zig b/src/lightpanda.zig
index d27173354..6405b7aab 100644
--- a/src/lightpanda.zig
+++ b/src/lightpanda.zig
@@ -549,6 +549,8 @@ fn writeJsonEnvelope(writer: *std.Io.Writer, frame: ?*Frame, dump_mode: ?Config.
.dump = if (dump_mode) |mode| @tagName(mode) else "",
.content = content,
.@"error" = if (err) |e| @errorName(e) else null,
+ .bot_challenge = if (frame) |f| f._bot_challenge else null,
+ .page_status = if (frame) |f| &f.page.status else null,
}, .{}, writer);
}
@@ -679,6 +681,27 @@ test "writeJsonEnvelope: null frame" {
.content = "",
}, aw.written());
try testing.expect(std.mem.find(u8, aw.written(), "\"error\":null") != null);
+ try testing.expect(std.mem.find(u8, aw.written(), "\"page_status\":null") != null);
+}
+
+test "writeJsonEnvelope: page status" {
+ var page = try testing.pageTest("page_js_error.html", .{});
+ defer page.close();
+
+ var aw: std.Io.Writer.Allocating = .init(testing.allocator);
+ defer aw.deinit();
+
+ try writeJsonEnvelope(&aw.writer, page.frame().?, null, "", null);
+ try testing.expectJson(.{
+ .http_status = 200,
+ .page_status = .{
+ .js_errors = 2,
+ .unsupported = .{ .webgl = 0, .canvas2d = 0 },
+ .skipped = .{ .iframe = 0, .worker = 0, .image = 0, .stylesheet = 0 },
+ .missing_globals = &[_][]const u8{},
+ },
+ }, aw.written());
+ try testing.expect(std.mem.find(u8, aw.written(), "\"bot_challenge\":null") != null);
}
test "writeJsonEnvelope: page error" {
diff --git a/src/log.zig b/src/log.zig
index 72662e6a1..8da4363f2 100644
--- a/src/log.zig
+++ b/src/log.zig
@@ -226,20 +226,6 @@ pub fn note(scope: Scope, comptime msg: []const u8, data: anytype) void {
}
}
-var warned_disabled_worker = std.atomic.Value(bool).init(false);
-pub fn warnDisabledWorker() void {
- if (warned_disabled_worker.swap(true, .monotonic) == false) {
- warn(.disabled, "workers disabled", .{ .hint = "enable via --load-resources worker" });
- }
-}
-
-var warned_disabled_iframe = std.atomic.Value(bool).init(false);
-pub fn warnDisabledIFrame() void {
- if (warned_disabled_iframe.swap(true, .monotonic) == false) {
- warn(.disabled, "iframes disabled", .{ .hint = "enable via --load-resources iframe" });
- }
-}
-
pub fn log(scope: Scope, level: Level, msg: []const u8, data: anytype) void {
var kvs: [@typeInfo(@TypeOf(data)).@"struct".field_names.len]KV = undefined;
initKVs(data, &kvs);
diff --git a/src/server/cdp/domains/lp.zig b/src/server/cdp/domains/lp.zig
index ea5988985..ab8d24f9d 100644
--- a/src/server/cdp/domains/lp.zig
+++ b/src/server/cdp/domains/lp.zig
@@ -40,6 +40,7 @@ pub fn processMessage(cmd: *CDP.Command) !void {
getNodeDetails,
getStructuredData,
getContentSignal,
+ getPageStatus,
detectForms,
clickNode,
fillNode,
@@ -59,6 +60,7 @@ pub fn processMessage(cmd: *CDP.Command) !void {
.getNodeDetails => return getNodeDetails(cmd),
.getStructuredData => return getStructuredData(cmd),
.getContentSignal => return getContentSignal(cmd),
+ .getPageStatus => return getPageStatus(cmd),
.detectForms => return detectForms(cmd),
.clickNode => return clickNode(cmd),
.fillNode => return fillNode(cmd),
@@ -313,6 +315,23 @@ fn getContentSignal(cmd: anytype) !void {
}, .{});
}
+fn getPageStatus(cmd: anytype) !void {
+ const bc = cmd.browser_context orelse return error.NoBrowserContext;
+ const frame = bc.mainFrame() orelse return error.FrameNotLoaded;
+ const status = &frame.page.status;
+
+ return cmd.sendResult(.{
+ .url = frame.url,
+ .httpStatus = frame._http_status,
+ .botChallenge = frame._bot_challenge,
+ .navigateError = if (frame._last_navigate_error) |err| @errorName(err) else null,
+ .jsErrors = status.js_errors,
+ .unsupported = status.unsupported,
+ .skipped = status.skipped,
+ .missingGlobals = status.missing_globals,
+ }, .{});
+}
+
fn detectForms(cmd: anytype) !void {
const bc = cmd.browser_context orelse return error.NoBrowserContext;
const frame = bc.mainFrame() orelse return error.FrameNotLoaded;
@@ -738,6 +757,56 @@ test "cdp.lp: getContentSignal" {
try testing.expect(result.get("contentSignals") != null);
}
+test "cdp.lp: getPageStatus" {
+ var ctx = try testing.context();
+ defer ctx.deinit();
+
+ const bc = try ctx.loadBrowserContext(.{});
+ const page = try bc.session.createPage();
+ bc.session.load_resources = .{};
+ // The iframe and worker skips warn; image and stylesheet are debug.
+ testing.expectLog(&.{ .disabled, .disabled });
+
+ const url = "http://localhost:9582/src/browser/tests/cdp/page_status.html";
+ try page.navigate(url, .{ .reason = .address_bar, .kind = .{ .push = null } });
+ try testing.waitForPage(bc);
+
+ try ctx.processMessage(.{ .id = 1, .method = "LP.getPageStatus" });
+ var result = (try dumpReply(&ctx, 1)).get("result").?.object;
+ try testing.expectEqual(url, result.get("url").?.string);
+ try testing.expectEqual(200, result.get("httpStatus").?.integer);
+ try testing.expectEqual(null, result.get("botChallenge"));
+ try testing.expectEqual(null, result.get("navigateError"));
+ try testing.expectEqual(1, result.get("jsErrors").?.integer);
+
+ // Two webgl probes, three paint calls; the 2d context itself and its
+ // path setup don't count.
+ var unsupported = result.get("unsupported").?.object;
+ try testing.expectEqual(2, unsupported.get("webgl").?.integer);
+ try testing.expectEqual(3, unsupported.get("canvas2d").?.integer);
+
+ try testing.expectEqual(0, result.get("missingGlobals").?.array.items.len);
+
+ var skipped = result.get("skipped").?.object;
+ try testing.expectEqual(1, skipped.get("iframe").?.integer);
+ try testing.expectEqual(1, skipped.get("worker").?.integer);
+ try testing.expectEqual(1, skipped.get("image").?.integer);
+ try testing.expectEqual(1, skipped.get("stylesheet").?.integer);
+
+ // A new top-level navigation starts over.
+ try bc.session.initiateRootNavigation(page.frame_id, "http://localhost:9582/src/browser/tests/cdp/dialog.html", .{ .reason = .address_bar, .kind = .{ .push = null } });
+ try testing.waitForPage(bc);
+
+ try ctx.processMessage(.{ .id = 2, .method = "LP.getPageStatus" });
+ result = (try dumpReply(&ctx, 2)).get("result").?.object;
+ try testing.expectEqual(0, result.get("jsErrors").?.integer);
+ unsupported = result.get("unsupported").?.object;
+ try testing.expectEqual(0, unsupported.get("webgl").?.integer);
+ try testing.expectEqual(0, unsupported.get("canvas2d").?.integer);
+ skipped = result.get("skipped").?.object;
+ try testing.expectEqual(0, skipped.get("iframe").?.integer);
+}
+
test "cdp.lp: action tools" {
var ctx = try testing.context();
defer ctx.deinit();