diff --git a/build.zig b/build.zig
index e7527cff..28e76aa1 100644
--- a/build.zig
+++ b/build.zig
@@ -104,10 +104,10 @@ pub fn build(b: *Build) !void {
     });
     check.dependOn(&check_lib.step);
 
-    // Extras (snapshot_creator, legacy_test) are off the default install to
+    // Extras (snapshot_creator) are off the default install to
     // avoid paying for three exe compiles on every edit. Build explicitly
     // with `zig build extras`.
-    const extras_step = b.step("extras", "Build snapshot_creator and legacy_test");
+    const extras_step = b.step("extras", "Build snapshot_creator");
 
     {
         // browser
@@ -187,38 +187,6 @@ pub fn build(b: *Build) !void {
         const test_step = b.step("test", "Run unit tests");
         test_step.dependOn(&run_tests.step);
     }
-
-    {
-        // browser
-        const exe = b.addExecutable(.{
-            .name = "legacy_test",
-            .use_llvm = true,
-            .root_module = b.createModule(.{
-                .root_source_file = b.path("src/main_legacy_test.zig"),
-                .target = target,
-                .optimize = optimize,
-                .sanitize_c = enable_csan,
-                .sanitize_thread = enable_tsan,
-                .imports = &.{
-                    .{ .name = "lightpanda", .module = lightpanda_module },
-                },
-            }),
-        });
-        extras_step.dependOn(&b.addInstallArtifact(exe, .{}).step);
-
-        const exe_check = b.addLibrary(.{
-            .name = "legacy_test_check",
-            .root_module = exe.root_module,
-        });
-        check.dependOn(&exe_check.step);
-
-        const run_cmd = b.addRunArtifact(exe);
-        if (b.args) |args| {
-            run_cmd.addArgs(args);
-        }
-        const run_step = b.step("legacy_test", "Run the app");
-        run_step.dependOn(&run_cmd.step);
-    }
 }
 
 fn linkV8(
diff --git a/src/TestHTTPServer.zig b/src/TestHTTPServer.zig
index a6d157c2..2fed8d63 100644
--- a/src/TestHTTPServer.zig
+++ b/src/TestHTTPServer.zig
@@ -90,8 +90,13 @@ fn handleConnection(self: *TestHTTPServer, conn: std.net.Server.Connection) !voi
         };
 
         self.handler(&req) catch |err| {
-            std.debug.print("test http error '{s}': {}\n", .{ req.head.target, err });
-            try req.respond("server error", .{ .status = .internal_server_error });
+            switch (err) {
+                error.BrokenPipe => {},
+                else => {
+                    std.debug.print("test http error '{s}': {}\n", .{ req.head.target, err });
+                    try req.respond("server error", .{ .status = .internal_server_error });
+                },
+            }
             return;
         };
     }
diff --git a/src/browser/Factory.zig b/src/browser/Factory.zig
index 9288cc4f..248ededa 100644
--- a/src/browser/Factory.zig
+++ b/src/browser/Factory.zig
@@ -282,7 +282,13 @@ pub fn abstractRange(_: *const Factory, arena: Allocator, child: anytype, frame:
         ._type = unionInit(AbstractRange.Type, chain.get(1)),
     };
     chain.setLeaf(1, child);
-    frame._live_ranges.append(&abstract_range._range_link);
+
+    if (abstract_range._type != .static_range) {
+        // StaticRanges are not live, so they don't get added to the frame's
+        // live_ranges list.
+        frame._live_ranges.append(&abstract_range._range_link);
+    }
+
     return chain.get(1);
 }
 
diff --git a/src/browser/Frame.zig b/src/browser/Frame.zig
index 024093ca..50251fa8 100644
--- a/src/browser/Frame.zig
+++ b/src/browser/Frame.zig
@@ -307,6 +307,7 @@ pub fn init(self: *Frame, frame_id: u32, page: *Page, parent: ?*Frame) !void {
         ._event_manager = EventManager.init(arena, self),
     };
     self._to_load = &self._to_load_1;
+    self._http_owner.blob_urls = &self._blob_urls;
 
     var screen: *Screen = undefined;
     var visual_viewport: *VisualViewport = undefined;
@@ -520,11 +521,6 @@ pub fn isSameOrigin(self: *const Frame, url: [:0]const u8) bool {
     return std.mem.eql(u8, URL.getHost(url), URL.getHost(current_origin));
 }
 
-/// Look up a blob URL in this frame's registry.
-pub fn lookupBlobUrl(self: *Frame, url: []const u8) ?*Blob {
-    return self._blob_urls.get(url);
-}
-
 pub fn navigate(self: *Frame, request_url: [:0]const u8, opts: NavigateOpts) !void {
     lp.assert(self._load_state == .waiting, "frame.renavigate", .{});
     const session = self._session;
@@ -585,7 +581,7 @@ pub fn navigate(self: *Frame, request_url: [:0]const u8, opts: NavigateOpts) !vo
             };
             const parse_arena = try self.getArena(.medium, "Frame.parseBlob");
             defer self.releaseArena(parse_arena);
-            var parser = Parser.init(parse_arena, self.document.asNode(), self);
+            var parser = Parser.init(parse_arena, self.document.asNode(), self, .{ .allow_declarative_shadow = true });
             parser.parse(blob._slice);
         } else {
             self.document.injectBlank(self) catch |err| {
@@ -1196,7 +1192,7 @@ fn frameDoneCallback(ctx: *anyopaque) !void {
     const parse_arena = try self.getArena(.medium, "Frame.parse");
     defer self.releaseArena(parse_arena);
 
-    var parser = Parser.init(parse_arena, self.document.asNode(), self);
+    var parser = Parser.init(parse_arena, self.document.asNode(), self, .{ .allow_declarative_shadow = true });
 
     switch (self._parse_state) {
         .html => |*html| {
@@ -3264,7 +3260,9 @@ pub fn _insertNodeRelative(self: *Frame, comptime from_parser: bool, parent: *No
     if (should_notify) {
         if (comptime from_parser == false) {
             // When the parser adds the node, nodeIsReady is only called when the
-            // nodeComplete() callback is executed.
+            // nodeComplete() callback is executed. nodeIsReady resolves the
+            // node's owning frame itself (only for the few node types that have
+            // ready work), so pass the incumbent `self`.
             try self.nodeIsReady(false, child);
 
             // Check if text was added to a script that hasn't started yet.
@@ -3573,11 +3571,20 @@ pub fn updateRangesForNodeRemoval(self: *Frame, parent: *Node, child: *Node, chi
 
 // TODO: optimize and cleanup, this is called a lot (e.g., innerHTML = '')
 pub fn parseHtmlAsChildren(self: *Frame, node: *Node, html: []const u8) !void {
+    return self.parseHtmlAsChildrenInner(node, html, false);
+}
+
+// setHTMLUnsafe variant: parse a fragment that may contain declarative shadow node
+pub fn parseHtmlUnsafeAsChildren(self: *Frame, node: *Node, html: []const u8) !void {
+    return self.parseHtmlAsChildrenInner(node, html, true);
+}
+
+fn parseHtmlAsChildrenInner(self: *Frame, node: *Node, html: []const u8, allow_declarative_shadow: bool) !void {
     const previous_parse_mode = self._parse_mode;
     self._parse_mode = .fragment;
     defer self._parse_mode = previous_parse_mode;
 
-    var parser = Parser.init(self.call_arena, node, self);
+    var parser = Parser.init(self.call_arena, node, self, .{ .allow_declarative_shadow = allow_declarative_shadow });
     parser.parseFragment(html);
 
     // html5ever wraps fragment output in an <html> element; unwrap so its
@@ -3615,6 +3622,15 @@ fn nodeIsReady(self: *Frame, comptime from_parser: bool, node: *Node) !void {
         // we don't execute scripts added via innerHTML = '<script...';
         return;
     }
+    // A node's "ready" work (running a <script>, loading an <iframe> / <link> /
+    // <style>) must happen in the frame that owns the node's document — not
+    // necessarily `self`. When an async callback (e.g. a postMessage listener)
+    // running in frame A appends a node to frame B's document, `self` is the
+    // incumbent frame A, but the script's base URL and execution realm must come
+    // from B (its node document). Resolving that owner frame is a parent-chain
+    // walk, so we only do it once we've matched a node type that has ready work
+    // (the common text/element insertion does nothing here). The parser inserts
+    // into its own document, so from_parser always uses `self`.
     if (node.is(Element.Html.Script)) |script| {
         if ((comptime from_parser == false) and script._src.len == 0) {
             // Script was added via JavaScript without a src attribute.
@@ -3625,23 +3641,27 @@ fn nodeIsReady(self: *Frame, comptime from_parser: bool, node: *Node) !void {
             }
         }
 
-        self.scriptAddedCallback(from_parser, script) catch |err| {
-            log.err(.frame, "frame.nodeIsReady", .{ .err = err, .element = "script", .type = self._type, .url = self.url });
+        const frame = if (comptime from_parser) self else node.ownerFrame(self);
+        frame.scriptAddedCallback(from_parser, script) catch |err| {
+            log.err(.frame, "frame.nodeIsReady", .{ .err = err, .element = "script", .type = frame._type, .url = frame.url });
             return err;
         };
     } else if (node.is(IFrame)) |iframe| {
-        self.iframeAddedCallback(iframe) catch |err| {
-            log.err(.frame, "frame.nodeIsReady", .{ .err = err, .element = "iframe", .type = self._type, .url = self.url });
+        const frame = if (comptime from_parser) self else node.ownerFrame(self);
+        frame.iframeAddedCallback(iframe) catch |err| {
+            log.err(.frame, "frame.nodeIsReady", .{ .err = err, .element = "iframe", .type = frame._type, .url = frame.url });
             return err;
         };
     } else if (node.is(Element.Html.Link)) |link| {
-        link.linkAddedCallback(self) catch |err| {
-            log.err(.frame, "frame.nodeIsReady", .{ .err = err, .element = "link", .type = self._type });
+        const frame = if (comptime from_parser) self else node.ownerFrame(self);
+        link.linkAddedCallback(frame) catch |err| {
+            log.err(.frame, "frame.nodeIsReady", .{ .err = err, .element = "link", .type = frame._type });
             return error.LinkLoadError;
         };
     } else if (node.is(Element.Html.Style)) |style| {
-        style.styleAddedCallback(self) catch |err| {
-            log.err(.frame, "frame.nodeIsReady", .{ .err = err, .element = "style", .type = self._type });
+        const frame = if (comptime from_parser) self else node.ownerFrame(self);
+        style.styleAddedCallback(frame) catch |err| {
+            log.err(.frame, "frame.nodeIsReady", .{ .err = err, .element = "style", .type = frame._type });
             return error.StyleLoadError;
         };
     }
@@ -4310,5 +4330,16 @@ test "Frame: httpMetadata 404" {
     defer testing.test_session.removePage();
     const meta = frame.httpMetadata();
     try testing.expect(meta.status != null);
-    try std.testing.expectEqual(@as(u16, 404), meta.status.?);
+    try testing.expectEqual(404, meta.status.?);
+}
+
+test "Frame: 401" {
+    var frame = try testing.pageTest("401", .{});
+    defer testing.reset();
+    defer frame._session.removePage();
+
+    var buf = std.Io.Writer.Allocating.init(testing.allocator);
+    defer buf.deinit();
+    try @import("dump.zig").root(frame.document, .{}, &buf.writer, frame);
+    try testing.expectEqual("<!DOCTYPE html><html><head><meta charset=\"utf-8\"></head><body><pre>No</pre></body></html>", buf.written());
 }
diff --git a/src/browser/HttpClient.zig b/src/browser/HttpClient.zig
index d73a37a4..a45b6b6c 100644
--- a/src/browser/HttpClient.zig
+++ b/src/browser/HttpClient.zig
@@ -567,6 +567,21 @@ fn requestT(self: *Client, req: Request, owner: ?*Owner) !*Transfer {
     // via transfer.abort which fires error_callback and deinits. `.created`
     // means no commit happened — anything else is held by an owner that
     // will clean up.
+
+    // Synthetic schemes never touch the network or the layer chain — they skip
+    // robots/cache/interception and deliver on the next tick
+    if (Synthetic.isSynthetic(req.url)) {
+        // The 2nd transfer is the callback context. We don't actually use it,
+        // we're just sticking transfer in there to have something.
+        self.runNextTick(transfer, transfer, .{ .run = Synthetic.run }) catch |err| {
+            if (transfer.state == .created) {
+                transfer.abort(err);
+            }
+            return err;
+        };
+        return transfer;
+    }
+
     self.entry_layer.request(transfer) catch |err| {
         if (transfer.state == .created) {
             transfer.abort(err);
@@ -577,6 +592,80 @@ fn requestT(self: *Client, req: Request, owner: ?*Owner) !*Transfer {
     return transfer;
 }
 
+// Non-network URL schemes whose response is synthesized in-process rather than
+// fetched, think blob data URLs.
+const Synthetic = struct {
+    const data_url = @import("data_url.zig");
+
+    fn isSynthetic(url: []const u8) bool {
+        return std.mem.startsWith(u8, url, "data:") or std.mem.startsWith(u8, url, "blob:");
+    }
+
+    fn run(transfer: *Transfer, _: *anyopaque) void {
+        defer transfer.deinit();
+
+        const fulfilled = build(transfer) catch |err| {
+            transfer.req.error_callback(transfer.req.ctx, err);
+            return;
+        };
+        deliver(&transfer.req, &fulfilled) catch |err| {
+            transfer.req.error_callback(transfer.req.ctx, err);
+        };
+    }
+
+    fn build(transfer: *Transfer) !FulfilledResponse {
+        const arena = transfer.arena;
+        const url = transfer.req.url;
+
+        var body: []const u8 = "";
+        var content_type: []const u8 = "";
+
+        if (std.mem.startsWith(u8, url, "data:")) {
+            const parsed = try data_url.parse(arena, url);
+            content_type = parsed.content_type;
+            body = parsed.body;
+        } else {
+            // blob: — resolved against the owning frame's registry.
+            const owner = transfer.owner orelse return error.BlobNotFound;
+            const blob_urls = owner.blob_urls orelse return error.BlobNotFound;
+            const blob = blob_urls.get(url) orelse return error.BlobNotFound;
+            content_type = blob._mime;
+            body = blob._slice;
+        }
+
+        // A blob with no type yields no Content-Type header.
+        const headers = if (content_type.len > 0) blk: {
+            const h = try arena.alloc(http.Header, 1);
+            h[0] = .{ .name = "content-type", .value = content_type };
+            break :blk h;
+        } else &[_]http.Header{};
+
+        return .{
+            .url = url,
+            .body = body,
+            .status = 200,
+            .headers = headers,
+        };
+    }
+
+    fn deliver(req: *Request, fulfilled: *const FulfilledResponse) !void {
+        const response = Response.fromFulfilled(req.ctx, fulfilled);
+        if (req.start_callback) |cb| {
+            try cb(response);
+        }
+        const proceed = try req.header_callback(response);
+        if (!proceed) {
+            return error.Abort;
+        }
+        if (fulfilled.body) |b| {
+            if (b.len > 0) {
+                try req.data_callback(response, b);
+            }
+        }
+        try req.done_callback(req.ctx);
+    }
+};
+
 const SyncContext = struct {
     allocator: Allocator,
     completion: union(enum) {
@@ -1782,7 +1871,7 @@ pub const Transfer = struct {
                 log.err(.http, "getResponseCode", .{ .err = err, .source = "body callback" });
                 return http.writefunc_error;
             };
-            if ((status >= 300 and status <= 399) or status == 401 or status == 407) {
+            if (status >= 300 and status <= 399) {
                 res.skip_body = true;
                 return @intCast(chunk_len);
             }
@@ -1909,7 +1998,11 @@ pub const Owner = struct {
     transfers: std.DoublyLinkedList = .{},
     websockets: std.DoublyLinkedList = .{},
 
+    // The owning Frame's / WorkerGlobalScope's blob: registry,
+    blob_urls: ?*const std.StringHashMapUnmanaged(*Blob) = null,
+
     const WebSocket = @import("webapi/net/WebSocket.zig");
+    const Blob = @import("webapi/Blob.zig");
 
     pub fn addTransfer(self: *Owner, t: *Transfer) void {
         self.transfers.append(&t.owner_node);
diff --git a/src/browser/ScriptManager.zig b/src/browser/ScriptManager.zig
index 445b41f6..e6b153d4 100644
--- a/src/browser/ScriptManager.zig
+++ b/src/browser/ScriptManager.zig
@@ -141,12 +141,11 @@ pub fn addFromElement(self: *ScriptManager, comptime from_parser: bool, script_e
     var remote_url: ?[:0]const u8 = null;
     const base_url = frame.base();
     if (element.getAttributeSafe(comptime .wrap("src"))) |src| {
-        if (try parseDataURI(arena, src)) |data_uri| {
-            source = .{ .@"inline" = data_uri };
-        } else {
-            remote_url = try URL.resolve(arena, base_url, src, .{ .encoding = frame.charset });
-            source = .{ .remote = .{} };
-        }
+        // data: and blob: srcs flow through the normal request path; HttpClient
+        // synthesizes the response. Execution mode (blocking vs async/defer) is
+        // attribute-driven, the same as any other src.
+        remote_url = try URL.resolve(arena, base_url, src, .{ .encoding = frame.charset });
+        source = .{ .remote = .{} };
     } else {
         var buf = std.Io.Writer.Allocating.init(arena);
         try element.asNode().getChildTextContent(&buf.writer);
@@ -339,65 +338,3 @@ pub fn parseImportmap(self: *ScriptManager, script: *const Script) !void {
 pub fn staticScriptsDone(self: *ScriptManager) void {
     self.base.staticScriptsDone();
 }
-
-// Parses data:[<media-type>][;base64],<data>
-fn parseDataURI(allocator: Allocator, src: []const u8) !?[]const u8 {
-    if (!std.mem.startsWith(u8, src, "data:")) {
-        return null;
-    }
-
-    const uri = src[5..];
-    const data_starts = std.mem.indexOfScalar(u8, uri, ',') orelse return null;
-    const data = uri[data_starts + 1 ..];
-
-    const unescaped = try URL.unescape(allocator, data);
-
-    const metadata = uri[0..data_starts];
-    if (std.mem.endsWith(u8, metadata, ";base64") == false) {
-        return unescaped;
-    }
-
-    // Forgiving base64 decode per WHATWG spec:
-    // https://infra.spec.whatwg.org/#forgiving-base64-decode
-    // Step 1: Remove all ASCII whitespace
-    var stripped = try std.ArrayList(u8).initCapacity(allocator, unescaped.len);
-    for (unescaped) |c| {
-        if (!std.ascii.isWhitespace(c)) {
-            stripped.appendAssumeCapacity(c);
-        }
-    }
-    const trimmed = std.mem.trimRight(u8, stripped.items, "=");
-
-    // Length % 4 == 1 is invalid
-    if (trimmed.len % 4 == 1) {
-        return error.InvalidCharacterError;
-    }
-
-    const decoded_size = std.base64.standard_no_pad.Decoder.calcSizeForSlice(trimmed) catch return error.InvalidCharacterError;
-    const buffer = try allocator.alloc(u8, decoded_size);
-    std.base64.standard_no_pad.Decoder.decode(buffer, trimmed) catch return error.InvalidCharacterError;
-    return buffer;
-}
-
-const testing = @import("../testing.zig");
-test "DataURI: parse valid" {
-    try assertValidDataURI("data:text/javascript; charset=utf-8;base64,Zm9v", "foo");
-    try assertValidDataURI("data:text/javascript; charset=utf-8;,foo", "foo");
-    try assertValidDataURI("data:,foo", "foo");
-}
-
-test "DataURI: parse invalid" {
-    try assertInvalidDataURI("atad:,foo");
-    try assertInvalidDataURI("data:foo");
-    try assertInvalidDataURI("data:");
-}
-
-fn assertValidDataURI(uri: []const u8, expected: []const u8) !void {
-    defer testing.reset();
-    const data_uri = try parseDataURI(testing.arena_allocator, uri) orelse return error.TestFailed;
-    try testing.expectEqual(expected, data_uri);
-}
-
-fn assertInvalidDataURI(uri: []const u8) !void {
-    try testing.expectEqual(null, parseDataURI(undefined, uri));
-}
diff --git a/src/browser/Session.zig b/src/browser/Session.zig
index 60eaed13..4b470b5b 100644
--- a/src/browser/Session.zig
+++ b/src/browser/Session.zig
@@ -161,6 +161,8 @@ pub fn deinit(self: *Session) void {
 
     self.cookie_jar.deinit();
 
+    self.browser.env.memoryPressureNotification(.critical);
+
     self.storage_shed.deinit(self.browser.app.allocator);
     self._console_messages.deinit();
     self.arena_pool.release(self.arena);
diff --git a/src/browser/data_url.zig b/src/browser/data_url.zig
new file mode 100644
index 00000000..4c39d1b1
--- /dev/null
+++ b/src/browser/data_url.zig
@@ -0,0 +1,202 @@
+// Copyright (C) 2023-2026  Lightpanda (Selecy SAS)
+//
+// 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/>.
+
+// "data: URL processor" — https://fetch.spec.whatwg.org/#data-url-processor.
+// The single home for data: parsing: the HttpClient synthetic-scheme path and
+// ScriptManager (<script src="data:...">) both go through here.
+
+const std = @import("std");
+const URL = @import("URL.zig");
+
+const Allocator = std.mem.Allocator;
+
+pub const Parsed = struct {
+    body: []const u8,
+    content_type: []const u8,
+};
+
+pub fn parse(arena: Allocator, url: []const u8) !Parsed {
+    if (std.mem.startsWith(u8, url, "data:") == false) {
+        return error.InvalidDataUrl;
+    }
+
+    const after = url["data:".len..];
+
+    const comma = std.mem.indexOfScalarPos(u8, after, 0, ',') orelse return error.InvalidDataUrl;
+    var meta = std.mem.trim(u8, after[0..comma], &std.ascii.whitespace);
+    const encoded_body = after[comma + 1 ..];
+
+    // A trailing ";" + optional spaces + "base64" selects base64 decoding.
+    const is_base64 = blk: {
+        if (meta.len < "base64".len) break :blk false;
+        const tail = meta[meta.len - "base64".len ..];
+        if (!std.ascii.eqlIgnoreCase(tail, "base64")) break :blk false;
+        const head = std.mem.trimRight(u8, meta[0 .. meta.len - "base64".len], " ");
+        if (head.len == 0 or head[head.len - 1] != ';') break :blk false;
+        meta = head[0 .. head.len - 1];
+        break :blk true;
+    };
+
+    var content_type: []const u8 = meta;
+    if (content_type.len == 0) {
+        content_type = "text/plain;charset=US-ASCII";
+    } else if (content_type[0] == ';') {
+        // e.g. "data:;charset=utf-8,x" -> "text/plain;charset=utf-8"
+        content_type = try std.fmt.allocPrint(arena, "text/plain{s}", .{content_type});
+    }
+
+    const body_text = try URL.unescape(arena, encoded_body);
+    const body = if (is_base64) try base64Decode(arena, body_text) else body_text;
+
+    return .{ .content_type = content_type, .body = body };
+}
+
+fn base64Decode(arena: Allocator, input: []const u8) ![]u8 {
+    // Forgiving-base64 decode — https://infra.spec.whatwg.org/#forgiving-base64-decode.
+    // std's decoders reject non-canonical trailing bits (e.g. "ab"), which
+    // forgiving-base64 tolerates, so decode by hand after validating padding.
+    const buf = try arena.alloc(u8, input.len);
+    var n: usize = 0;
+    for (input) |c| switch (c) {
+        ' ', '\t', '\n', '\r', std.ascii.control_code.ff => {},
+        else => {
+            buf[n] = c;
+            n += 1;
+        },
+    };
+    var src = buf[0..n];
+
+    // Only a multiple-of-4 length may carry (and shed) up to two "=" of padding.
+    if (src.len % 4 == 0) {
+        if (std.mem.endsWith(u8, src, "==")) {
+            src = src[0 .. src.len - 2];
+        } else if (std.mem.endsWith(u8, src, "=")) {
+            src = src[0 .. src.len - 1];
+        }
+    }
+    if (src.len % 4 == 1) return error.InvalidBase64;
+    // Any "=" still present is misplaced padding.
+    if (std.mem.indexOfScalar(u8, src, '=') != null) return error.InvalidBase64;
+
+    const out_len = src.len / 4 * 3 + switch (src.len % 4) {
+        0 => @as(usize, 0),
+        2 => 1,
+        3 => 2,
+        else => unreachable,
+    };
+    const out = try arena.alloc(u8, out_len);
+
+    var oi: usize = 0;
+    var i: usize = 0;
+    while (i + 4 <= src.len) : (i += 4) {
+        const a = try b64Val(src[i]);
+        const b = try b64Val(src[i + 1]);
+        const c = try b64Val(src[i + 2]);
+        const d = try b64Val(src[i + 3]);
+        out[oi] = (a << 2) | (b >> 4);
+        out[oi + 1] = (b << 4) | (c >> 2);
+        out[oi + 2] = (c << 6) | d;
+        oi += 3;
+    }
+    switch (src.len - i) {
+        0 => {},
+        2 => {
+            const a = try b64Val(src[i]);
+            const b = try b64Val(src[i + 1]);
+            out[oi] = (a << 2) | (b >> 4);
+        },
+        3 => {
+            const a = try b64Val(src[i]);
+            const b = try b64Val(src[i + 1]);
+            const c = try b64Val(src[i + 2]);
+            out[oi] = (a << 2) | (b >> 4);
+            out[oi + 1] = (b << 4) | (c >> 2);
+        },
+        else => unreachable,
+    }
+    return out;
+}
+
+fn b64Val(c: u8) !u8 {
+    return switch (c) {
+        'A'...'Z' => c - 'A',
+        'a'...'z' => c - 'a' + 26,
+        '0'...'9' => c - '0' + 52,
+        '+' => 62,
+        '/' => 63,
+        else => error.InvalidBase64,
+    };
+}
+
+const testing = @import("../testing.zig");
+test "data_url: plain text, default content-type" {
+    defer testing.reset();
+    const r = try parse(testing.arena_allocator, "data:,Hello%2C%20World");
+    try testing.expectString("text/plain;charset=US-ASCII", r.content_type);
+    try testing.expectString("Hello, World", r.body);
+}
+
+test "data_url: explicit mediatype" {
+    defer testing.reset();
+    const r = try parse(testing.arena_allocator, "data:text/html,<b>hi</b>");
+    try testing.expectString("text/html", r.content_type);
+    try testing.expectString("<b>hi</b>", r.body);
+}
+
+test "data_url: base64" {
+    defer testing.reset();
+    const r = try parse(testing.arena_allocator, "data:text/plain;base64,SGVsbG8=");
+    try testing.expectString("text/plain", r.content_type);
+    try testing.expectString("Hello", r.body);
+}
+
+test "data_url: base64 without padding decodes (forgiving)" {
+    defer testing.reset();
+    const r = try parse(testing.arena_allocator, "data:application/octet-stream;base64,SGVsbG8");
+    try testing.expectString("Hello", r.body);
+
+    // 2- and 3-char unpadded tails decode (non-canonical trailing bits are ok).
+    try testing.expectString("i", (try parse(testing.arena_allocator, "data:;base64,ab")).body);
+    try testing.expectString("a", (try parse(testing.arena_allocator, "data:;base64,YR")).body);
+
+    // ASCII whitespace inside the payload is ignored.
+    try testing.expectString("Hello", (try parse(testing.arena_allocator, "data:;base64,SGVs bG8=")).body);
+}
+
+test "data_url: forgiving-base64 rejects misplaced/over-padding" {
+    defer testing.reset();
+    const arena = testing.arena_allocator;
+    try std.testing.expectError(error.InvalidBase64, parse(arena, "data:;base64,abcd=")); // len % 4 == 1
+    try std.testing.expectError(error.InvalidBase64, parse(arena, "data:;base64,="));
+    try std.testing.expectError(error.InvalidBase64, parse(arena, "data:;base64,ab=c")); // interior "="
+    try std.testing.expectError(error.InvalidBase64, parse(arena, "data:;base64,==")); // no data
+}
+
+test "data_url: bare charset gets text/plain prefix" {
+    defer testing.reset();
+    const r = try parse(testing.arena_allocator, "data:;charset=utf-8,x");
+    try testing.expectString("text/plain;charset=utf-8", r.content_type);
+}
+
+test "data_url: empty body" {
+    defer testing.reset();
+    const r = try parse(testing.arena_allocator, "data:text/plain,");
+    try testing.expectString("", r.body);
+}
+
+test "data_url: missing comma is an error" {
+    defer testing.reset();
+    try std.testing.expectError(error.InvalidDataUrl, parse(testing.arena_allocator, "data:text/plain"));
+}
diff --git a/src/browser/js/Context.zig b/src/browser/js/Context.zig
index 26d12af1..d839faef 100644
--- a/src/browser/js/Context.zig
+++ b/src/browser/js/Context.zig
@@ -392,13 +392,27 @@ fn evaluateModule(self: *Context, comptime want_result: bool, mod: js.Module, ur
 
         // Some module-loading errors aren't handled by TryCatch. We need to
         // get the error from the module itself.
+        const exception = mod.getException();
         const message = blk: {
-            const e = mod.getException().toString() catch break :blk "???";
+            const e = exception.toString() catch break :blk "???";
             break :blk e.toSlice() catch "???";
         };
+        const stack = blk: {
+            if (comptime IS_DEBUG == false) {
+                // SetCaptureStackTraceForUncaughtExceptions is only set in Debug
+                break :blk "";
+            }
+
+            const stack_handle = v8.v8__Exception__GetStackTrace(exception.handle) orelse break :blk "";
+            var buf = std.Io.Writer.Allocating.init(self.call_arena);
+            js.writeStackTrace(self.isolate.handle, stack_handle, &buf.writer) catch break :blk "???";
+            break :blk buf.written();
+        };
+
         log.warn(.js, "evaluate module", .{
-            .message = message,
+            .stack = stack,
             .specifier = url,
+            .message = message,
         });
         return error.EvaluationError;
     };
diff --git a/src/browser/js/Env.zig b/src/browser/js/Env.zig
index 7635e9a2..9e3ffcb9 100644
--- a/src/browser/js/Env.zig
+++ b/src/browser/js/Env.zig
@@ -135,6 +135,10 @@ pub fn init(app: *App, opts: InitOpts) !Env {
     v8.v8__Isolate__SetFatalErrorHandler(isolate_handle, fatalCallback);
     v8.v8__Isolate__SetOOMErrorHandler(isolate_handle, oomCallback);
 
+    if (comptime IS_DEBUG) {
+        v8.v8__Isolate__SetCaptureStackTraceForUncaughtExceptions(isolate_handle, true, 64);
+    }
+
     isolate.enter();
     errdefer isolate.exit();
 
@@ -304,11 +308,13 @@ fn _createContext(self: *Env, global: anytype, params: ContextParams) !*Context
     };
 
     context.execution = .{
+        .js = context,
         .url = &global.url,
         .buf = &global.buf,
         .charset = &global.charset,
-        .context = context,
         .arena = global.arena,
+        .page = context.page,
+        .session = page.session,
         .call_arena = params.call_arena,
         ._factory = global._factory,
         ._scheduler = &context.scheduler,
diff --git a/src/browser/js/Execution.zig b/src/browser/js/Execution.zig
index d30cd905..6b4bd8cd 100644
--- a/src/browser/js/Execution.zig
+++ b/src/browser/js/Execution.zig
@@ -30,11 +30,12 @@ const lp = @import("lightpanda");
 
 const Context = @import("Context.zig");
 const Scheduler = @import("Scheduler.zig");
+const Page = @import("../Page.zig");
+const Session = @import("../Session.zig");
 const Factory = @import("../Factory.zig");
 const HttpClient = @import("../HttpClient.zig");
 const EventManagerBase = @import("../EventManagerBase.zig");
 
-const Blob = @import("../webapi/Blob.zig");
 const Event = @import("../webapi/Event.zig");
 const EventTarget = @import("../webapi/EventTarget.zig");
 const Performance = @import("../webapi/Performance.zig");
@@ -44,12 +45,15 @@ const Allocator = std.mem.Allocator;
 
 const Execution = @This();
 
-context: *Context,
+js: *Context,
 
 // Fields named to match Page for generic code (executor._factory works for both)
 buf: []u8,
 arena: Allocator,
 call_arena: Allocator,
+
+page: *Page,
+session: *Session,
 _factory: *Factory,
 _scheduler: *Scheduler,
 
@@ -61,7 +65,7 @@ charset: *[]const u8,
 
 // Returns the current base URL of the global scope.
 pub fn base(self: *const Execution) [:0]const u8 {
-    return self.context.global.base();
+    return self.js.global.base();
 }
 
 pub fn dupeString(self: *const Execution, value: []const u8) ![]const u8 {
@@ -72,33 +76,27 @@ pub fn dupeString(self: *const Execution, value: []const u8) ![]const u8 {
 }
 
 pub fn getArena(self: *const Execution, size_or_bucket: anytype, debug: []const u8) !Allocator {
-    return self.context.page.getArena(size_or_bucket, debug);
+    return self.page.getArena(size_or_bucket, debug);
 }
 
 pub fn releaseArena(self: *const Execution, allocator: Allocator) void {
-    self.context.page.releaseArena(allocator);
+    self.page.releaseArena(allocator);
 }
 
 pub fn headersForRequest(self: *const Execution, headers: *HttpClient.Headers) !void {
-    return switch (self.context.global) {
+    return switch (self.js.global) {
         inline else => |g| g.headersForRequest(headers),
     };
 }
 
 pub fn isSameOrigin(self: *const Execution, url: [:0]const u8) bool {
-    return switch (self.context.global) {
+    return switch (self.js.global) {
         inline else => |g| g.isSameOrigin(url),
     };
 }
 
-pub fn lookupBlobUrl(self: *const Execution, url: []const u8) ?*Blob {
-    return switch (self.context.global) {
-        inline else => |g| g.lookupBlobUrl(url),
-    };
-}
-
 pub fn makeRequest(self: *const Execution, req: HttpClient.Request) !void {
-    return switch (self.context.global) {
+    return switch (self.js.global) {
         inline else => |g| g.makeRequest(req),
     };
 }
@@ -108,7 +106,7 @@ pub fn makeRequest(self: *const Execution, req: HttpClient.Request) !void {
 // owning scope without caring whether it's a Frame or a Worker — e.g.
 // WebSocket.init appending to `.websockets`.
 pub fn httpOwner(self: *const Execution) *HttpClient.Owner {
-    return switch (self.context.global) {
+    return switch (self.js.global) {
         inline else => |g| &g._http_owner,
     };
 }
@@ -120,31 +118,31 @@ pub fn dispatch(
     handler: anytype,
     comptime opts: EventManagerBase.DispatchDirectOptions,
 ) !void {
-    return switch (self.context.global) {
+    return switch (self.js.global) {
         inline else => |g| g.dispatch(target, event, handler, opts),
     };
 }
 
 pub fn hasDirectListeners(self: *const Execution, target: *EventTarget, typ: []const u8, handler: anytype) bool {
-    return switch (self.context.global) {
+    return switch (self.js.global) {
         inline else => |g| g.hasDirectListeners(target, typ, handler),
     };
 }
 
 pub fn performance(self: *const Execution) *Performance {
-    return switch (self.context.global) {
+    return switch (self.js.global) {
         inline else => |g| g.performance(),
     };
 }
 
 pub fn frameId(self: *const Execution) u32 {
-    return switch (self.context.global) {
+    return switch (self.js.global) {
         inline else => |g| g._frame_id,
     };
 }
 
 pub fn loaderId(self: *const Execution) u32 {
-    return switch (self.context.global) {
+    return switch (self.js.global) {
         inline else => |g| g._loader_id,
     };
 }
diff --git a/src/browser/js/Function.zig b/src/browser/js/Function.zig
index 240f85ef..7ab17483 100644
--- a/src/browser/js/Function.zig
+++ b/src/browser/js/Function.zig
@@ -23,6 +23,7 @@ const js = @import("js.zig");
 
 const v8 = js.v8;
 const log = lp.log;
+const IS_DEBUG = @import("builtin").mode == .Debug;
 
 const Function = @This();
 
@@ -52,6 +53,20 @@ pub fn withThis(self: *const Function, value: anytype) !Function {
 pub fn newInstance(self: *const Function, caught: *js.TryCatch.Caught) !js.Object {
     const local = self.local;
 
+    if (comptime IS_DEBUG == false) {
+        // This should not be possible, yet it happens. In Release, we'll log an
+        // error and hope for the best. In Debug, we'll let the code execute
+        // and v8 will crash on the null reference. This null value almost
+        // certainly comes from a Global that was reset and thus gets unwrapped
+        // to null (but I haven't figured out the flow that can cause that). This
+        // does indicate that we might be in some shutdown state, so just
+        // return an error might not be too bad.
+        if (@intFromPtr(self.handle) == 0) {
+            log.err(.browser, "newInstance on dead handle", .{});
+            return error.DeadFunctionHandle;
+        }
+    }
+
     var try_catch: js.TryCatch = undefined;
     try_catch.init(local);
     defer try_catch.deinit();
@@ -108,6 +123,20 @@ fn _tryCallWithThis(self: *const Function, comptime T: type, this: anytype, args
     caught.* = .{};
     const local = self.local;
 
+    if (comptime IS_DEBUG == false) {
+        // This should not be possible, yet it happens. In Release, we'll log an
+        // error and hope for the best. In Debug, we'll let the code execute
+        // and v8 will crash on the null reference. This null value almost
+        // certainly comes from a Global that was reset and thus gets unwrapped
+        // to null (but I haven't figured out the flow that can cause that). This
+        // does indicate that we might be in some shutdown state, so just
+        // return an error might not be too bad.
+        if (@intFromPtr(self.handle) == 0) {
+            log.err(.browser, "call on dead handle", .{});
+            return error.DeadFunctionHandle;
+        }
+    }
+
     // When we're calling a function from within JavaScript itself, this isn't
     // necessary. We're within a Caller instantiation, which will already have
     // incremented the call_depth and it won't decrement it until the Caller is
diff --git a/src/browser/js/Local.zig b/src/browser/js/Local.zig
index 900b0b59..e046dcf6 100644
--- a/src/browser/js/Local.zig
+++ b/src/browser/js/Local.zig
@@ -1342,30 +1342,19 @@ fn finalizerPtrGetter(comptime T: type, comptime FT: type) *const fn (*T) *FT {
 }
 
 pub fn stackTrace(self: *const Local) !?[]const u8 {
-    const isolate = self.isolate;
+    const isolate = self.isolate.handle;
+    const stack_handle = v8.v8__StackTrace__CurrentStackTrace__STATIC(isolate, 30) orelse return null;
+
     const separator = log.separator();
 
-    var buf: std.ArrayList(u8) = .empty;
-    var writer = buf.writer(self.call_arena);
-
-    const stack_trace_handle = v8.v8__StackTrace__CurrentStackTrace__STATIC(isolate.handle, 30).?;
-    const frame_count = v8.v8__StackTrace__GetFrameCount(stack_trace_handle);
-
-    if (v8.v8__StackTrace__CurrentScriptNameOrSourceURL__STATIC(isolate.handle)) |script| {
+    var buf = std.Io.Writer.Allocating.init(self.call_arena);
+    if (v8.v8__StackTrace__CurrentScriptNameOrSourceURL__STATIC(isolate)) |script| {
         const stack = js.String{ .local = self, .handle = script };
-        try writer.print("{s}<{f}>", .{ separator, stack });
+        try buf.writer.print("{s}<{f}>", .{ separator, stack });
     }
 
-    for (0..@intCast(frame_count)) |i| {
-        const frame_handle = v8.v8__StackTrace__GetFrame(stack_trace_handle, isolate.handle, @intCast(i)).?;
-        if (v8.v8__StackFrame__GetFunctionName(frame_handle)) |name| {
-            const script = js.String{ .local = self, .handle = name };
-            try writer.print("{s}{f}:{d}", .{ separator, script, v8.v8__StackFrame__GetLineNumber(frame_handle) });
-        } else {
-            try writer.print("{s}<anonymous>:{d}", .{ separator, v8.v8__StackFrame__GetLineNumber(frame_handle) });
-        }
-    }
-    return buf.items;
+    try js.writeStackTrace(isolate, stack_handle, &buf.writer);
+    return buf.written();
 }
 
 // == Promise Helpers ==
@@ -1508,6 +1497,13 @@ pub fn newException(self: *const Local, ex: anytype) js.Exception {
     };
 }
 
+pub fn getGlobal(self: *const Local) js.Object {
+    return .{
+        .local = self,
+        .handle = v8.v8__Context__Global(self.handle).?,
+    };
+}
+
 // Convert a Global (or optional Global) to a Local (or optional Local).
 // Meant to be used from either frame.js.toLocal, where the context must have an
 // non-null local (orelse panic), or from a LocalScope
diff --git a/src/browser/js/bridge.zig b/src/browser/js/bridge.zig
index e971edd1..96c5cd65 100644
--- a/src/browser/js/bridge.zig
+++ b/src/browser/js/bridge.zig
@@ -827,6 +827,7 @@ pub const PageJsApis = flattenTypes(&.{
     @import("../webapi/XMLSerializer.zig"),
     @import("../webapi/AbstractRange.zig"),
     @import("../webapi/Range.zig"),
+    @import("../webapi/StaticRange.zig"),
     @import("../webapi/NodeFilter.zig"),
     @import("../webapi/Element.zig"),
     @import("../webapi/element/DOMStringMap.zig"),
diff --git a/src/browser/js/js.zig b/src/browser/js/js.zig
index 1d4140fe..d159ddbc 100644
--- a/src/browser/js/js.zig
+++ b/src/browser/js/js.zig
@@ -17,6 +17,8 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 const std = @import("std");
+const lp = @import("lightpanda");
+
 pub const v8 = @import("v8").c;
 
 const string = @import("../../string.zig");
@@ -417,3 +419,19 @@ pub const FinalizerCallback = struct {
         page.releaseArena(self.arena);
     }
 };
+
+pub fn writeStackTrace(isolate: *v8.Isolate, stack_handle: *const v8.StackTrace, writer: *std.Io.Writer) !void {
+    const separator = lp.log.separator();
+    const frame_count = v8.v8__StackTrace__GetFrameCount(stack_handle);
+
+    for (0..@intCast(frame_count)) |i| {
+        const frame_handle = v8.v8__StackTrace__GetFrame(stack_handle, isolate, @intCast(i)).?;
+        if (v8.v8__StackFrame__GetFunctionName(frame_handle)) |name| {
+            var buf: [1024]u8 = undefined;
+            const n = v8.v8__String__WriteUtf8(name, isolate, &buf, buf.len, v8.NO_NULL_TERMINATION | v8.REPLACE_INVALID_UTF8);
+            try writer.print("{s}{s}:{d}", .{ separator, buf[0..n], v8.v8__StackFrame__GetLineNumber(frame_handle) });
+        } else {
+            try writer.print("{s}<anonymous>:{d}", .{ separator, v8.v8__StackFrame__GetLineNumber(frame_handle) });
+        }
+    }
+}
diff --git a/src/browser/markdown.zig b/src/browser/markdown.zig
index c542c7e4..e72065ca 100644
--- a/src/browser/markdown.zig
+++ b/src/browser/markdown.zig
@@ -20,9 +20,12 @@ const std = @import("std");
 
 const Frame = @import("Frame.zig");
 const URL = @import("URL.zig");
-const TreeWalker = @import("webapi/TreeWalker.zig");
-const Element = @import("webapi/Element.zig");
+
 const Node = @import("webapi/Node.zig");
+const Element = @import("webapi/Element.zig");
+const TreeWalker = @import("webapi/TreeWalker.zig");
+const Slot = @import("webapi/element/html/Slot.zig");
+
 const isAllWhitespace = @import("../string.zig").isAllWhitespace;
 const truncateUtf8 = @import("../string.zig").truncateUtf8;
 
@@ -187,6 +190,10 @@ const Context = struct {
     writer: *std.Io.Writer,
     frame: *Frame,
 
+    // When there's a slot-attribute, we skip rendering, unless this flag has
+    // bet set to true.
+    force_slot: bool = false,
+
     fn ensureNewline(self: *Context) !void {
         if (!self.state.last_char_was_newline) {
             try self.writer.writeByte('\n');
@@ -224,11 +231,37 @@ const Context = struct {
         }
     }
 
+    // Render a <slot>'s assigned light-DOM nodes, or its own children as
+    // fallback. Same as dump's dumpSlotContent.
+    fn renderSlotContent(self: *Context, slot: *Slot) !void {
+        const assigned = slot.assignedNodes(null, self.frame) catch return;
+        if (assigned.len == 0) {
+            return self.renderChildren(slot.asNode());
+        }
+        for (assigned) |node| {
+            // ensures that we don't skip this element when rending it.
+            self.force_slot = true;
+            try self.render(node);
+        }
+        self.force_slot = false;
+    }
+
     fn renderElement(self: *Context, el: *Element) !void {
+        const force_slot = self.force_slot;
+        self.force_slot = false;
+
         const tag = el.getTag();
 
         if (!isVisibleElement(el)) return;
 
+        if (!force_slot) {
+            if (el.getAttributeSafe(comptime .wrap("slot")) != null) {
+                // This element has a slot attribute, and we aren't forcing slot
+                // rendering (i.e. this is the light-DOM), skip it.
+                return;
+            }
+        }
+
         // Ensure block elements start on a new line
         if (tag.isBlock() and !self.state.in_table) {
             try self.ensureNewline();
@@ -396,10 +429,21 @@ const Context = struct {
                 }
                 return;
             },
+            .slot => return self.renderSlotContent(el.as(Slot)),
             else => {},
         }
 
-        try self.renderChildren(el.asNode());
+        // Composed tree: a shadow host renders its shadow tree in place of its
+        // light-DOM children (light DOM is visible only through <slot>). Applies
+        // to open and closed roots alike. markdown is always a rendered-content
+        // path (cf. dump.zig's default .rendered mode), so we always pierce; the
+        // early-return tags above can never be valid shadow hosts, so only this
+        // generic path needs the check.
+        if (self.frame._element_shadow_roots.get(el)) |shadow| {
+            try self.renderChildren(shadow.asNode());
+        } else {
+            try self.renderChildren(el.asNode());
+        }
 
         switch (tag) {
             .pre => {
@@ -823,3 +867,80 @@ test "browser.markdown: max_bytes truncates with marker" {
     try testing.expect(std.mem.endsWith(u8, out, "[truncated]\n"));
     try testing.expect(out.len <= 50 + truncation_marker.len);
 }
+
+// Builds a shadow host <div>, populates its light DOM with `light` and its
+// (open) shadow tree with `shadow`, then dumps the host. Declarative shadow DOM
+// parsing isn't implemented, so the shadow tree is attached imperatively.
+fn testMarkdownShadow(light: []const u8, shadow: []const u8, expected: []const u8) !void {
+    const testing = @import("../testing.zig");
+    const frame = try testing.test_session.createPage();
+    defer testing.test_session.removePage();
+    frame.url = "http://localhost/";
+
+    const doc = frame.window._document;
+
+    const host = try doc.createElement("div", null, frame);
+    if (light.len > 0) {
+        try frame.parseHtmlAsChildren(host.asNode(), light);
+    }
+
+    const sr = try host.attachShadow(comptime .wrap("open"), frame);
+    try frame.parseHtmlAsChildren(sr.asNode(), shadow);
+
+    var aw: std.Io.Writer.Allocating = .init(testing.allocator);
+    defer aw.deinit();
+    try dump(host.asNode(), .{}, &aw.writer, frame);
+
+    try testing.expectString(expected, aw.written());
+}
+
+test "browser.markdown: shadow content is pierced" {
+    try testMarkdownShadow("", "Shadow content", "Shadow content\n");
+}
+
+test "browser.markdown: slot projects assigned light DOM" {
+    // The slotted <span> renders at the slot's position in the shadow tree
+    // (inside the <h2>), and not a second time at its light-DOM position.
+    try testMarkdownShadow(
+        \\<span slot="title">Slotted</span>
+    ,
+        \\<h2><slot name="title"></slot></h2>
+    , "\n## Slotted\n");
+}
+
+test "browser.markdown: unassigned light DOM is omitted" {
+    // Light DOM is visible only through a <slot>; with no matching slot the
+    // light <p> must not appear — only the shadow tree's content does.
+    try testMarkdownShadow(
+        \\<p>orphan</p>
+    ,
+        \\<div>only shadow</div>
+    , "only shadow\n");
+}
+
+test "browser.markdown: slot fallback content when nothing assigned" {
+    try testMarkdownShadow("",
+        \\<slot name="x">Default text</slot>
+    , "Default text\n");
+}
+
+// End-to-end: a declarative shadow root (parsed via setHTMLUnsafe) is attached
+// as a real shadow tree, and markdown's composed-tree piercing then renders it.
+test "browser.markdown: declarative shadow DOM renders through piercing" {
+    const testing = @import("../testing.zig");
+    const frame = try testing.test_session.createPage();
+    defer testing.test_session.removePage();
+    frame.url = "http://localhost/";
+
+    const doc = frame.window._document;
+    const host = try doc.createElement("div", null, frame);
+    try host.setHTMLUnsafe(
+        \\<div><template shadowrootmode="open"><p>shadow content</p></template></div>
+    , frame);
+
+    var aw: std.Io.Writer.Allocating = .init(testing.allocator);
+    defer aw.deinit();
+    try dump(host.asNode(), .{}, &aw.writer, frame);
+
+    try testing.expectString("\nshadow content\n", aw.written());
+}
diff --git a/src/browser/parser/Parser.zig b/src/browser/parser/Parser.zig
index 5dcb8284..65d66e4a 100644
--- a/src/browser/parser/Parser.zig
+++ b/src/browser/parser/Parser.zig
@@ -71,7 +71,16 @@ pending_text: ?PendingText,
 // second chunk of a run, so the common case stays at one copy.
 buf: std.ArrayList(u8),
 
-pub fn init(arena: Allocator, node: *Node, frame: *Frame) Parser {
+// Whether `<template shadowrootmode>` is parsed into a real shadow root.
+// True for document navigation, document.write, and setHTMLUnsafe; false for
+// innerHTML and DOMParser (per spec). Set from Options at init.
+allow_declarative_shadow: bool = false,
+
+pub const Options = struct {
+    allow_declarative_shadow: bool = false,
+};
+
+pub fn init(arena: Allocator, node: *Node, frame: *Frame, opts: Options) Parser {
     return .{
         .err = null,
         .frame = frame,
@@ -83,6 +92,7 @@ pub fn init(arena: Allocator, node: *Node, frame: *Frame) Parser {
         },
         .pending_text = null,
         .buf = .empty,
+        .allow_declarative_shadow = opts.allow_declarative_shadow,
     };
 }
 
@@ -157,6 +167,7 @@ const Error = struct {
         reparent_children,
         append_before_sibling,
         append_based_on_parent_node,
+        attach_declarative_shadow,
     };
 };
 
@@ -180,6 +191,8 @@ pub fn parse(self: *Parser, html: []const u8) void {
         reparentChildrenCallback,
         appendBeforeSiblingCallback,
         appendBasedOnParentNodeCallback,
+        attachDeclarativeShadowCallback,
+        self.allow_declarative_shadow,
     );
     self.flushPendingText() catch |err| {
         if (self.err == null) self.err = .{ .err = err, .source = .append };
@@ -209,6 +222,8 @@ pub fn parseWithEncoding(self: *Parser, html: []const u8, charset: []const u8) v
         reparentChildrenCallback,
         appendBeforeSiblingCallback,
         appendBasedOnParentNodeCallback,
+        attachDeclarativeShadowCallback,
+        self.allow_declarative_shadow,
     );
     self.flushPendingText() catch |err| {
         if (self.err == null) self.err = .{ .err = err, .source = .append };
@@ -235,6 +250,8 @@ pub fn parseXML(self: *Parser, xml: []const u8) void {
         reparentChildrenCallback,
         appendBeforeSiblingCallback,
         appendBasedOnParentNodeCallback,
+        attachDeclarativeShadowCallback,
+        false,
     );
     self.flushPendingText() catch |err| {
         if (self.err == null) self.err = .{ .err = err, .source = .append };
@@ -261,6 +278,8 @@ pub fn parseFragment(self: *Parser, html: []const u8) void {
         reparentChildrenCallback,
         appendBeforeSiblingCallback,
         appendBasedOnParentNodeCallback,
+        attachDeclarativeShadowCallback,
+        self.allow_declarative_shadow,
     );
     self.flushPendingText() catch |err| {
         if (self.err == null) self.err = .{ .err = err, .source = .append };
@@ -271,10 +290,10 @@ pub const Streaming = struct {
     parser: Parser,
     handle: ?*anyopaque,
 
-    pub fn init(arena: Allocator, node: *Node, frame: *Frame) Streaming {
+    pub fn init(arena: Allocator, node: *Node, frame: *Frame, opts: Options) Streaming {
         return .{
             .handle = null,
-            .parser = Parser.init(arena, node, frame),
+            .parser = Parser.init(arena, node, frame, opts),
         };
     }
 
@@ -304,6 +323,8 @@ pub const Streaming = struct {
             reparentChildrenCallback,
             appendBeforeSiblingCallback,
             appendBasedOnParentNodeCallback,
+            attachDeclarativeShadowCallback,
+            self.parser.allow_declarative_shadow,
         ) orelse return error.ParserCreationFailed;
     }
 
@@ -499,6 +520,34 @@ fn _getTemplateContentsCallback(self: *Parser, node: *Node) !*anyopaque {
     return pn;
 }
 
+// Called for `<template shadowrootmode>` when declarative shadow roots are
+// allowed. Attaches a shadow root to `host` and redirects the (stack-only)
+// template's contents into it, so html5ever parses the template's children
+// straight into the shadow root. Returns 1 on success, 0 to tell html5ever to
+// fall back to inserting the template as a normal light-DOM element.
+fn attachDeclarativeShadowCallback(ctx: *anyopaque, host_ref: *anyopaque, template_ref: *anyopaque, mode_is_open: u8) callconv(.c) u8 {
+    const self: *Parser = @ptrCast(@alignCast(ctx));
+    return self._attachDeclarativeShadowCallback(getNode(host_ref), getNode(template_ref), mode_is_open != 0) catch |err| {
+        self.err = .{ .err = err, .source = .attach_declarative_shadow };
+        return 0;
+    };
+}
+
+fn _attachDeclarativeShadowCallback(self: *Parser, host_node: *Node, template_node: *Node, mode_is_open: bool) !u8 {
+    // guaranteed by html5ever
+    const host = host_node.as(Element);
+    const mode: lp.String = if (mode_is_open) comptime .wrap("open") else comptime .wrap("closed");
+    const shadow = host.attachShadow(mode, self.frame) catch |err| switch (err) {
+        // Expected per-spec fall-backs (host can't host a shadow, or already
+        // has one): keep the <template> in the light DOM instead.
+        error.NotSupported => return 0,
+        else => return err,
+    };
+    const template = template_node.as(Element).is(Element.Html.Template) orelse return 0;
+    template._content = shadow.asDocumentFragment();
+    return 1;
+}
+
 fn getDataCallback(ctx: *anyopaque) callconv(.c) *anyopaque {
     const pn: *ParsedNode = @ptrCast(@alignCast(ctx));
     // For non-elements, data is null. But, we expect this to only ever
diff --git a/src/browser/parser/html5ever.zig b/src/browser/parser/html5ever.zig
index 829ac429..135e6c96 100644
--- a/src/browser/parser/html5ever.zig
+++ b/src/browser/parser/html5ever.zig
@@ -37,6 +37,8 @@ pub extern "c" fn html5ever_parse_document(
     reparentChildrenCallback: *const fn (ctx: *anyopaque, node_ref: *anyopaque, new_parent_ref: *anyopaque) callconv(.c) void,
     appendBeforeSiblingCallback: *const fn (ctx: *anyopaque, sibling_ref: *anyopaque, NodeOrText) callconv(.c) void,
     appendBasedOnParentNodeCallback: *const fn (ctx: *anyopaque, element_ref: *anyopaque, prev_element_ref: *anyopaque, NodeOrText) callconv(.c) void,
+    attachDeclarativeShadowCallback: *const fn (ctx: *anyopaque, host_ref: *anyopaque, template_ref: *anyopaque, mode_is_open: u8) callconv(.c) u8,
+    allow_declarative_shadow: bool,
 ) void;
 
 /// Parse HTML document with encoding conversion. Converts from charset to UTF-8 before parsing.
@@ -61,6 +63,8 @@ pub extern "c" fn html5ever_parse_document_with_encoding(
     reparentChildrenCallback: *const fn (ctx: *anyopaque, node_ref: *anyopaque, new_parent_ref: *anyopaque) callconv(.c) void,
     appendBeforeSiblingCallback: *const fn (ctx: *anyopaque, sibling_ref: *anyopaque, NodeOrText) callconv(.c) void,
     appendBasedOnParentNodeCallback: *const fn (ctx: *anyopaque, element_ref: *anyopaque, prev_element_ref: *anyopaque, NodeOrText) callconv(.c) void,
+    attachDeclarativeShadowCallback: *const fn (ctx: *anyopaque, host_ref: *anyopaque, template_ref: *anyopaque, mode_is_open: u8) callconv(.c) u8,
+    allow_declarative_shadow: bool,
 ) void;
 
 pub extern "c" fn html5ever_parse_fragment(
@@ -82,6 +86,8 @@ pub extern "c" fn html5ever_parse_fragment(
     reparentChildrenCallback: *const fn (ctx: *anyopaque, node_ref: *anyopaque, new_parent_ref: *anyopaque) callconv(.c) void,
     appendBeforeSiblingCallback: *const fn (ctx: *anyopaque, sibling_ref: *anyopaque, NodeOrText) callconv(.c) void,
     appendBasedOnParentNodeCallback: *const fn (ctx: *anyopaque, element_ref: *anyopaque, prev_element_ref: *anyopaque, NodeOrText) callconv(.c) void,
+    attachDeclarativeShadowCallback: *const fn (ctx: *anyopaque, host_ref: *anyopaque, template_ref: *anyopaque, mode_is_open: u8) callconv(.c) u8,
+    allow_declarative_shadow: bool,
 ) void;
 
 pub extern "c" fn html5ever_attribute_iterator_next(ctx: *anyopaque) Nullable(Attribute);
@@ -112,6 +118,8 @@ pub extern "c" fn html5ever_streaming_parser_create(
     reparentChildrenCallback: *const fn (ctx: *anyopaque, node_ref: *anyopaque, new_parent_ref: *anyopaque) callconv(.c) void,
     appendBeforeSiblingCallback: *const fn (ctx: *anyopaque, sibling_ref: *anyopaque, NodeOrText) callconv(.c) void,
     appendBasedOnParentNodeCallback: *const fn (ctx: *anyopaque, element_ref: *anyopaque, prev_element_ref: *anyopaque, NodeOrText) callconv(.c) void,
+    attachDeclarativeShadowCallback: *const fn (ctx: *anyopaque, host_ref: *anyopaque, template_ref: *anyopaque, mode_is_open: u8) callconv(.c) u8,
+    allow_declarative_shadow: bool,
 ) ?*anyopaque;
 
 pub extern "c" fn html5ever_streaming_parser_feed(
@@ -215,6 +223,8 @@ pub extern "c" fn xml5ever_parse_document(
     reparentChildrenCallback: *const fn (ctx: *anyopaque, node_ref: *anyopaque, new_parent_ref: *anyopaque) callconv(.c) void,
     appendBeforeSiblingCallback: *const fn (ctx: *anyopaque, sibling_ref: *anyopaque, NodeOrText) callconv(.c) void,
     appendBasedOnParentNodeCallback: *const fn (ctx: *anyopaque, element_ref: *anyopaque, prev_element_ref: *anyopaque, NodeOrText) callconv(.c) void,
+    attachDeclarativeShadowCallback: *const fn (ctx: *anyopaque, host_ref: *anyopaque, template_ref: *anyopaque, mode_is_open: u8) callconv(.c) u8,
+    allow_declarative_shadow: bool,
 ) void;
 
 // General encoding api
diff --git a/src/browser/tests/console/console.html b/src/browser/tests/console/console.html
index 8f68ccd8..cb35991a 100644
--- a/src/browser/tests/console/console.html
+++ b/src/browser/tests/console/console.html
@@ -1,6 +1,20 @@
 <!DOCTYPE html>
 <script src="../testing.js"></script>
 
+<script id=replaceable>
+    "use strict";
+    // console is [Replaceable] (Console Standard): assignment must replace it
+    // even in strict mode — neither throwing nor silently no-op'ing, and even
+    // after console has already been read.
+    const prev = window.console;
+    window.console = {marker: 42};
+    testing.expectEqual(42, window.console.marker);
+    testing.expectEqual(42, console.marker);
+    // restore: console is now a writable data property, so this just overwrites it.
+    window.console = prev;
+    testing.expectEqual(true, window.console === prev);
+</script>
+
 <script id=entries>
     {
         const entries = Object.entries(console);
diff --git a/src/browser/tests/document/write.html b/src/browser/tests/document/write.html
index 7322882f..e079c92c 100644
--- a/src/browser/tests/document/write.html
+++ b/src/browser/tests/document/write.html
@@ -142,6 +142,23 @@
   }
 </script>
 
+<!-- document.write processes declarative shadow roots, like the parser. -->
+<script id=write_declarative_shadow>
+  document.write('<div id="dw_dsd"><template shadowrootmode="open"><p>written shadow</p></template></div>');
+  testing.expectEqual(true, true);
+</script>
+
+<script id=verify_declarative_shadow>
+  {
+    const host = document.getElementById('dw_dsd');
+    // The shadow root survives the fragment->live-DOM splice.
+    testing.expectEqual(true, host.shadowRoot !== null);
+    testing.expectEqual('written shadow', host.shadowRoot.querySelector('p').textContent);
+    // The <template> was consumed, not left in light DOM.
+    testing.expectEqual(null, host.querySelector('template'));
+  }
+</script>
+
 <!-- Phase 3 Tests: document.open/close would go here -->
 <!-- Note: Testing document.open/close requires async/setTimeout which doesn't -->
 <!-- work well with the test isolation. The implementation is tested manually. -->
diff --git a/src/browser/tests/element/html/script/data_url.html b/src/browser/tests/element/html/script/data_url.html
new file mode 100644
index 00000000..43546761
--- /dev/null
+++ b/src/browser/tests/element/html/script/data_url.html
@@ -0,0 +1,29 @@
+<!DOCTYPE html>
+<script src="../../../testing.js"></script>
+
+<!--
+  data: <script src> resolves through the HTTP client's synthetic-scheme path
+  (no special-casing in ScriptManager). Execution mode is attribute-driven,
+  exactly like any other src: bare = blocking, defer/async = deferred.
+-->
+
+<!-- Blocking, parser-inserted: run in document order, before the check below. -->
+<script src="data:text/javascript,window.__plain = 3;"></script>
+<script src="data:text/javascript;base64,d2luZG93Ll9fYjY0ID0gNDI7"></script>
+<script src="data:text/javascript,window.__enc%20%3D%207%3B"></script>
+
+<script id=blocking_data_urls>
+{
+   testing.expectEqual(3, window.__plain);
+   testing.expectEqual(42, window.__b64);
+   testing.expectEqual(7, window.__enc);
+}
+</script>
+
+<!-- A deferred data: src must still run; proves mode follows the attribute. -->
+<script src="data:text/javascript,window.__deferred = 'ran';" defer></script>
+<script id=deferred_check>
+   testing.onload(() => {
+      testing.expectEqual('ran', window.__deferred);
+   });
+</script>
diff --git a/src/browser/tests/event/message.html b/src/browser/tests/event/message.html
index 88be4650..55153c8b 100644
--- a/src/browser/tests/event/message.html
+++ b/src/browser/tests/event/message.html
@@ -161,6 +161,32 @@
 }
 </script>
 
+<script id=postMessageTransfersPorts>
+{
+  // window.postMessage(data, targetOrigin, [port]) must deliver the transferred
+  // MessagePort as event.ports[0] (regression: ports used to always be empty,
+  // so receivers doing `e.ports[0].onmessage = ...` threw on undefined).
+  const channel = new MessageChannel();
+  let received = null;
+  let echoed = null;
+
+  channel.port1.onmessage = (e) => { echoed = e.data; };
+
+  const handler = (e) => {
+    received = e.ports[0];
+    received.postMessage('pong');
+  };
+  window.addEventListener('message', handler, { once: true });
+
+  window.postMessage('ping', '*', [channel.port2]);
+
+  testing.onload(() => {
+    testing.expectEqual(true, received instanceof MessagePort);
+    testing.expectEqual('pong', echoed);
+  });
+}
+</script>
+
 <script id=messageEventOriginFromLocation>
 {
   let receivedOrigin = null;
diff --git a/src/browser/tests/frames/data_url_iframe.html b/src/browser/tests/frames/data_url_iframe.html
new file mode 100644
index 00000000..17cbe8bf
--- /dev/null
+++ b/src/browser/tests/frames/data_url_iframe.html
@@ -0,0 +1,23 @@
+<!DOCTYPE html>
+<script src="../testing.js"></script>
+
+<script id=data_url_navigation type=module>
+  // data: navigation flows through the HTTP client's synthetic-scheme path
+  // (resource_type=.document -> serveSynthetic), like any URL. The data:
+  // document is cross-origin (opaque origin), so we can't read its
+  // contentDocument — instead it reports its own parsed content back via
+  // postMessage, which proves serveSynthetic delivered the bytes and they
+  // parsed + ran.
+  {
+    const state = await testing.async();
+    window.addEventListener('message', (e) => state.resolve(e.data));
+
+    const f = document.createElement('iframe');
+    f.src = "data:text/html,<p>hello</p><script>parent.postMessage(document.querySelector('p').textContent, '*')<\/script>";
+    document.documentElement.appendChild(f);
+
+    await state.done((data) => {
+      testing.expectEqual('hello', data);
+    });
+  }
+</script>
diff --git a/src/browser/tests/legacy/browser.html b/src/browser/tests/legacy/browser.html
deleted file mode 100644
index 1f60488b..00000000
--- a/src/browser/tests/legacy/browser.html
+++ /dev/null
@@ -1,10 +0,0 @@
-<!DOCTYPE html>
-<script src="testing.js"></script>
-<script id=intl>
-  var te = new TextEncoder();
-  testing.expectEqual('utf-8', te.encoding);
-  testing.expectEqual([226, 130, 172], Array.from(te.encode('€')));
-
-  // this will crash if ICU isn't properly configured / ininitialized
-  testing.expectEqual("[object Intl.DateTimeFormat]", new Intl.DateTimeFormat().toString());
-</script>
diff --git a/src/browser/tests/legacy/crypto.html b/src/browser/tests/legacy/crypto.html
deleted file mode 100644
index f1dc291a..00000000
--- a/src/browser/tests/legacy/crypto.html
+++ /dev/null
@@ -1,26 +0,0 @@
-<!DOCTYPE html>
-<script src="testing.js"></script>
-<script id=crypto>
-  const a = crypto.randomUUID();
-  const b = crypto.randomUUID();
-  testing.expectEqual(36, a.length);
-  testing.expectEqual(36, b.length);
-  testing.expectEqual(false, a == b)
-
-  testing.expectError('Error: QuotaExceededError', () => {
-    crypto.getRandomValues(new BigUint64Array(8193));
-  });
-
-  let r1 = new Int32Array(5)
-  let r2 = crypto.getRandomValues(r1)
-  testing.expectEqual(5, new Set(r1).size);
-  testing.expectEqual(5, new Set(r2).size);
-  testing.expectEqual(true, r1.every((v, i) => v === r2[i]));
-
-  var r3 = new Uint8Array(16);
-  let r4 = crypto.getRandomValues(r3);
-
-  r4[6] = 10;
-  testing.expectEqual(10, r4[6]);
-  testing.expectEqual(10, r3[6]);
-</script>
diff --git a/src/browser/tests/legacy/css.html b/src/browser/tests/legacy/css.html
deleted file mode 100644
index 3f83e934..00000000
--- a/src/browser/tests/legacy/css.html
+++ /dev/null
@@ -1,6 +0,0 @@
-<!DOCTYPE html>
-<script src="testing.js"></script>
-<script id=support>
-  testing.expectEqual(true, CSS.supports('display: flex'));
-  testing.expectEqual(true, CSS.supports('text-decoration-style', 'blink'));
-</script>
diff --git a/src/browser/tests/legacy/cssom/css_style_declaration.html b/src/browser/tests/legacy/cssom/css_style_declaration.html
deleted file mode 100644
index 3d4e961e..00000000
--- a/src/browser/tests/legacy/cssom/css_style_declaration.html
+++ /dev/null
@@ -1,101 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-<script id=css_style_declaration>
-  let style = document.createElement('div').style;
-  style.cssText = 'color: red; font-size: 12px; margin: 5px !important;';
-  testing.expectEqual(3, style.length);
-
-  testing.expectEqua;('red', style.getPropertyValue('color'));
-  testing.expectEqua;('12px', style.getPropertyValue('font-size'));
-  testing.expectEqua;('', style.getPropertyValue('unknown-property'));
-
-  testing.expectEqual('important', style.getPropertyPriority('margin'));
-  testing.expectEqual('', style.getPropertyPriority('color'));
-  testing.expectEqual('', style.getPropertyPriority('unknown-property'));
-
-  testing.expectEqual('color', style.item(0));
-  testing.expectEqual('font-size', style.item(1));
-  testing.expectEqual('margin', style.item(2));
-  testing.expectEqual('', style.item(3));
-
-  style.setProperty('background-color', 'blue');
-  testing.expectEqual('blue', style.getPropertyValue('background-color'));
-  testing.expectEqual(4, style.length);
-
-  style.setProperty('color', 'green');
-  testing.expectEqual('green', style.color);
-  testing.expectEqual('green', style.getPropertyValue('color'));
-  testing.expectEqual(4, style.length);
-
-  style.setProperty('padding', '10px', 'important');
-  testing.expectEqual('10px', style.getPropertyValue('padding'));
-  testing.expectEqual('important', style.getPropertyPriority('padding'));
-
-  style.setProperty('border', '1px solid black', 'IMPORTANT');
-  testing.expectEqual('important', style.getPropertyPriority('border'));
-</script>
-
-<script id=removeProperty>
-  testing.expectEqual('green', style.removeProperty('color'));
-  testing.expectEqual('', style.getPropertyValue('color'));
-  testing.expectEqual(5, style.length)
-
-  testing.expectEqual('', style.removeProperty('unknown-property'));
-</script>
-
-<script id=includes>
-  testing.expectEqual(false, style.cssText.includes('font-size: 10px;'));
-  testing.expectEqual(true, style.cssText.includes('font-size: 12px;'));
-  testing.expectEqual(true, style.cssText.includes('margin: 5px !important;'));
-  testing.expectEqual(true, style.cssText.includes('padding: 10px !important;'));
-  testing.expectEqual(true, style.cssText.includes('border: 1px solid black !important;'));
-</script>
-
-<script id=special_char">
-  style.cssText = 'color: purple; text-align: center;';
-  testing.expectEqual(2, style.length);
-  testing.expectEqual('purple', style.getPropertyValue('color'));
-  testing.expectEqual('center', style.getPropertyValue('text-align'));
-  testing.expectEqual('', style.getPropertyValue('font-size'));
-
-  style.setProperty('cont', 'Hello; world!');
-  testing.expectEqual('Hello; world!', style.getPropertyValue('cont'));
-
-  style.cssText = 'content: "Hello; world!"; background-image: url("test.png");';
-  testing.expectEqual('"Hello; world!"', style.getPropertyValue('content'));
-  testing.expectEqual('url("test.png")', style.getPropertyValue('background-image'));
-</script>
-
-<script id=cssFloat">
-  testing.expectEqual('', style.cssFloat);
-  style.cssFloat = 'left';
-  testing.expectEqual('left', style.cssFloat);
-  testing.expectEqual('left', style.getPropertyValue('float'));
-
-  style.cssFloat = 'right';
-  testing.expectEqual('right', style.cssFloat);
-  testing.expectEqual('right', style.getPropertyValue('float'));
-
-  style.cssFloat = null;
-  testing.expectEqual('', style.cssFloat);
-  testing.expectEqual('', style.getPropertyValue('float'));
-</script>
-
-<script id=misc>
-  style.setProperty('display', '');
-  testing.expectEqual('', style.getPropertyValue('display'));
-
-  // style.cssText = '  color  :  purple  ;  margin  :  10px  ;  ';
-  // testing.expectEqual('purple', style.getPropertyValue('color'));
-  // testing.expectEqual('10px', style.getPropertyValue('margin'));
-
-  // style.setProperty('border-bottom-left-radius', '5px');
-  // testing.expectEqual('5px', style.getPropertyValue('border-bottom-left-radius'));
-
-  // testing.expectEqual('visible', style.visibility);
-  // testing.expectEqual('visible', style.getPropertyValue('visibility'));
-
-  // testing.expectEqual('10px', style.margin);
-  // style.margin = 'auto';
-  // testing.expectEqual('auto', style.margin);
-</script>
diff --git a/src/browser/tests/legacy/cssom/css_stylesheet.html b/src/browser/tests/legacy/cssom/css_stylesheet.html
deleted file mode 100644
index 20ee1dfe..00000000
--- a/src/browser/tests/legacy/cssom/css_stylesheet.html
+++ /dev/null
@@ -1,16 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-<script id=css_stylesheet>
-  let css = new CSSStyleSheet()
-  testing.expectEqual(true, css instanceof CSSStyleSheet);
-  testing.expectEqual(0, css.cssRules.length);
-  testing.expectEqual(null, css.ownerRule);
-
-  let index1 = css.insertRule('body { color: red; }', 0);
-  testing.expectEqual(0, index1);
-  testing.expectEqual(0, css.cssRules.length);
-
-  let replaced = false;
-  css.replace('body{}').then(() => replaced = true);
-  testing.onload(() => testing.expectEqual(true, replaced));
-</script>
diff --git a/src/browser/tests/legacy/dom/animation.html b/src/browser/tests/legacy/dom/animation.html
deleted file mode 100644
index e109ab0e..00000000
--- a/src/browser/tests/legacy/dom/animation.html
+++ /dev/null
@@ -1,15 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-
-<script id=animation>
-  let a1 = document.createElement('div').animate(null, null);
-  testing.expectEqual('finished', a1.playState);
-
-  let cb = [];
-  a1.ready.then(() => { cb.push('ready') });
-  a1.finished.then((x) => {
-    cb.push('finished');
-    cb.push(x == a1);
-  });
-  testing.onload(() => testing.expectEqual(['finished', true], cb));
-</script>
diff --git a/src/browser/tests/legacy/dom/attribute.html b/src/browser/tests/legacy/dom/attribute.html
deleted file mode 100644
index 2e208861..00000000
--- a/src/browser/tests/legacy/dom/attribute.html
+++ /dev/null
@@ -1,33 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-
-<a id="link" href="foo" class="ok">OK</a>
-
-<script id=attribute>
-  let a = document.createAttributeNS('foo', 'bar');
-  testing.expectEqual('foo', a.namespaceURI);
-  testing.expectEqual(null, a.prefix);
-  testing.expectEqual('bar', a.localName);
-  testing.expectEqual('bar', a.name);
-  testing.expectEqual('', a.value);
-
-  // TODO: libdom has a bug here: the created attr has no parent, it
-  // causes a panic w/ libdom when setting the value.
-  //.{ "a.value = 'nok'", "nok" },
-  testing.expectEqual(null, a.ownerElement);
-
-  let b = document.getElementById('link').getAttributeNode('class');
-  testing.expectEqual('class', b.name);
-  testing.expectEqual('ok', b.value);
-
-  b.value = 'nok';
-  testing.expectEqual('nok', b.value)
-
-  b.value = null;
-  testing.expectEqual('null', b.value);
-
-  b.value = 'ok';
-  testing.expectEqual('ok', b.value);
-
-  testing.expectEqual('link', b.ownerElement.id);
-</script>
diff --git a/src/browser/tests/legacy/dom/character_data.html b/src/browser/tests/legacy/dom/character_data.html
deleted file mode 100644
index ff74da90..00000000
--- a/src/browser/tests/legacy/dom/character_data.html
+++ /dev/null
@@ -1,48 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-
-<a id="link" href="foo" class="ok">OK</a>
-
-<script id=character_data>
-  let link = document.getElementById('link');
-  let cdata = link.firstChild;
-  testing.expectEqual('OK', cdata.data);
-
-  cdata.data = 'OK modified';
-  testing.expectEqual('OK modified', cdata.data);
-  cdata.data = 'OK';
-
-  testing.expectEqual(2, cdata.length);
-
-  testing.expectEqual(true, cdata.nextElementSibling === null);
-
-  // create a next element
-  let next = document.createElement('a');
-  testing.expectEqual(true, link.appendChild(next, cdata) !== undefined);
-  testing.expectEqual(true, cdata.nextElementSibling.localName === 'a');
-
-  testing.expectEqual(true, cdata.previousElementSibling === null);
-
-  // create a prev element
-  let prev = document.createElement('div');
-  testing.expectEqual(true, link.insertBefore(prev, cdata) !== undefined);
-  testing.expectEqual('div', cdata.previousElementSibling.localName);
-
-  cdata.appendData(' modified');
-  testing.expectEqual('OK modified', cdata.data);
-
-  cdata.deleteData('OK'.length, ' modified'.length);
-  testing.expectEqual('OK', cdata.data)
-
-  cdata.insertData('OK'.length-1, 'modified');
-  testing.expectEqual('OmodifiedK', cdata.data);
-
-  cdata.replaceData('OK'.length-1, 'modified'.length, 'replaced');
-  testing.expectEqual('OreplacedK', cdata.data);
-
-  testing.expectEqual('replaced', cdata.substringData('OK'.length-1, 'replaced'.length));
-  testing.expectEqual('', cdata.substringData('OK'.length-1, 0));
-
-  testing.expectEqual('replaced', cdata.substringData('OK'.length-1, 'replaced'.length));
-  testing.expectEqual('', cdata.substringData('OK'.length-1, 0));
-</script>
diff --git a/src/browser/tests/legacy/dom/comment.html b/src/browser/tests/legacy/dom/comment.html
deleted file mode 100644
index 2f87846c..00000000
--- a/src/browser/tests/legacy/dom/comment.html
+++ /dev/null
@@ -1,9 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-<script id=comment>
-  let comment = new Comment('foo');
-  testing.expectEqual('foo', comment.data);
-
-  let empty = new Comment()
-  testing.expectEqual('', empty.data);
-</script>
diff --git a/src/browser/tests/legacy/dom/document.html b/src/browser/tests/legacy/dom/document.html
deleted file mode 100644
index 647ddf19..00000000
--- a/src/browser/tests/legacy/dom/document.html
+++ /dev/null
@@ -1,185 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-
-<div id="content">
-  <a id="a1" href="foo" class="ok">OK</a>
-  <p id="p1" class="ok empty">
-    <span id="s1"></span>
-  </p>
-  <p id="p2"> And</p>
-</div>
-
-<script id=document>
-  testing.expectEqual('Document', document.__proto__.__proto__.constructor.name);
-  testing.expectEqual('Node', document.__proto__.__proto__.__proto__.constructor.name);
-  testing.expectEqual('EventTarget', document.__proto__.__proto__.__proto__.__proto__.constructor.name);
-
-  let newdoc = new Document();
-  testing.expectEqual(null, newdoc.documentElement);
-  testing.expectEqual(0, newdoc.children.length);
-  testing.expectEqual(0, newdoc.getElementsByTagName('*').length);
-  testing.expectEqual(null, newdoc.getElementsByTagName('*').item(0));
-  testing.expectEqual(true, newdoc.inputEncoding === document.inputEncoding);
-  testing.expectEqual(true, newdoc.documentURI === document.documentURI);
-  testing.expectEqual(true, newdoc.URL === document.URL);
-  testing.expectEqual(true, newdoc.compatMode === document.compatMode);
-  testing.expectEqual(true, newdoc.characterSet === document.characterSet);
-  testing.expectEqual(true, newdoc.charset === document.charset);
-
-  testing.expectEqual('HTML', document.documentElement.tagName);
-
-  testing.expectEqual('UTF-8', document.characterSet);
-  testing.expectEqual('UTF-8', document.charset);
-  testing.expectEqual('UTF-8', document.inputEncoding);
-  testing.expectEqual('CSS1Compat', document.compatMode);
-  testing.expectEqual('text/html', document.contentType);
-
-  testing.expectEqual('http://localhost:9589/dom/document.html', document.documentURI);
-  testing.expectEqual('http://localhost:9589/dom/document.html', document.URL);
-
-  testing.expectEqual(document.body, document.activeElement);
-
-  $('#a1').focus();
-  testing.expectEqual($('#a1'), document.activeElement);
-
-  testing.expectEqual(0, document.styleSheets.length);
-</script>
-
-<script id=getElementById>
-  let divById = document.getElementById('content');
-  testing.expectEqual('HTMLDivElement', divById.constructor.name);
-  testing.expectEqual('div', divById.localName);
-</script>
-
-<script id=getElementsByTagName>
-  let byTagName = document.getElementsByTagName('p');
-  testing.expectEqual(2, byTagName.length)
-  testing.expectEqual('p1', byTagName.item(0).id);
-  testing.expectEqual('p2', byTagName.item(1).id);
-
-  let byTagNameAll = document.getElementsByTagName('*');
-  // If you add a script block (or change the HTML in any other way on this
-  // frame), this test will break. Adjust it accordingly.
-  testing.expectEqual(12, byTagNameAll.length);
-  testing.expectEqual('html', byTagNameAll.item(0).localName);
-  testing.expectEqual('SCRIPT', byTagNameAll.item(11).tagName);
-
-  testing.expectEqual('s1', byTagNameAll.namedItem('s1').id);
-</script>
-
-<script id=getElementByClassName>
-  let ok = document.getElementsByClassName('ok');
-  testing.expectEqual(2, ok.length);
-
-  let empty = document.getElementsByClassName('empty');
-  testing.expectEqual(1, empty.length);
-
-  let emptyok = document.getElementsByClassName('empty ok');
-  testing.expectEqual(1, emptyok.length);
-</script>
-
-<script id=createXYZ>
-  var v = document.createDocumentFragment();
-  testing.expectEqual('#document-fragment', v.nodeName);
-
-  v = document.createTextNode('foo');
-  testing.expectEqual('#text', v.nodeName);
-
-  v = document.createAttribute('foo');
-  testing.expectEqual('foo', v.nodeName);
-
-  v = document.createComment('foo');
-  testing.expectEqual('#comment', v.nodeName);
-  v.cloneNode(); // doesn't crash, (I guess that's the point??)
-
-  let pi = document.createProcessingInstruction('foo', 'bar')
-  testing.expectEqual('foo', pi.target);
-  pi.cloneNode(); // doesn't crash (I guess that's the point??)
-</script>
-
-<script id=importNode>
-  let nimp = document.getElementById('content');
-  var v = document.importNode(nimp);
-  testing.expectEqual('DIV', v.nodeName);
-</script>
-
-<script id=children>
-  testing.expectEqual(1, document.children.length);
-  testing.expectEqual('HTML', document.children.item(0).nodeName)
-  testing.expectEqual('HTML', document.firstElementChild.nodeName);
-  testing.expectEqual('HTML', document.lastElementChild.nodeName);
-  testing.expectEqual(1, document.childElementCount);
-
-  let nd = new Document();
-  testing.expectEqual(0, nd.children.length);
-  testing.expectEqual(null, nd.children.item(0));
-  testing.expectEqual(null, nd.firstElementChild);
-  testing.expectEqual(null, nd.lastElementChild);
-  testing.expectEqual(0, nd.childElementCount);
-</script>
-
-<!-- <script id=createElement>
-  let emptydoc = document.createElement('html');
-  emptydoc.prepend(document.createElement('html'));
-
-  let emptydoc2 = document.createElement('html');
-  emptydoc2.append(document.createElement('html'));
-
-  // Not sure what the above are testing, I just copied and pasted them.
-  // Maybe that something doesn't crash?
-  // Adding this so that the test runner doesn't complain;
-  testing.skip();
-</script> -->
-
-<script id=querySelector>
-  testing.expectEqual('HTML', document.querySelector('*').nodeName);
-  testing.expectEqual('content', document.querySelector('#content').id);
-  testing.expectEqual('p1', document.querySelector('#p1').id);
-  testing.expectEqual('a1', document.querySelector('.ok').id);
-  testing.expectEqual('p1', document.querySelector('a ~ p').id);
-  testing.expectEqual('HTML', document.querySelector(':root').nodeName);
-
-  testing.expectEqual(2, document.querySelectorAll('p').length);
-
-  testing.expectEqual([''],
-    Array.from(document.querySelectorAll('#content > p#p1'))
-        .map(row => row.querySelector('span').textContent)
-  );
-
-  testing.expectEqual(0, document.querySelectorAll('.\\:popover-open').length);
-  testing.expectEqual(0, document.querySelectorAll('.foo\\:bar').length);
-</script>
-
-<script id=adoptNode>
-// this test breaks the doc structure, keep it at the end
-  let nadop = document.getElementById('content')
-  var v = document.adoptNode(nadop);
-  testing.expectEqual('DIV', v.nodeName);
-</script>
-
-<script id=adoptedStyleSheets>
-  const acss = document.adoptedStyleSheets;
-  testing.expectEqual(0, acss.length);
-  acss.push(new CSSStyleSheet());
-  testing.expectEqual(1, acss.length);
-</script>
-
-<script id=createEvent>
-  const event = document.createEvent("Event");
-
-  testing.expectEqual(true, event instanceof Event);
-  testing.expectEqual("", event.type);
-
-  const customEvent = document.createEvent("CustomEvent");
-  customEvent.initCustomEvent("hey", false, false);
-
-  testing.expectEqual(true, customEvent instanceof CustomEvent);
-  testing.expectEqual(true, customEvent instanceof Event);
-
-  testing.withError(
-      (err) => {
-          // TODO: Check the error type.
-      },
-      () => document.createEvent("InvalidType"),
-  );
-</script>
diff --git a/src/browser/tests/legacy/dom/document_fragment.html b/src/browser/tests/legacy/dom/document_fragment.html
deleted file mode 100644
index a4b163a4..00000000
--- a/src/browser/tests/legacy/dom/document_fragment.html
+++ /dev/null
@@ -1,34 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-<body></body>
-
-<script id=documentFragment>
-  testing.expectEqual('DocumentFragment', new DocumentFragment().constructor.name);
-
-  const dc1 = new DocumentFragment();
-  testing.expectEqual(true, dc1.isEqualNode(dc1))
-
-  const dc2 = new DocumentFragment();
-  testing.expectEqual(true, dc1.isEqualNode(dc2))
-
-  let f = document.createDocumentFragment();
-  let d = document.createElement('div');
-  testing.expectEqual(0, d.childElementCount);
-
-  d.id = 'x';
-  testing.expectEqual(null, $('#x'));
-
-  f.append(d);
-  testing.expectEqual(1, f.childElementCount)
-  testing.expectEqual('x', f.children[0].id);
-  testing.expectEqual(null, $('#x'));
-
-  document.getElementsByTagName('body')[0].append(f.cloneNode(true));
-  testing.expectEqual(true, $('#x') != null);
-
-  testing.expectEqual(null, document.querySelector('.hello'));
-  testing.expectEqual(0, document.querySelectorAll('.hello').length);
-
-  testing.expectEqual('x', document.querySelector('#x').id);
-  testing.expectEqual(['x'], Array.from(document.querySelectorAll('#x')).map((n) => n.id));
-</script>
diff --git a/src/browser/tests/legacy/dom/document_type.html b/src/browser/tests/legacy/dom/document_type.html
deleted file mode 100644
index ff7cdbc8..00000000
--- a/src/browser/tests/legacy/dom/document_type.html
+++ /dev/null
@@ -1,13 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-<script id=documentType>
-  let dt1 = document.implementation.createDocumentType('qname1', 'pid1', 'sys1');
-  let dt2 = document.implementation.createDocumentType('qname2', 'pid2', 'sys2');
-  let dt3 = document.implementation.createDocumentType('qname1', 'pid1', 'sys1');
-  testing.expectEqual(true, dt1.isEqualNode(dt1));
-  testing.expectEqual(true, dt1.isEqualNode(dt3));
-  testing.expectEqual(false, dt1.isEqualNode(dt2));
-  testing.expectEqual(false, dt2.isEqualNode(dt3));
-  testing.expectEqual(false, dt1.isEqualNode(document));
-  testing.expectEqual(false, document.isEqualNode(dt1));
-</script>
diff --git a/src/browser/tests/legacy/dom/dom_parser.html b/src/browser/tests/legacy/dom/dom_parser.html
deleted file mode 100644
index bf9bec8a..00000000
--- a/src/browser/tests/legacy/dom/dom_parser.html
+++ /dev/null
@@ -1,7 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-<script id=domParser>
-  const dp = new DOMParser();;
-  const parsed = dp.parseFromString('<div>abc</div>', 'text/html');
-  testing.expectEqual('[object HTMLDocument]', parsed.toString());
-</script>
diff --git a/src/browser/tests/legacy/dom/element.html b/src/browser/tests/legacy/dom/element.html
deleted file mode 100644
index 6a7155c8..00000000
--- a/src/browser/tests/legacy/dom/element.html
+++ /dev/null
@@ -1,304 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-
-<div id="content" dir="ltr">
-  <a id="link" href="foo" class="ok">OK</a>
-  <p id="para-empty" class="ok empty">
-    <span id="para-empty-child"></span>
-  </p>
-  <p id="para"> And</p>
-  <!--comment-->
-</div>
-
-<script id=element>
-  let content = document.getElementById('content');
-  testing.expectEqual('http://www.w3.org/1999/xhtml', content.namespaceURI);
-  testing.expectEqual(null, content.prefix);
-  testing.expectEqual('div', content.localName);
-  testing.expectEqual('DIV', content.tagName);
-  testing.expectEqual('content', content.id);
-  testing.expectEqual('ltr', content.dir);
-
-  content.id = 'foo';
-  testing.expectEqual('foo', content.id);
-
-  content.id = 'content';
-  testing.expectEqual('', content.className);
-
-  let p1 = document.getElementById('para-empty');
-  testing.expectEqual('ok empty', p1.className);
-  testing.expectEqual('', p1.dir);
-
-  p1.className = 'foo bar baz';
-  testing.expectEqual('foo bar baz', p1.className);
-
-  p1.className = 'ok empty';
-  testing.expectEqual(2, p1.classList.length);
-</script>
-
-<script id=closest>
-  const el2 = document.createElement('div');
-  el2.id = 'closest';
-  el2.className = 'ok';
-
-  testing.expectEqual(el2, el2.closest('#closest'));
-  testing.expectEqual(el2, el2.closest('.ok'));
-  testing.expectEqual(null, el2.closest('.notok'));
-
-  const sp = document.createElement('span');
-  el2.appendChild(sp);
-  testing.expectEqual(el2, sp.closest('#closest'));
-</script>
-
-<script id=attributes>
-  testing.expectEqual(true, content.hasAttributes());
-  testing.expectEqual(2, content.attributes.length);
-  testing.expectEqual(['id', 'dir'], content.getAttributeNames());
-  testing.expectEqual('content', content.getAttribute('id'));
-  testing.expectEqual('content', content.attributes['id'].value);
-
-  let x = '';
-  for (const attr of content.attributes) {
-    x += attr.name + '=' + attr.value + ',';
-  }
-  testing.expectEqual('id=content,dir=ltr,', x);
-
-  testing.expectEqual(false, content.hasAttribute('foo'));
-  testing.expectEqual(null, content.getAttribute('foo'));
-
-  content.setAttribute('foo', 'bar');
-  testing.expectEqual(true, content.hasAttribute('foo'));
-  testing.expectEqual('bar', content.getAttribute('foo'));
-  testing.expectEqual(['id', 'dir', 'foo'], content.getAttributeNames());
-
-  testing.expectError('InvalidCharacterError: Invalid Character', () => {
-    content.setAttribute('.foo', 'invalid')
-  });
-
-  content.setAttribute('foo', 'baz');
-  testing.expectEqual(true, content.hasAttribute('foo'));
-  testing.expectEqual('baz', content.getAttribute('foo'));
-
-  content.removeAttribute('foo');
-  testing.expectEqual(false, content.hasAttribute('foo'));
-  testing.expectEqual(null, content.getAttribute('foo'));
-
-  let b = document.getElementById('content');
-  testing.expectEqual(true, b.toggleAttribute('foo'));
-  testing.expectEqual(true, b.hasAttribute('foo'));
-  testing.expectEqual('', b.getAttribute('foo'));
-
-  testing.expectEqual(false, b.toggleAttribute('foo'));
-  testing.expectEqual(false, b.hasAttribute('foo'));
-
-  testing.expectEqual(false, document.createElement('a').hasAttributes());
-
-  const div2 = document.createElement('div');
-  div2.innerHTML = '<p id=1 .lit$id=9>a</p>';
-  testing.expectEqual('<p id="1" .lit$id="9">a</p>', div2.innerHTML);
-  testing.expectEqual(['id', '.lit$id'], div2.childNodes[0].getAttributeNames());
-</script>
-
-<script id=children>
-  testing.expectEqual(3, content.children.length);
-  testing.expectEqual('A', content.firstElementChild.nodeName);
-  testing.expectEqual('P', content.lastElementChild.nodeName);
-  testing.expectEqual(3, content.childElementCount);
-</script>
-
-<script id=sibling>
-  content.prepend(document.createTextNode('foo'));
-  content.append(document.createTextNode('bar'));
-
-  let d = document.getElementById('para');
-  testing.expectEqual('P', d.previousElementSibling.nodeName);
-  testing.expectEqual(null, d.nextElementSibling);
-</script>
-
-<script id=querySelector>
-  testing.expectEqual(null, content.querySelector('foo'));
-  testing.expectEqual(null, content.querySelector('#foo'));
-  testing.expectEqual('link', content.querySelector('#link').id);
-  testing.expectEqual('para', content.querySelector('#para').id);
-  testing.expectEqual('link', content.querySelector('*').id);
-  testing.expectEqual('link', content.querySelector('*').id);
-  testing.expectEqual(null, content.querySelector('#content'));
-  testing.expectEqual('para', content.querySelector('#para').id);
-  testing.expectEqual('link', content.querySelector('.ok').id);
-  testing.expectEqual('para-empty', content.querySelector('a ~ p').id);
-
-  testing.expectEqual(0, content.querySelectorAll('foo').length);
-  testing.expectEqual(0, content.querySelectorAll('#foo').length);
-  testing.expectEqual(1, content.querySelectorAll('#link').length);
-  testing.expectEqual('link', content.querySelectorAll('#link').item(0).id);
-  testing.expectEqual(1, content.querySelectorAll('#para').length);
-  testing.expectEqual('para', content.querySelectorAll('#para').item(0).id);
-  testing.expectEqual(4, content.querySelectorAll('*').length);
-  testing.expectEqual(2, content.querySelectorAll('p').length);
-  testing.expectEqual('link', content.querySelectorAll('.ok').item(0).id);
-</script>
-
-<script id=createdAttributes>
-  let ff = document.createAttribute('foo');
-  content.setAttributeNode(ff);
-  testing.expectEqual('foo', content.getAttributeNode('foo').name);
-  testing.expectEqual('foo', content.removeAttributeNode(ff).name);
-  testing.expectEqual(null, content.getAttributeNode('bar'));
-</script>
-
-<script id=innerHTML>
-  testing.expectEqual(' And', document.getElementById('para').innerHTML);
-  testing.expectEqual('<span id="para-empty-child"></span>', $('#para-empty').innerHTML.trim());
-
-  let h = $('#para-empty');
-  const prev = h.innerHTML;
-  h.innerHTML = '<p id="hello">hello world</p>';
-  testing.expectEqual('<p id="hello">hello world</p>', h.innerHTML);
-  testing.expectEqual('P', h.firstChild.nodeName);
-  testing.expectEqual('hello', h.firstChild.id);
-  testing.expectEqual('hello world', h.firstChild.textContent);
-
-  h.innerHTML = prev;
-  testing.expectEqual('<span id="para-empty-child"></span>', $('#para-empty').innerHTML.trim());
-  testing.expectEqual('<p id="para"> And</p>', $('#para').outerHTML);
-</script>
-
-<script id=matches>
-  const el = document.createElement('div');
-  el.id = 'matches';
-  el.className = 'ok';
-  testing.expectEqual(true, el.matches('#matches'));
-  testing.expectEqual(true, el.matches('.ok'));
-  testing.expectEqual(false, el.matches('.notok'));
-</script>
-
-<script id=scroll>
-  const el3 = document.createElement('div');
-  el3.scrollIntoViewIfNeeded();
-  el3.scrollIntoViewIfNeeded(false);
-  // doesn't throw is good enough
-  testing.skip();
-</script>
-
-<script id=before>
-  const before_container = document.createElement('div');
-  document.append(before_container);
-
-  const b1 = document.createElement('div');
-  before_container.append(b1);
-
-  const b1_a = document.createElement('p');
-  b1.before(b1_a, 'over 9000');
-  testing.expectEqual('<p></p>over 9000<div></div>', before_container.innerHTML);
-</script>
-
-<script id=after>
-  const after_container = document.createElement('div');
-  document.append(after_container);
-  const a1 = document.createElement('div');
-  after_container.append(a1);
-
-  const a1_a = document.createElement('p');
-  a1.after('over 9000', a1_a);
-  testing.expectEqual('<div></div>over 9000<p></p>', after_container.innerHTML);
-</script>
-
-<script id=getElementsByTagName>
-  var div1 = document.createElement('div');
-  div1.innerHTML = "  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>";
-  testing.expectEqual(1, div1.getElementsByTagName('a').length);
-</script>
-
-<script id=outerHTML>
-  let fc = document.createElement('div')
-  fc.innerHTML = '<script><\/script>';
-  testing.expectEqual('<div><script><\/script></div>', fc.outerHTML);
-
-  fc = document.createElement('div')
-  fc.innerHTML = '<script><\/script><p>hello</p>';
-  testing.expectEqual('<div><script><\/script><p>hello</p></div>', fc.outerHTML);
-</script>
-
-<script id=remove>
-  const rm = document.createElement('div');
-  testing.expectEqual([], rm.getAttributeNames());
-  rm.id = 'to-remove';
-
-  document.getElementsByTagName('body')[0].appendChild(rm);
-  $('#to-remove').remove();
-  testing.expectEqual(null, $('#to-remove'));
-</script>
-
-<script id=elementDir>
-  const divElement = document.createElement("div");
-  // Always initialized with empty string if `dir` attribute not provided.
-  testing.expectEqual("", divElement.dir);
-
-  divElement.dir = "ltr";
-  testing.expectEqual("ltr", divElement.dir);
-
-  divElement.dir = "rtl";
-  testing.expectEqual("rtl", divElement.dir);
-
-  divElement.dir = "auto";
-  testing.expectEqual("auto", divElement.dir);
-</script>
-
-<script id=linkRel>
-  const linkElement = document.createElement("link");
-  // A newly created link element must have it's rel set to empty string.
-  testing.expectEqual("", linkElement.rel);
-
-  linkElement.rel = "stylesheet";
-  testing.expectEqual("stylesheet", linkElement.rel);
-</script>
-
-<!-- This structure will get mutated by insertAdjacentHTML test -->
-<div id="insert-adjacent-html-outer-wrapper">
-    <div id="insert-adjacent-html-inner-wrapper">
-        <span></span>
-        <p>content</p>
-    </div>
-</div>
-
-<script id=insertAdjacentHTML>
-  // Insert "beforeend".
-  const wrapper = $("#insert-adjacent-html-inner-wrapper");
-  wrapper.insertAdjacentHTML("beforeend", "<h1>title</h1>");
-  let newElement = wrapper.lastElementChild;
-  testing.expectEqual("H1", newElement.tagName);
-  testing.expectEqual("title", newElement.innerText);
-
-  // Insert "beforebegin".
-  wrapper.insertAdjacentHTML("beforebegin", "<h2>small title</h2>");
-  newElement = wrapper.previousElementSibling;
-  testing.expectEqual("H2", newElement.tagName);
-  testing.expectEqual("small title", newElement.innerText);
-
-  // Insert "afterend".
-  wrapper.insertAdjacentHTML("afterend", "<div id=\"afterend\">after end</div>");
-  newElement = wrapper.nextElementSibling;
-  testing.expectEqual("DIV", newElement.tagName);
-  testing.expectEqual("after end", newElement.innerText);
-  testing.expectEqual("afterend", newElement.id);
-
-  // Insert "afterbegin".
-  wrapper.insertAdjacentHTML("afterbegin", "<div class=\"afterbegin\">after begin</div><yy></yy>");
-  newElement = wrapper.firstElementChild;
-  testing.expectEqual("DIV", newElement.tagName);
-  testing.expectEqual("after begin", newElement.innerText);
-  testing.expectEqual("afterbegin", newElement.className);
-</script>
-
-<script id=nonBreakingSpace>
-  // Test non-breaking space encoding (critical for React hydration)
-  const div = document.createElement('div');
-  div.innerHTML = 'hello\xa0world';
-  testing.expectEqual('hello\xa0world', div.textContent);
-  testing.expectEqual('hello&nbsp;world', div.innerHTML);
-
-  // Test that outerHTML also encodes non-breaking spaces correctly
-  const p = document.createElement('p');
-  p.textContent = 'XAnge\xa0Privacy';
-  testing.expectEqual('<p>XAnge&nbsp;Privacy</p>', p.outerHTML);
-</script> -->
diff --git a/src/browser/tests/legacy/dom/event_target.html b/src/browser/tests/legacy/dom/event_target.html
deleted file mode 100644
index 68fb8c6b..00000000
--- a/src/browser/tests/legacy/dom/event_target.html
+++ /dev/null
@@ -1,116 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-
-<div id="content"><p id=para></p></div>
-
-<script id=eventTarget>
-  testing.expectEqual('[object EventTarget]', new EventTarget().toString());
-
-  let content = $('#content');
-  let para = $('#para');
-
-  var nb = 0;
-  var evt;
-  var phase;
-  var cur;
-
-  function reset() {
-    nb = 0;
-    evt = undefined;
-    phase = undefined;
-    cur = undefined;
-  }
-
-  function cbk(event) {
-    evt = event;
-    phase = event.eventPhase;
-    cur = event.currentTarget;
-    nb++;
-  }
-
-  content.addEventListener('basic', cbk);
-  content.dispatchEvent(new Event('basic'));
-  testing.expectEqual(1, nb);
-  testing.expectEqual(true, evt instanceof Event);
-  testing.expectEqual('basic', evt.type);
-  testing.expectEqual(2, phase);
-  testing.expectEqual('content', cur.getAttribute('id'));
-
-  reset();
-  para.dispatchEvent(new Event('basic'))
-
-  // handler is not called, no capture, not the targeno bubbling
-  testing.expectEqual(0, nb);
-  testing.expectEqual(undefined, evt);
-
-  reset();
-  content.addEventListener('basic', cbk);
-  content.dispatchEvent(new Event('basic'))
-  testing.expectEqual(1, nb);
-
-  reset();
-  content.addEventListener('basic', cbk, true);
-  content.dispatchEvent(new Event('basic'));
-  testing.expectEqual(2, nb);
-
-  reset()
-  content.removeEventListener('basic', cbk);
-  content.dispatchEvent(new Event('basic'));
-  testing.expectEqual(1, nb);
-
-  reset();
-  content.removeEventListener('basic', cbk, {capture: true});
-  content.dispatchEvent(new Event('basic'));
-  testing.expectEqual(0, nb);
-
-  reset();
-  content.addEventListener('capture', cbk, true);
-  content.dispatchEvent(new Event('capture'));
-  testing.expectEqual(1, nb);
-  testing.expectEqual(true, evt instanceof Event);
-  testing.expectEqual('capture', evt.type);
-  testing.expectEqual(2, phase);
-  testing.expectEqual('content', cur.getAttribute('id'));
-
-  reset();
-  para.dispatchEvent(new Event('capture'));
-  testing.expectEqual(1, nb);
-  testing.expectEqual(true, evt instanceof Event);
-  testing.expectEqual('capture', evt.type);
-  testing.expectEqual(1, phase);
-  testing.expectEqual('content', cur.getAttribute('id'));
-
-  reset();
-  content.addEventListener('bubbles', cbk);
-  content.dispatchEvent(new Event('bubbles', {bubbles: true}));
-  testing.expectEqual(1, nb);
-  testing.expectEqual(true, evt instanceof Event);
-  testing.expectEqual('bubbles', evt.type);
-  testing.expectEqual(2, phase);
-  testing.expectEqual('content', cur.getAttribute('id'));
-
-  reset();
-  para.dispatchEvent(new Event('bubbles', {bubbles: true}));
-  testing.expectEqual(1, nb);
-  testing.expectEqual(true, evt instanceof Event);
-  testing.expectEqual('bubbles', evt.type);
-  testing.expectEqual(3, phase);
-  testing.expectEqual('content', cur.getAttribute('id'));
-
-
-  const obj1 = {
-    calls: 0,
-    handleEvent: function() { this.calls += 1 }
-  };
-  content.addEventListener('he', obj1);
-  content.dispatchEvent(new Event('he'));
-  testing.expectEqual(1, obj1.calls);
-
-  content.removeEventListener('he', obj1);
-  content.dispatchEvent(new Event('he'));
-  testing.expectEqual(1, obj1.calls);
-
-  // doesn't crash on null receiver
-  content.addEventListener('he2', null);
-  content.dispatchEvent(new Event('he2'));
-</script>
diff --git a/src/browser/tests/legacy/dom/exceptions.html b/src/browser/tests/legacy/dom/exceptions.html
deleted file mode 100644
index 654f68ca..00000000
--- a/src/browser/tests/legacy/dom/exceptions.html
+++ /dev/null
@@ -1,39 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-
-<div id="content">
-  <a id="link" href="foo" class="ok">OK</a>
-</div>
-
-<script id=exceptions>
-  let content = $('#content');
-  let link = $('#link');
-
-  testing.withError((err) => {
-    testing.expectEqual(3, err.code);
-    testing.expectEqual('Hierarchy Error', err.message);
-    testing.expectEqual('HierarchyRequestError: Hierarchy Error', err.toString());
-    testing.expectEqual(true, err instanceof DOMException);
-    testing.expectEqual(true, err instanceof Error);
-  }, () => link.appendChild(content));
-</script>
-
-<script id=constructor>
-  let exc0 = new DOMException();
-  testing.expectEqual('Error', exc0.name);
-  testing.expectEqual(0, exc0.code);
-  testing.expectEqual('', exc0.message);
-  testing.expectEqual('Error', exc0.toString());
-
-  let exc1 = new DOMException('Sandwich malfunction');
-  testing.expectEqual('Error', exc1.name);
-  testing.expectEqual(0, exc1.code);
-  testing.expectEqual('Sandwich malfunction', exc1.message);
-  testing.expectEqual('Error: Sandwich malfunction', exc1.toString());
-
-  let exc2 = new DOMException('Caterpillar turned into a butterfly', 'NoModificationAllowedError');
-  testing.expectEqual('NoModificationAllowedError', exc2.name);
-  testing.expectEqual(7, exc2.code);
-  testing.expectEqual('Caterpillar turned into a butterfly', exc2.message);
-  testing.expectEqual('NoModificationAllowedError: Caterpillar turned into a butterfly', exc2.toString());
-</script>
diff --git a/src/browser/tests/legacy/dom/html_collection.html b/src/browser/tests/legacy/dom/html_collection.html
deleted file mode 100644
index 10e3dca2..00000000
--- a/src/browser/tests/legacy/dom/html_collection.html
+++ /dev/null
@@ -1,67 +0,0 @@
-<!DOCTYPE html>
-<body>
-  <div id="content">
-    <a id="link" href="foo" class="ok">OK</a>
-    <p id="para-empty" class="ok empty">
-      <span id="para-empty-child"></span>
-    </p>
-    <p id="para"> And</p>
-    <!--comment-->
-  </div>
-</body>
-
-<script src="../testing.js"></script>
-<script id=caseInsensitive>
-    const Ptags = document.getElementsByTagName('P');
-    testing.expectEqual(2, Ptags.length);
-    testing.expectEqual('p', Ptags.item(0).localName);
-    testing.expectEqual('p', Ptags.item(1).localName);
-</script>
-
-<script id=all>
-  let allTags = document.getElementsByTagName('*');
-  testing.expectEqual(11, allTags.length);
-  testing.expectEqual('html', allTags.item(0).localName);
-  testing.expectEqual('html', allTags.item(0).localName);
-  testing.expectEqual('head', allTags.item(1).localName);
-  testing.expectEqual('html', allTags.item(0).localName);
-  testing.expectEqual('body', allTags.item(2).localName);
-  testing.expectEqual('div', allTags.item(3).localName);
-  testing.expectEqual('p', allTags.item(7).localName);
-  testing.expectEqual('span', allTags.namedItem('para-empty-child').localName);
-
-
-  // array like
-  testing.expectEqual('html', allTags[0].localName);
-  testing.expectEqual('p', allTags[7].localName);
-  testing.expectEqual(undefined, allTags[14]);
-  testing.expectEqual('span', allTags['para-empty-child'].localName);
-  testing.expectEqual(undefined, allTags['foo']);
-</script>
-
-<script id=element>
-  let content = $('#content');
-  testing.expectEqual(4, content.getElementsByTagName('*').length);
-  testing.expectEqual(2, content.getElementsByTagName('p').length);
-  testing.expectEqual(0, content.getElementsByTagName('div').length);
-
-  testing.expectEqual(1, document.children.length);
-  testing.expectEqual(3, content.children.length);
-</script>
-
-<script id=liveness>
-  const ptags = document.getElementsByTagName('p');
-  testing.expectEqual(2, ptags.length);
-  testing.expectEqual(' And', ptags.item(1).textContent);
-
-  let p = document.createElement('p');
-  p.textContent = 'OK live';
-  // hasn't been added, still 2
-  testing.expectEqual(2, ptags.length);
-
-  testing.expectEqual(true, content.appendChild(p) != undefined);
-  testing.expectEqual(3, ptags.length);
-  testing.expectEqual('OK live', ptags.item(2).textContent);
-  testing.expectEqual(true, content.insertBefore(p, $('#para-empty')) != undefined);
-  testing.expectEqual('OK live', ptags.item(0).textContent);
-</script>
diff --git a/src/browser/tests/legacy/dom/implementation.html b/src/browser/tests/legacy/dom/implementation.html
deleted file mode 100644
index 6dcc0838..00000000
--- a/src/browser/tests/legacy/dom/implementation.html
+++ /dev/null
@@ -1,14 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-<script id=implementation>
-  let impl = document.implementation;
-  testing.expectEqual("[object HTMLDocument]", impl.createHTMLDocument().toString());;
-
-  const doc = impl.createHTMLDocument('foo');
-  testing.expectEqual("[object HTMLDocument]", doc.toString());
-  testing.expectEqual("foo", doc.title);
-  testing.expectEqual("[object HTMLBodyElement]", doc.body.toString());
-  testing.expectEqual("[object XMLDocument]", impl.createDocument(null, 'foo').toString());
-  testing.expectEqual("[object DocumentType]", impl.createDocumentType('foo', 'bar', 'baz').toString());
-  testing.expectEqual(true, impl.hasFeature());
-</script>
diff --git a/src/browser/tests/legacy/dom/intersection_observer.html b/src/browser/tests/legacy/dom/intersection_observer.html
deleted file mode 100644
index d569894f..00000000
--- a/src/browser/tests/legacy/dom/intersection_observer.html
+++ /dev/null
@@ -1,163 +0,0 @@
-<!DOCTYPE html>
-<body></body>
-<script src="../testing.js"></script>
-
-<script id=intersectionObserver>
-  {
-    // never attached
-    let count = 0;
-    const div = document.createElement('div');
-    new IntersectionObserver((entries) => {
-      count += 1;
-    }).observe(div);
-
-    testing.onload(() => {
-      testing.expectEqual(0, count);
-    });
-  }
-
-  {
-    // not connected, but has parent
-    let count = 0;
-    const div1 = document.createElement('div');
-    const div2 = document.createElement('div');
-    new IntersectionObserver((entries) => {
-      console.log(entries[0]);
-      count += 1;
-    }).observe(div1);
-
-    div2.appendChild(div1);
-    testing.onload(() => {
-      testing.expectEqual(1, count);
-    });
-  }
-</script>
-
-<script id=reobserve>
-  {
-    let count = 0;
-    let observer = new IntersectionObserver(entries => {
-      count += entries.length;
-    });
-
-    const div1 = document.createElement('div');
-    document.body.appendChild(div1);
-
-    // cannot fire synchronously, must be on the next tick
-    testing.expectEqual(0, count);
-    observer.observe(div1);
-    testing.expectEqual(0, count);
-    observer.observe(div1);
-    observer.observe(div1);
-    testing.expectEqual(0, count);
-
-    testing.onload(() => {
-      testing.expectEqual(1, count);
-    });
-  }
-</script>
-
-<script id=unobserve>
-  {
-    let count = 0;
-    let observer = new IntersectionObserver(entries => {
-      count += entries.length;
-    });
-
-    const div1 = document.createElement('div');
-    document.body.appendChild(div1);
-
-    testing.expectEqual(0, count);
-    observer.observe(div1);
-    testing.expectEqual(0, count);
-    observer.observe(div1);
-    observer.observe(div1);
-    testing.expectEqual(0, count);
-
-    observer.unobserve(div1);
-    testing.onload(() => {
-      testing.expectEqual(0, count);
-    });
-  }
-</script>
-
-<script id=disconnect>
-  {
-    let count = 0;
-    let observer = new IntersectionObserver(entries => {
-      count += entries.length;
-    });
-
-    const div1 = document.createElement('div');
-    document.body.appendChild(div1);
-
-    // cannot fire synchronously, must be on the next tick
-    testing.expectEqual(0, count);
-    observer.observe(div1);
-    testing.expectEqual(0, count);
-    observer.observe(div1);
-    observer.observe(div1);
-    testing.expectEqual(0, count);
-    observer.disconnect();
-
-    testing.onload(() => {
-      testing.expectEqual(0, count);
-    });
-  }
-</script>
-
-<script id=entry>
-  {
-    let entry = null;
-    let observer = new IntersectionObserver(entries => {
-      entry = entries[0];
-    });
-
-    let div1 = document.createElement('div');
-    document.body.appendChild(div1);
-    new IntersectionObserver(entries => { entry = entries[0]; }).observe(div1);
-
-    testing.onload(() => {
-      testing.expectEqual(125, entry.boundingClientRect.x);
-      testing.expectEqual(1, entry.intersectionRatio);
-      testing.expectEqual(125, entry.intersectionRect.x);
-      testing.expectEqual(125, entry.intersectionRect.y);
-      testing.expectEqual(5, entry.intersectionRect.width);
-      testing.expectEqual(5, entry.intersectionRect.height);
-      testing.expectEqual(true, entry.isIntersecting);
-      testing.expectEqual(0, entry.rootBounds.x);
-      testing.expectEqual(0, entry.rootBounds.y);
-      testing.expectEqual(1920, entry.rootBounds.width);
-      testing.expectEqual(1080, entry.rootBounds.height);
-      testing.expectEqual('[object HTMLDivElement]', entry.target.toString());
-    });
-  }
-</script>
-
-<script id=timing>
-  {
-    const capture = [];
-    const observer = new IntersectionObserver(() => {
-      capture.push('callback');
-    });
-
-    const div = document.createElement('div');
-    capture.push('pre-append');
-    document.body.appendChild(div);
-    capture.push('post-append');
-
-    capture.push('pre-observe');
-    observer.observe(div);
-    capture.push('post-observe');
-
-    testing.onload(() => {
-      testing.expectEqual([
-        'pre-append',
-        'post-append',
-        'pre-observe',
-        'post-observe',
-        'callback',
-      ], capture)
-    });
-  }
-</script>
diff --git a/src/browser/tests/legacy/dom/named_node_map.html b/src/browser/tests/legacy/dom/named_node_map.html
deleted file mode 100644
index 7cdcf4b7..00000000
--- a/src/browser/tests/legacy/dom/named_node_map.html
+++ /dev/null
@@ -1,19 +0,0 @@
-<!DOCTYPE html>
-<div id="content"></div>
-
-<script src="../testing.js"></script>
-<script id=namedNodeMap>
-  let a = document.getElementById('content').attributes;
-  testing.expectEqual(1, a.length);
-  testing.expectEqual('[object Attr]', a.item(0).toString());
-  testing.expectEqual(null, a.item(1));
-  testing.expectEqual('[object Attr]', a.getNamedItem('id').toString());
-  testing.expectEqual(null, a.getNamedItem('foo'));
-  testing.expectEqual('[object Attr]', a.setNamedItem(a.getNamedItem('id')).toString());
-
-  testing.expectEqual('id', a['id'].name);
-  testing.expectEqual('content', a['id'].value);
-  testing.expectEqual(undefined, a['other']);
-  a[0].value = 'abc123';
-  testing.expectEqual('abc123', a[0].value);
-</script>
diff --git a/src/browser/tests/legacy/dom/node_filter.html b/src/browser/tests/legacy/dom/node_filter.html
deleted file mode 100644
index d5ac95f4..00000000
--- a/src/browser/tests/legacy/dom/node_filter.html
+++ /dev/null
@@ -1,219 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-
-<!-- Test fixture -->
-<div id="container">
-  <!-- comment1 -->
-  <div id="outer">
-    <!-- comment2 -->
-    <span id="inner">
-      <!-- comment3 -->
-      Text content
-      <!-- comment4 -->
-    </span>
-    <!-- comment5 -->
-  </div>
-  <!-- comment6 -->
-</div>
-
-<script id=nodeFilter>
-  testing.expectEqual(1, NodeFilter.FILTER_ACCEPT);
-  testing.expectEqual(2, NodeFilter.FILTER_REJECT);
-  testing.expectEqual(3, NodeFilter.FILTER_SKIP);
-  testing.expectEqual(4294967295, NodeFilter.SHOW_ALL);
-  testing.expectEqual(129, NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_COMMENT);
-</script>
-
-<script id=treeWalkerComments>
-  {
-    const container = $('#container');
-    const walker = document.createTreeWalker(
-      container,
-      NodeFilter.SHOW_COMMENT,
-      null,
-      false
-    );
-
-    const comments = [];
-    let node;
-    while (node = walker.nextNode()) {
-      comments.push(node.data.trim());
-    }
-
-    // Should find all 6 comments, including those nested inside elements
-    testing.expectEqual(6, comments.length);
-    testing.expectEqual('comment1', comments[0]);
-    testing.expectEqual('comment2', comments[1]);
-    testing.expectEqual('comment3', comments[2]);
-    testing.expectEqual('comment4', comments[3]);
-    testing.expectEqual('comment5', comments[4]);
-    testing.expectEqual('comment6', comments[5]);
-  }
-</script>
-
-<script id=treeWalkerElements>
-  {
-    const container = $('#container');
-    const walker = document.createTreeWalker(
-      container,
-      NodeFilter.SHOW_ELEMENT,
-      null,
-      false
-    );
-
-    const elements = [];
-    let node;
-    while (node = walker.nextNode()) {
-      if (node.id) {
-        elements.push(node.id);
-      }
-    }
-
-    // Should find the 2 nested elements (outer and inner)
-    testing.expectEqual(2, elements.length);
-    testing.expectEqual('outer', elements[0]);
-    testing.expectEqual('inner', elements[1]);
-  }
-</script>
-
-<script id=treeWalkerAll>
-  {
-    const container = $('#container');
-    const walker = document.createTreeWalker(
-      container,
-      NodeFilter.SHOW_ALL,
-      null,
-      false
-    );
-
-    let commentCount = 0;
-    let elementCount = 0;
-    let textCount = 0;
-
-    let node;
-    while (node = walker.nextNode()) {
-      if (node.nodeType === 8) commentCount++;      // Comment
-      else if (node.nodeType === 1) elementCount++;  // Element
-      else if (node.nodeType === 3) textCount++;     // Text
-    }
-
-    testing.expectEqual(6, commentCount);
-    testing.expectEqual(2, elementCount);
-    testing.expectEqual(true, textCount > 0);
-  }
-</script>
-
-<script id=treeWalkerCombined>
-  {
-    const container = $('#container');
-    const walker = document.createTreeWalker(
-      container,
-      NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_COMMENT,
-      null,
-      false
-    );
-
-    let commentCount = 0;
-    let elementCount = 0;
-
-    let node;
-    while (node = walker.nextNode()) {
-      if (node.nodeType === 8) commentCount++;      // Comment
-      else if (node.nodeType === 1) elementCount++;  // Element
-    }
-
-    // Should find 6 comments and 2 elements, but no text nodes
-    testing.expectEqual(6, commentCount);
-    testing.expectEqual(2, elementCount);
-  }
-</script>
-
-<script id=treeWalkerCustomFilter>
-  {
-    const container = $('#container');
-
-    // Filter that accepts only elements with id
-    const walker = document.createTreeWalker(
-      container,
-      NodeFilter.SHOW_ELEMENT,
-      {
-        acceptNode: function(node) {
-          return node.id ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
-        }
-      },
-      false
-    );
-
-    const elements = [];
-    let node;
-    while (node = walker.nextNode()) {
-      elements.push(node.id);
-    }
-
-    // Should find only elements with id (outer and inner)
-    testing.expectEqual(2, elements.length);
-    testing.expectEqual('outer', elements[0]);
-    testing.expectEqual('inner', elements[1]);
-  }
-</script>
-
-<script id=nodeIteratorComments>
-  {
-    const container = $('#container');
-    const iterator = document.createNodeIterator(
-      container,
-      NodeFilter.SHOW_COMMENT,
-      null,
-      false
-    );
-
-    const comments = [];
-    let node;
-    while (node = iterator.nextNode()) {
-      comments.push(node.data.trim());
-    }
-
-    // Should find all 6 comments, including those nested inside elements
-    testing.expectEqual(6, comments.length);
-    testing.expectEqual('comment1', comments[0]);
-    testing.expectEqual('comment2', comments[1]);
-    testing.expectEqual('comment3', comments[2]);
-    testing.expectEqual('comment4', comments[3]);
-    testing.expectEqual('comment5', comments[4]);
-    testing.expectEqual('comment6', comments[5]);
-  }
-</script>
-
-<script id=reactLikeScenario>
-  {
-    // Test a React-like scenario with comment markers
-    const div = document.createElement('div');
-    div.innerHTML = `
-      <a href="/">
-        <!--$-->
-        <svg viewBox="0 0 10 10">
-          <path d="M0,0 L10,10" />
-        </svg>
-        <!--/$-->
-      </a>
-    `;
-
-    const walker = document.createTreeWalker(
-      div,
-      NodeFilter.SHOW_COMMENT,
-      null,
-      false
-    );
-
-    const comments = [];
-    let node;
-    while (node = walker.nextNode()) {
-      comments.push(node.data);
-    }
-
-    // Should find both React markers even though they're nested inside <a>
-    testing.expectEqual(2, comments.length);
-    testing.expectEqual('$', comments[0]);
-    testing.expectEqual('/$', comments[1]);
-  }
-</script>
diff --git a/src/browser/tests/legacy/dom/node_list.html b/src/browser/tests/legacy/dom/node_list.html
deleted file mode 100644
index 911b8aa8..00000000
--- a/src/browser/tests/legacy/dom/node_list.html
+++ /dev/null
@@ -1,19 +0,0 @@
-<!DOCTYPE html>
-<div id="content">
-  <a id="link" href="foo" class="ok">OK</a>
-  <p id="para-empty" class="ok empty">
-    <span id="para-empty-child"></span>
-  </p>
-  <p id="para"> And</p>
-  <!--comment-->
-</div>
-
-<script src="../testing.js"></script>
-<script id=nodeList>
-  let list = document.getElementById('content').childNodes;
-  testing.expectEqual(9, list.length);
-  testing.expectEqual('Text', list[0].__proto__.constructor.name);
-  let i = 0;
-  list.forEach(function (n, idx) { i += idx; });
-  testing.expectEqual(36, i);
-</script>
diff --git a/src/browser/tests/legacy/dom/node_owner.html b/src/browser/tests/legacy/dom/node_owner.html
deleted file mode 100644
index 0aec74c5..00000000
--- a/src/browser/tests/legacy/dom/node_owner.html
+++ /dev/null
@@ -1,34 +0,0 @@
-<!DOCTYPE html>
-<div id="target-container">
-  <p id="reference-node">
-  I am the original reference node.
-  </p>
-</div>
-
-<script src="../testing.js"></script>
-<script id=nodeOwner>
-  const parser = new DOMParser();
-  const newDoc = parser.parseFromString('<div id="new-node"><p>Hey</p><span>Marked</span></div>', 'text/html');
-  const newNode = newDoc.getElementById('new-node');
-  const parent = $('#target-container');
-  const referenceNode = $('#reference-node');
-
-  parent.insertBefore(newNode, referenceNode);
-  const k = $('#new-node');
-  const ptag = k.querySelector('p');
-  const spanTag = k.querySelector('span');
-  const anotherDoc = parser.parseFromString('<div id="another-new-node"></div>', 'text/html');
-  const anotherNewNode = anotherDoc.getElementById('another-new-node');
-  testing.expectEqual('[object HTMLDivElement]', parent.appendChild(anotherNewNode).toString());
-
-
-  testing.expectEqual(newNode.ownerDocument, parent.ownerDocument);
-  testing.expectEqual(anotherNewNode.ownerDocument, parent.ownerDocument);
-  testing.expectEqual('P', newNode.firstChild.nodeName);
-  testing.expectEqual(parent.ownerDocument, ptag.ownerDocument);
-  testing.expectEqual(parent.ownerDocument, spanTag.ownerDocument);
-  testing.expectEqual(true, parent.contains(newNode));
-  testing.expectEqual(true, parent.contains(anotherNewNode));
-  testing.expectEqual(false, anotherDoc.contains(anotherNewNode));
-  testing.expectEqual(false, newDoc.contains(newNode));
-</script>
diff --git a/src/browser/tests/legacy/dom/performance.html b/src/browser/tests/legacy/dom/performance.html
deleted file mode 100644
index 0fbfe6fd..00000000
--- a/src/browser/tests/legacy/dom/performance.html
+++ /dev/null
@@ -1,16 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-<script id=performance>
-  let performance = window.performance;
-  testing.expectEqual(true, performance instanceof Performance);
-
-  let mark1 = performance.mark("start");
-  testing.expectEqual(true, mark1 instanceof PerformanceMark);
-  testing.expectEqual('start', mark1.name);
-  testing.expectEqual('mark', mark1.entryType);
-  testing.expectEqual(0, mark1.duration);
-  testing.expectEqual(null, mark1.detail);
-
-  let mark2 = performance.mark("start", {startTime: 32939393.9});
-  testing.expectEqual(32939393.9, mark2.startTime);
-</script>
diff --git a/src/browser/tests/legacy/dom/performance_observer.html b/src/browser/tests/legacy/dom/performance_observer.html
deleted file mode 100644
index 303fc15f..00000000
--- a/src/browser/tests/legacy/dom/performance_observer.html
+++ /dev/null
@@ -1,5 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-<script id=performanceObserver>
-  testing.expectEqual(0, PerformanceObserver.supportedEntryTypes.length);
-</script>
diff --git a/src/browser/tests/legacy/dom/processing_instruction.html b/src/browser/tests/legacy/dom/processing_instruction.html
deleted file mode 100644
index 67bc8fc4..00000000
--- a/src/browser/tests/legacy/dom/processing_instruction.html
+++ /dev/null
@@ -1,22 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-<script id=processingInstruction>
-  let pi = document.createProcessingInstruction('foo', 'bar');
-  testing.expectEqual('foo', pi.target);
-  testing.expectEqual('bar', pi.data);
-  pi.data = 'foo';
-  testing.expectEqual('foo', pi.data);
-
-  let pi2 = pi.cloneNode();
-  testing.expectEqual(7, pi2.nodeType);
-
-  let pi11 = document.createProcessingInstruction('target1', 'data1');
-  let pi12 = document.createProcessingInstruction('target2', 'data2');
-  let pi13 = document.createProcessingInstruction('target1', 'data1');
-  testing.expectEqual(true, pi11.isEqualNode(pi11));
-  testing.expectEqual(true, pi11.isEqualNode(pi13));
-  testing.expectEqual(false, pi11.isEqualNode(pi12));
-  testing.expectEqual(false, pi12.isEqualNode(pi13));
-  testing.expectEqual(false, pi11.isEqualNode(document));
-  testing.expectEqual(false, document.isEqualNode(pi11));
-</script>
diff --git a/src/browser/tests/legacy/dom/range.html b/src/browser/tests/legacy/dom/range.html
deleted file mode 100644
index a60862ca..00000000
--- a/src/browser/tests/legacy/dom/range.html
+++ /dev/null
@@ -1,41 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-
-<div id=content><!-- hello world --><p>over 9000</p></div>
-
-<script id="constructor">
-  let range = new Range();
-  testing.expectEqual(true, range instanceof Range);
-  testing.expectEqual(true, range instanceof AbstractRange);
-
-// Test initial state - collapsed range
-  testing.expectEqual(true, range.collapsed);
-  testing.expectEqual(0, range.startOffset);
-  testing.expectEqual(0, range.endOffset);
-  testing.expectEqual(true, range.startContainer instanceof HTMLDocument);
-  testing.expectEqual(true, range.endContainer instanceof HTMLDocument);
-</script>
-
-<script id="createRange">
-  let docRange = document.createRange();
-  testing.expectEqual(true, docRange instanceof Range);
-  testing.expectEqual(true, docRange.collapsed);
-</script>
-
-<script id=textRange>
-  const container = $('#content');
-  const commentNode = container.childNodes[0];
-  testing.expectEqual(' hello world ', commentNode.nodeValue);
-
-  const textRange = document.createRange();
-  textRange.selectNodeContents(commentNode);
-  testing.expectEqual(0, textRange.startOffset);
-  testing.expectEqual(13, textRange.endOffset); // length of comment
-</script>
-
-<script id=nodeRange>
-  const nodeRange = document.createRange();
-  nodeRange.selectNodeContents(container);
-  testing.expectEqual(0, nodeRange.startOffset);
-  testing.expectEqual(2, nodeRange.endOffset); // length of container.childNodes
-</script>
diff --git a/src/browser/tests/legacy/dom/text.html b/src/browser/tests/legacy/dom/text.html
deleted file mode 100644
index d7ceba08..00000000
--- a/src/browser/tests/legacy/dom/text.html
+++ /dev/null
@@ -1,19 +0,0 @@
-<!DOCTYPE html>
-<a id="link" href="foo" class="ok">OK</a>
-
-<script src="../testing.js"></script>
-<script id=text>
-  let t = new Text('foo');
-  testing.expectEqual('foo', t.data);
-
-  let emptyt = new Text();
-  testing.expectEqual('', emptyt.data);
-
-  let text = $('#link').firstChild;
-  testing.expectEqual('OK', text.wholeText);
-
-  text.data = 'OK modified';
-  let split = text.splitText('OK'.length);
-  testing.expectEqual(' modified', split.data);
-  testing.expectEqual('OK', text.data);
-</script>
diff --git a/src/browser/tests/legacy/dom/token_list.html b/src/browser/tests/legacy/dom/token_list.html
deleted file mode 100644
index b04d5658..00000000
--- a/src/browser/tests/legacy/dom/token_list.html
+++ /dev/null
@@ -1,64 +0,0 @@
-<!DOCTYPE html>
-<p id="para-empty" class="ok empty">
-
-<script src="../testing.js"></script>
-<script id=tokenList>
-  let gs = $('#para-empty');
-
-  let cl = gs.classList;
-  testing.expectEqual('ok empty', gs.className);
-  testing.expectEqual('ok empty', cl.value);
-  testing.expectEqual(2, cl.length);
-
-  gs.className = 'foo bar baz';
-  testing.expectEqual('foo bar baz', gs.className);
-  testing.expectEqual(3, cl.length);
-
-  gs.className = 'ok empty';
-  testing.expectEqual(2, cl.length);
-
-  let cl2 = gs.classList;
-  testing.expectEqual(2, cl2.length);
-  testing.expectEqual('ok', cl2.item(0));
-  testing.expectEqual('empty', cl2.item(1));
-  testing.expectEqual(true, cl2.contains('ok'));
-  testing.expectEqual(false, cl2.contains('nok'));
-
-  cl2.add('foo', 'bar', 'baz');
-  testing.expectEqual(5, cl2.length);
-
-  cl2.remove('foo', 'bar', 'baz');
-  testing.expectEqual(2, cl2.length);
-
-  let cl3 = gs.classList;
-  testing.expectEqual(false, cl3.toggle('ok'));
-  testing.expectEqual(true, cl3.toggle('ok'));
-  testing.expectEqual(2, cl3.length);
-
-  let cl4 = gs.classList;
-  testing.expectEqual(true, cl4.replace('ok', 'nok'));
-  testing.expectEqual("empty nok", cl4.value);
-  testing.expectEqual(true, cl4.replace('nok', 'ok'));
-  testing.expectEqual("empty ok", cl4.value);
-
-  let cl5 = gs.classList;
-  let keys = [...cl5.keys()];
-  testing.expectEqual(2, keys.length);
-  testing.expectEqual(0, keys[0]);
-  testing.expectEqual(1, keys[1]);
-
-  let values = [...cl5.values()];
-  testing.expectEqual(2, values.length);
-  testing.expectEqual('empty', values[0]);
-  testing.expectEqual('ok', values[1]);
-
-  let entries = [...cl5.entries()];
-  testing.expectEqual(2, entries.length);
-  testing.expectEqual([0, 'empty'], entries[0]);
-  testing.expectEqual([1, 'ok'], entries[1]);
-
-  let cl6 = gs.classList;
-  cl6.value = 'a  b  ccc';
-  testing.expectEqual('a  b  ccc', cl6.value);
-  testing.expectEqual('a  b  ccc', cl6.toString());
-</script>
diff --git a/src/browser/tests/legacy/encoding/decoder.html b/src/browser/tests/legacy/encoding/decoder.html
deleted file mode 100644
index 8a93dc46..00000000
--- a/src/browser/tests/legacy/encoding/decoder.html
+++ /dev/null
@@ -1,60 +0,0 @@
-<!DOCTYPE html>
-<meta charset="UTF-8">
-
-<script src="../testing.js"></script>
-<script id=decoder>
-  let d1 = new TextDecoder();
-  testing.expectEqual('utf-8', d1.encoding);
-  testing.expectEqual(false, d1.fatal);
-  testing.expectEqual(false, d1.ignoreBOM);
-
-  testing.expectEqual('', d1.decode());
-  testing.expectEqual('𠮷', d1.decode(new Uint8Array([240, 160, 174, 183])));
-  testing.expectEqual('𠮷', d1.decode(new Uint8Array([0xEF, 0xBB, 0xBF, 240, 160, 174, 183])));
-  testing.expectEqual('�2', d1.decode(new Uint8Array([249, 50])));
-
-  {
-    const buffer = new ArrayBuffer(4);
-    const ints = new Uint8Array(buffer)
-    ints[0] = 240;
-    ints[1] = 160;
-    ints[2] = 174;
-    ints[3] = 183;
-    testing.expectEqual('𠮷', d1.decode(buffer));
-  }
-
-  {
-    const buffer = new ArrayBuffer(4);
-    const dv = new DataView(buffer);
-    dv.setUint8(0, 240);
-    dv.setUint8(1, 160);
-    dv.setUint8(2, 174);
-    dv.setUint8(3, 183);
-    testing.expectEqual('𠮷', d1.decode(dv));
-  }
-
-  let d2 = new TextDecoder('utf8', {fatal: true})
-  testing.expectError('Error: InvalidUtf8', () => {
-    let data  = new Uint8Array([240, 240, 160, 174, 183]);
-    d2.decode(data);
-  });
-</script>
-
-<script id=stream>
-  let d3 = new TextDecoder();
-  testing.expectEqual('', d2.decode(new Uint8Array([226, 153]), { stream: true }));
-  testing.expectEqual('♥', d2.decode(new Uint8Array([165]), { stream: true }));
-</script>
-
-<script id=slice>
-    const buf1 = new ArrayBuffer(7);
-    const arr1 = new Uint8Array(buf1)
-    arr1[0] = 80;
-    arr1[1] = 81;
-    arr1[2] = 82;
-    arr1[3] = 83;
-    arr1[4] = 84;
-    arr1[5] = 85;
-    arr1[6] = 86;
-    testing.expectEqual('RST', d3.decode(new Uint8Array(buf1, 2, 3)));
-</script>
diff --git a/src/browser/tests/legacy/encoding/encoder.html b/src/browser/tests/legacy/encoding/encoder.html
deleted file mode 100644
index affcd575..00000000
--- a/src/browser/tests/legacy/encoding/encoder.html
+++ /dev/null
@@ -1,14 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-<script id=encoder>
-  var encoder = new TextEncoder();
-  testing.expectEqual('utf-8', encoder.encoding);
-  testing.expectEqual([226, 130, 172], Array.from(encoder.encode('€')));
-
-  // Invalid utf-8 sequence.
-  // Browsers give a different result for this, they decode it to:
-  //    50, 50, 54, 44, 52, 48, 44, 49, 54, 49
-  testing.expectError('Error: InvalidUtf8', () => {
-    encoder.encode(new Uint8Array([0xE2,0x28,0xA1]));
-  });
-</script>
diff --git a/src/browser/tests/legacy/events/composition.html b/src/browser/tests/legacy/events/composition.html
deleted file mode 100644
index b5a6a710..00000000
--- a/src/browser/tests/legacy/events/composition.html
+++ /dev/null
@@ -1,36 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-
-<script id=noNata>
-  {
-    let event = new CompositionEvent("test", {});
-    testing.expectEqual(true, event instanceof CompositionEvent);
-    testing.expectEqual(true, event instanceof Event);
-
-    testing.expectEqual("test", event.type);
-    testing.expectEqual("", event.data);
-  }
-</script>
-
-<script id=withData>
-  {
-    let event = new CompositionEvent("test2", {data: "over 9000!"});
-    testing.expectEqual("test2", event.type);
-    testing.expectEqual("over 9000!", event.data);
-  }
-</script>
-
-<script id=dispatch>
-  {
-    let called = 0;
-    document.addEventListener('CE', (e) => {
-      testing.expectEqual('test-data', e.data);
-      testing.expectEqual(true, e instanceof CompositionEvent);
-      called += 1
-    });
-
-    document.dispatchEvent(new CompositionEvent('CE', {data: 'test-data'}));
-    testing.expectEqual(1, called);
-  }
-</script>
-
diff --git a/src/browser/tests/legacy/events/custom.html b/src/browser/tests/legacy/events/custom.html
deleted file mode 100644
index cb6ddd2b..00000000
--- a/src/browser/tests/legacy/events/custom.html
+++ /dev/null
@@ -1,25 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-<script id=custom>
-  let capture = null;
-  const el = document.createElement('div');
-  el.addEventListener('c1', (e) => { capture = 'c1-' + new String(e.detail)});
-  el.addEventListener('c2', (e) => { capture = 'c2-' + new String(e.detail.over)});
-
-  el.dispatchEvent(new CustomEvent('c1'));
-  testing.expectEqual("c1-null", capture);
-
-  el.dispatchEvent(new CustomEvent('c1', {detail: '123'}));
-  testing.expectEqual("c1-123", capture);
-
-  el.dispatchEvent(new CustomEvent('c2', {detail: {over: 9000}}));
-  testing.expectEqual("c2-9000", capture);
-
-  let window_calls = 0;
-  window.addEventListener('c1', () => {
-    window_calls += 1;
-  });
-
-  el.dispatchEvent(new CustomEvent('c1', {bubbles: true}));
-  testing.expectEqual(1, window_calls);
-</script>
diff --git a/src/browser/tests/legacy/events/event.html b/src/browser/tests/legacy/events/event.html
deleted file mode 100644
index d6bbe80f..00000000
--- a/src/browser/tests/legacy/events/event.html
+++ /dev/null
@@ -1,139 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-
-<div id=content>
-  <p id="para"></p>
-</div>
-
-<script id=dispatch>
-  const startTime =  new Event('x').timeStamp;
-
-  let content = $('#content');
-  // let para = document.getElementById('para');
-  var nb = 0;
-  var evt = null;
-
-  const incrementCallback = function(e) {
-    evt = e;
-    nb += 1;
-    e.preventDefault();
-  }
-
-  content.addEventListener('dispatch', incrementCallback);
-
-  content.dispatchEvent(new Event('dispatch', {bubbles: true, cancelable: true}));
-  testing.expectEqual(1, nb);
-  testing.expectEqual(content, evt.target);
-  testing.expectEqual(true, evt.bubbles);
-  testing.expectEqual(true, evt.cancelable);
-  testing.expectEqual(true, evt.defaultPrevented);
-  testing.expectEqual(false, evt.isTrusted);
-  testing.expectEqual(true, evt.timeStamp >= Math.floor(startTime));
-</script>
-
-<script id=propagate>
-  nb = 0;
-  let para = $('#para');
-  // the stop listener is capturing, so it propagates down
-  content.addEventListener('stop',function(e) {
-    e.stopPropagation();
-    nb += 1;
-   }, true)
-
-  para.addEventListener('stop',function(e) {
-    nb += 10;
-  });
-
-  para.dispatchEvent(new Event('stop'));
-  // didn't propagate down (because of capturing) to para handler
-  testing.expectEqual(1, nb);
-</script>
-
-<script id=immediate>
-  nb = 0;
-
-  content.addEventListener('immediate', function(e) {
-    e.stopImmediatePropagation();
-    nb += 1;
-  });
-
-  // the following event listener will not be invoked
-  content.addEventListener('immediate', function(e) {
-    nb += 10;
-  });
-
-  content.dispatchEvent(new Event('immediate'));
-  testing.expectEqual(1, nb);
-</script>
-
-<script id=legacy>
-  nb = 0;
-  content.addEventListener('legacy', incrementCallback);
-  let evtLegacy = document.createEvent('Event');
-  evtLegacy.initEvent('legacy');
-  content.dispatchEvent(evtLegacy);
-  testing.expectEqual(1, nb);
-</script>
-
-<script id=removeListener>
-  nb = 0;
-  document.addEventListener('count', incrementCallback);
-  document.removeEventListener('count', incrementCallback);
-  document.dispatchEvent(new Event('count'));
-  testing.expectEqual(0, nb);
-</script>
-
-<script id=once>
-  document.addEventListener('count', incrementCallback, {once: true});
-  document.dispatchEvent(new Event('count'));
-  document.dispatchEvent(new Event('count'));
-  document.dispatchEvent(new Event('count'));
-  testing.expectEqual(1, nb);
-</script>
-
-<script id=abortController>
-  nb = 0;
-
-  let ac = new AbortController()
-  document.addEventListener('count', incrementCallback, {signal: ac.signal})
-  document.dispatchEvent(new Event('count'));
-  document.dispatchEvent(new Event('count'));
-  ac.abort();
-  document.dispatchEvent(new Event('count'));
-  testing.expectEqual(2, nb);
-  document.removeEventListener('count', incrementCallback);
-</script>
-
-<script id=composedPath>
-  testing.expectEqual([], new Event('').composedPath());
-
-  let div1 = document.createElement('div');
-  let sr1 = div1.attachShadow({mode: 'open'});
-  sr1.innerHTML = "<p id=srp1></p>";
-  document.getElementsByTagName('body')[0].appendChild(div1);
-
-  let cp = null;
-  const shadowCallback = function(e) {
-    cp = e.composedPath().map((n) => n.id || n.nodeName || n.toString());
-  }
-
-  div1.addEventListener('click', shadowCallback);
-  sr1.getElementById('srp1').click();
-  testing.expectEqual(
-    ['srp1', '#document-fragment', 'DIV', 'BODY', 'HTML', '#document', '[object Window]'],
-    cp
-  );
-
-  let div2 = document.createElement('div');
-  let sr2 = div2.attachShadow({mode: 'closed'});
-  sr2.innerHTML = "<p id=srp2></p>";
-  document.getElementsByTagName('body')[0].appendChild(div2);
-
-  cp = null;
-  div2.addEventListener('click', shadowCallback);
-  sr2.getElementById('srp2').click();
-  testing.expectEqual(
-    ['DIV', 'BODY', 'HTML', '#document', '[object Window]'],
-    cp
-  );
-</script>
diff --git a/src/browser/tests/legacy/events/keyboard.html b/src/browser/tests/legacy/events/keyboard.html
deleted file mode 100644
index e76de57f..00000000
--- a/src/browser/tests/legacy/events/keyboard.html
+++ /dev/null
@@ -1,88 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-
-<script id=default>
-  let event = new KeyboardEvent("test", { key: "a" });
-  testing.expectEqual(true, event instanceof KeyboardEvent);
-  testing.expectEqual(true, event instanceof Event);
-
-  testing.expectEqual("test", event.type);
-  testing.expectEqual("a", event.key);
-
-  testing.expectEqual(0, event.location);
-  testing.expectEqual(false, event.repeat);
-  testing.expectEqual(false, event.isComposing);
-
-  testing.expectEqual(false, event.ctrlKey);
-  testing.expectEqual(false, event.shiftKey);
-  testing.expectEqual(false, event.metaKey);
-  testing.expectEqual(false, event.altKey);
-</script>
-
-<script id=getModifierState>
-  event = new KeyboardEvent("test", {
-    altKey: true,
-    shiftKey: true,
-    metaKey: true,
-    ctrlKey: true,
-  });
-
-  testing.expectEqual(true, event.getModifierState("Alt"));
-  testing.expectEqual(true, event.getModifierState("AltGraph"));
-  testing.expectEqual(true, event.getModifierState("Control"));
-  testing.expectEqual(true, event.getModifierState("Shift"));
-  testing.expectEqual(true, event.getModifierState("Meta"));
-  testing.expectEqual(false, event.getModifierState("OS"));
-  testing.expectEqual(true, event.getModifierState("Accel"));
-</script>
-
-<script id=keyDownListener>
-  event = new KeyboardEvent("keydown", { key: "z" });
-  let isKeyDown = false;
-
-  document.addEventListener("keydown", (e) => {
-    isKeyDown = true;
-
-    testing.expectEqual(true, e instanceof KeyboardEvent);
-    testing.expectEqual(true, e instanceof Event);
-    testing.expectEqual("z", event.key);
-  });
-
-  document.dispatchEvent(event);
-
-  testing.expectEqual(true, isKeyDown);
-</script>
-
-<script id=keyUpListener>
-  event = new KeyboardEvent("keyup", { key: "x" });
-  let isKeyUp = false;
-
-  document.addEventListener("keyup", (e) => {
-    isKeyUp = true;
-
-    testing.expectEqual(true, e instanceof KeyboardEvent);
-    testing.expectEqual(true, e instanceof Event);
-    testing.expectEqual("x", event.key);
-  });
-
-  document.dispatchEvent(event);
-
-  testing.expectEqual(true, isKeyUp);
-</script>
-
-<script id=keyPressListener>
-  event = new KeyboardEvent("keypress", { key: "w" });
-  let isKeyPress = false;
-
-  document.addEventListener("keypress", (e) => {
-    isKeyPress = true;
-
-    testing.expectEqual(true, e instanceof KeyboardEvent);
-    testing.expectEqual(true, e instanceof Event);
-    testing.expectEqual("w", event.key);
-  });
-
-  document.dispatchEvent(event);
-
-  testing.expectEqual(true, isKeyPress);
-</script>
diff --git a/src/browser/tests/legacy/events/mouse.html b/src/browser/tests/legacy/events/mouse.html
deleted file mode 100644
index 230bf188..00000000
--- a/src/browser/tests/legacy/events/mouse.html
+++ /dev/null
@@ -1,34 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-<script id=default>
-  let event = new MouseEvent('click');
-  testing.expectEqual('click', event.type);
-  testing.expectEqual(true, event instanceof MouseEvent);
-  testing.expectEqual(true, event instanceof Event);
-  testing.expectEqual(0, event.clientX);
-  testing.expectEqual(0, event.clientY);
-  testing.expectEqual(0, event.screenX);
-  testing.expectEqual(0, event.screenY);
-</script>
-
-<script id=parameters>
-  let new_event = new MouseEvent('click', { 'button': 0, 'clientX': 10, 'clientY': 20 });
-  testing.expectEqual(0, new_event.button);
-  testing.expectEqual(10, new_event.x);
-  testing.expectEqual(20, new_event.y);
-  testing.expectEqual(0, new_event.screenX);
-  testing.expectEqual(0, new_event.screenY);
-</script>
-
-<script id=listener>
-  let me = new MouseEvent('click');
-  testing.expectEqual(true, me instanceof Event);
-
-  var evt = null;
-  document.addEventListener('click', function (e) {
-    evt = e;
-  });
-  document.dispatchEvent(me);
-  testing.expectEqual('click', evt.type);
-  testing.expectEqual(true, evt instanceof MouseEvent);
-</script>
diff --git a/src/browser/tests/legacy/fetch/fetch.html b/src/browser/tests/legacy/fetch/fetch.html
deleted file mode 100644
index d6649860..00000000
--- a/src/browser/tests/legacy/fetch/fetch.html
+++ /dev/null
@@ -1,34 +0,0 @@
-<script src="../testing.js"></script>
-<script id=fetch type=module>
-  const promise1 = new Promise((resolve) => {
-    fetch('http://127.0.0.1:9589/xhr/json')
-    .then((res) => {
-      testing.expectEqual('cors', res.type);
-      return res.json()
-    })
-    .then((json) => {
-      resolve(json);
-    });
-  });
-
-  testing.async(promise1, (json) => {
-    testing.expectEqual({over: '9000!!!'}, json);
-  });
-</script>
-
-<script id=same-origin type=module>
-  const promise1 = new Promise((resolve) => {
-    fetch('http://localhost:9589/xhr/json')
-    .then((res) => {
-      testing.expectEqual('basic', res.type);
-      return res.json()
-    })
-    .then((json) => {
-      resolve(json);
-    });
-  });
-
-  testing.async(promise1, (json) => {
-    testing.expectEqual({over: '9000!!!'}, json);
-  });
-</script>
diff --git a/src/browser/tests/legacy/fetch/headers.html b/src/browser/tests/legacy/fetch/headers.html
deleted file mode 100644
index 0626ad3d..00000000
--- a/src/browser/tests/legacy/fetch/headers.html
+++ /dev/null
@@ -1,103 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-
-<script id=headers>
-  let headers = new Headers({"Set-Cookie": "name=world"});
-  testing.expectEqual("name=world", headers.get("set-cookie"));
-
-  let myHeaders = new Headers();
-  myHeaders.append("Content-Type", "image/jpeg"),
-  testing.expectEqual(false, myHeaders.has("Picture-Type"));
-  testing.expectEqual("image/jpeg", myHeaders.get("Content-Type"));
-
-  myHeaders.append("Content-Type", "image/png");
-  testing.expectEqual("image/jpeg, image/png", myHeaders.get("Content-Type"));
-
-  myHeaders.delete("Content-Type");
-  testing.expectEqual(null, myHeaders.get("Content-Type"));
-
-  myHeaders.set("Picture-Type", "image/svg")
-  testing.expectEqual("image/svg", myHeaders.get("Picture-Type"));
-  testing.expectEqual(true, myHeaders.has("Picture-Type"))
-
-  const originalHeaders = new Headers([["Content-Type", "application/json"], ["Authorization", "Bearer token123"]]);
-  testing.expectEqual("application/json", originalHeaders.get("Content-Type"));
-  testing.expectEqual("Bearer token123", originalHeaders.get("Authorization"));
-
-  const newHeaders = new Headers(originalHeaders);
-  testing.expectEqual("application/json", newHeaders.get("Content-Type"));
-  testing.expectEqual("Bearer token123" ,newHeaders.get("Authorization"));
-  testing.expectEqual(true ,newHeaders.has("Content-Type"));
-  testing.expectEqual(true ,newHeaders.has("Authorization"));
-  testing.expectEqual(false, newHeaders.has("X-Custom"));
-
-  newHeaders.set("X-Custom", "test-value");
-  testing.expectEqual("test-value", newHeaders.get("X-Custom"));
-  testing.expectEqual(null, originalHeaders.get("X-Custom"));
-  testing.expectEqual(false, originalHeaders.has("X-Custom"));
-</script>
-
-<script id=keys>
-  const testKeyHeaders = new Headers();
-  testKeyHeaders.set("Content-Type", "application/json");
-  testKeyHeaders.set("Authorization", "Bearer token123");
-  testKeyHeaders.set("X-Custom", "test-value");
-
-  const keys = [];
-  for (const key of testKeyHeaders.keys()) {
-      keys.push(key);
-  }
-
-  testing.expectEqual(3, keys.length);
-  testing.expectEqual(true, keys.includes("content-type"));
-  testing.expectEqual(true, keys.includes("authorization"));
-  testing.expectEqual(true, keys.includes("x-custom"));
-</script>
-
-<script id=values>
-  const testValuesHeaders = new Headers();
-  testValuesHeaders.set("Content-Type", "application/json");
-  testValuesHeaders.set("Authorization", "Bearer token123");
-  testValuesHeaders.set("X-Custom", "test-value");
-
-  const values = [];
-  for (const value of testValuesHeaders.values()) {
-      values.push(value);
-  }
-
-  testing.expectEqual(3, values.length);
-  testing.expectEqual(true, values.includes("application/json"));
-  testing.expectEqual(true, values.includes("Bearer token123"));
-  testing.expectEqual(true, values.includes("test-value"));
-</script>
-
-<script id=entries>
-  const testEntriesHeaders = new Headers();
-  testEntriesHeaders.set("Content-Type", "application/json");
-  testEntriesHeaders.set("Authorization", "Bearer token123");
-  testEntriesHeaders.set("X-Custom", "test-value");
-
-  const entries = [];
-  for (const entry of testEntriesHeaders.entries()) {
-      entries.push(entry);
-  }
-        
-  testing.expectEqual(3, entries.length);
-
-  const entryMap = new Map(entries);
-  testing.expectEqual("application/json", entryMap.get("content-type"));
-  testing.expectEqual("Bearer token123", entryMap.get("authorization"));
-  testing.expectEqual("test-value", entryMap.get("x-custom"));
-  
-  const entryKeys = Array.from(entryMap.keys());
-  testing.expectEqual(3, entryKeys.length);
-  testing.expectEqual(true, entryKeys.includes("content-type"));
-  testing.expectEqual(true, entryKeys.includes("authorization"));
-  testing.expectEqual(true, entryKeys.includes("x-custom"));
-  
-  const entryValues = Array.from(entryMap.values());
-  testing.expectEqual(3, entryValues.length);
-  testing.expectEqual(true, entryValues.includes("application/json"));
-  testing.expectEqual(true, entryValues.includes("Bearer token123"));
-  testing.expectEqual(true, entryValues.includes("test-value"))
-</script>
diff --git a/src/browser/tests/legacy/fetch/request.html b/src/browser/tests/legacy/fetch/request.html
deleted file mode 100644
index f3118948..00000000
--- a/src/browser/tests/legacy/fetch/request.html
+++ /dev/null
@@ -1,23 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-
-<script id=request>
-  let request = new Request("flower.png");
-  testing.expectEqual("http://localhost:9589/fetch/flower.png", request.url);
-  testing.expectEqual("GET", request.method);
-
-  let request2 = new Request("https://google.com", {
-    method: "POST",
-    body: "Hello, World",
-    cache: "reload",
-    credentials: "omit",
-    headers: { "Sender": "me", "Target": "you" }
-    }
-  );
-  testing.expectEqual("https://google.com", request2.url);
-  testing.expectEqual("POST", request2.method);
-  testing.expectEqual("omit", request2.credentials);
-  testing.expectEqual("reload", request2.cache);
-  testing.expectEqual("me", request2.headers.get("SeNdEr"));
-  testing.expectEqual("you", request2.headers.get("target"));
-</script>
diff --git a/src/browser/tests/legacy/fetch/response.html b/src/browser/tests/legacy/fetch/response.html
deleted file mode 100644
index ef49a260..00000000
--- a/src/browser/tests/legacy/fetch/response.html
+++ /dev/null
@@ -1,51 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-
-<script id=response>
-  let response = new Response("Hello, World!");
-  testing.expectEqual(200, response.status);
-  testing.expectEqual("", response.statusText);
-  testing.expectEqual(true, response.ok);
-  testing.expectEqual("", response.url);
-  testing.expectEqual(false, response.redirected);
-
-  let response2 = new Response("Error occurred", {
-    status: 404,
-    statusText: "Not Found",
-    headers: {
-        "Content-Type": "text/plain",
-        "X-Custom": "test-value",
-        "Cache-Control": "no-cache"
-    }
-  });
-  testing.expectEqual(404, response2.status);
-  testing.expectEqual("Not Found", response2.statusText);
-  testing.expectEqual(false, response2.ok);
-  testing.expectEqual("text/plain", response2.headers.get("Content-Type"));
-  testing.expectEqual("test-value", response2.headers.get("X-Custom"));
-  testing.expectEqual("no-cache", response2.headers.get("cache-control"));
-        
-  let response3 = new Response("Created", { status: 201, statusText: "Created" });
-  testing.expectEqual("basic", response3.type);
-  testing.expectEqual(201, response3.status);
-  testing.expectEqual("Created", response3.statusText);
-  testing.expectEqual(true, response3.ok);
-
-  let nullResponse = new Response(null);
-  testing.expectEqual(200, nullResponse.status);
-  testing.expectEqual("", nullResponse.statusText);
-
-  let emptyResponse = new Response("");
-  testing.expectEqual(200, emptyResponse.status);
-</script>
-
-<script id=json type=module>
-  const promise1 = new Promise((resolve) => {
-    let response = new Response('[]');
-    response.json().then(resolve)
-  });
-
-  testing.async(promise1, (json) => {
-    testing.expectEqual([], json);
-  });
-</script>
diff --git a/src/browser/tests/legacy/file/blob.html b/src/browser/tests/legacy/file/blob.html
deleted file mode 100644
index 343fd32b..00000000
--- a/src/browser/tests/legacy/file/blob.html
+++ /dev/null
@@ -1,125 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-
-<script id=Blob/Blob.text>
-  {
-    const parts = ["\r\nthe quick brown\rfo\rx\r", "\njumps over\r\nthe\nlazy\r", "\ndog"];
-    // "transparent" ending should not modify the final buffer.
-    const blob = new Blob(parts, { type: "text/html" });
-
-    const expected = parts.join("");
-    testing.expectEqual(expected.length, blob.size);
-    testing.expectEqual("text/html", blob.type);
-    testing.async(blob.text(), result => testing.expectEqual(expected, result));
-  }
-
-  {
-    const parts = ["\rhello\r", "\nwor\r\nld"];
-    // "native" ending should modify the final buffer.
-    const blob = new Blob(parts, { endings: "native" });
-
-    const expected = "\nhello\n\nwor\nld";
-    testing.expectEqual(expected.length, blob.size);
-    testing.async(blob.text(), result => testing.expectEqual(expected, result));
-
-    testing.async(blob.arrayBuffer(), result => testing.expectEqual(true, result instanceof ArrayBuffer));
-  }
-</script>
-
-<script id=Blob.stream>
-  {
-    const parts = ["may", "thy", "knife", "chip", "and", "shatter"];
-    const blob = new Blob(parts);
-    const reader = blob.stream().getReader();
-
-    testing.async(reader.read(), ({ done, value }) => {
-      const expected = new Uint8Array([109, 97, 121, 116, 104, 121, 107, 110,
-                                       105, 102, 101, 99, 104, 105, 112, 97,
-                                       110, 100, 115, 104, 97, 116, 116, 101,
-                                       114]);
-      testing.expectEqual(false, done);
-      testing.expectEqual(true, value instanceof Uint8Array);
-      testing.expectEqual(expected, value);
-    });
-  }
-</script>
-
-<script id=Blob.arrayBuffer/Blob.slice>
-  {
-    const parts = ["la", "symphonie", "des", "éclairs"];
-    const blob = new Blob(parts);
-    testing.async(blob.arrayBuffer(), result => testing.expectEqual(true, result instanceof ArrayBuffer));
-
-    let temp = blob.slice(0);
-    testing.expectEqual(blob.size, temp.size);
-    testing.async(temp.text(), result => {
-      testing.expectEqual("lasymphoniedeséclairs", result);
-    });
-
-    temp = blob.slice(-4, -2, "custom");
-    testing.expectEqual(2, temp.size);
-    testing.expectEqual("custom", temp.type);
-    testing.async(temp.text(), result => testing.expectEqual("ai", result));
-
-    temp = blob.slice(14);
-    testing.expectEqual(8, temp.size);
-    testing.async(temp.text(), result => testing.expectEqual("éclairs", result));
-
-    temp = blob.slice(6, -10, "text/eclair");
-    testing.expectEqual(6, temp.size);
-    testing.expectEqual("text/eclair", temp.type);
-    testing.async(temp.text(), result => testing.expectEqual("honied", result));
-  }
-</script>
-
-<!-- Firefox and Safari only -->
-<script id=Blob.bytes>
-  {
-    const parts = ["light ", "panda ", "rocks ", "!"];
-    const blob = new Blob(parts);
-
-    testing.async(blob.bytes(), result => {
-      const expected = new Uint8Array([108, 105, 103, 104, 116, 32, 112, 97,
-                                       110, 100, 97, 32, 114, 111, 99, 107, 115,
-                                       32, 33]);
-      testing.expectEqual(true, result instanceof Uint8Array);
-      testing.expectEqual(expected, result);
-    });
-  }
-
-  // Test for SIMD.
-  {
-    const parts = [
-      "\rThe opened package\r\nof potato\nchi\rps",
-      "held the\r\nanswer to the\r mystery. Both det\rectives looke\r\rd\r",
-      "\rat it but failed to realize\nit was\r\nthe\rkey\r\n",
-      "\r\nto solve the \rcrime.\r"
-    ];
-
-    const blob = new Blob(parts, { type: "text/html", endings: "native" });
-    testing.expectEqual(161, blob.size);
-    testing.expectEqual("text/html", blob.type);
-    testing.async(blob.bytes(), result => {
-      const expected = new Uint8Array([10, 84, 104, 101, 32, 111, 112, 101, 110,
-                                       101, 100, 32, 112, 97, 99, 107, 97, 103,
-                                       101, 10, 111, 102, 32, 112, 111, 116, 97,
-                                       116, 111, 10, 99, 104, 105, 10, 112, 115,
-                                       104, 101, 108, 100, 32, 116, 104, 101, 10,
-                                       97, 110, 115, 119, 101, 114, 32, 116, 111,
-                                       32, 116, 104, 101, 10, 32, 109, 121, 115,
-                                       116, 101, 114, 121, 46, 32, 66, 111, 116,
-                                       104, 32, 100, 101, 116, 10, 101, 99, 116,
-                                       105, 118, 101, 115, 32, 108, 111, 111, 107,
-                                       101, 10, 10, 100, 10, 10, 97, 116, 32, 105,
-                                       116, 32, 98, 117, 116, 32, 102, 97, 105, 108,
-                                       101, 100, 32, 116, 111, 32, 114, 101, 97,
-                                       108, 105, 122, 101, 10, 105, 116, 32, 119, 97,
-                                       115, 10, 116, 104, 101, 10, 107, 101, 121,
-                                       10, 10, 116, 111, 32, 115, 111, 108, 118, 101,
-                                       32, 116, 104, 101, 32, 10, 99, 114, 105, 109,
-                                       101, 46, 10]);
-      testing.expectEqual(true, result instanceof Uint8Array);
-      testing.expectEqual(expected, result);
-    });
-  }
-</script>
diff --git a/src/browser/tests/legacy/file/file.html b/src/browser/tests/legacy/file/file.html
deleted file mode 100644
index 05f23ad7..00000000
--- a/src/browser/tests/legacy/file/file.html
+++ /dev/null
@@ -1,7 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-
-<script id=file>
-  let f = new File();
-  testing.expectEqual(true, f instanceof File);
-</script>
diff --git a/src/browser/tests/legacy/html/abort_controller.html b/src/browser/tests/legacy/html/abort_controller.html
deleted file mode 100644
index 5f9f0ee0..00000000
--- a/src/browser/tests/legacy/html/abort_controller.html
+++ /dev/null
@@ -1,41 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-
-<script id=abortController>
-  var a1 = new AbortController();
-
-  var s1 = a1.signal;
-  testing.expectEqual(undefined, s1.throwIfAborted());
-  testing.expectEqual(undefined, s1.reason);
-
-  let target;;
-  let called = 0;
-  s1.addEventListener('abort', (e) => {
-    called += 1;
-    target = e.target;
-  });
-
-  a1.abort();
-  testing.expectEqual(true, s1.aborted)
-  testing.expectEqual(s1, target)
-  testing.expectEqual('AbortError', s1.reason)
-  testing.expectEqual(1, called)
-</script>
-
-<script id=abort>
-  var s2 = AbortSignal.abort('over 9000');
-  testing.expectEqual(true, s2.aborted);
-  testing.expectEqual('over 9000', s2.reason);
-  testing.expectEqual('AbortError', AbortSignal.abort().reason);
-</script>
-
-<script id=timeout>
-  var s3 = AbortSignal.timeout(10);
-  testing.onload(() => {
-    testing.expectEqual(true, s3.aborted);
-    testing.expectEqual('TimeoutError', s3.reason);
-    testing.expectError('Error: TimeoutError', () => {
-      s3.throwIfAborted()
-    });
-  });
-</script>
diff --git a/src/browser/tests/legacy/html/canvas.html b/src/browser/tests/legacy/html/canvas.html
deleted file mode 100644
index ed1980eb..00000000
--- a/src/browser/tests/legacy/html/canvas.html
+++ /dev/null
@@ -1,13 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-
-<script id=canvas>
-{
-  const element = document.createElement("canvas");
-  const ctx = element.getContext("2d");
-  testing.expectEqual(true, ctx instanceof CanvasRenderingContext2D);
-  // We can't really test this but let's try to call it at least.
-  ctx.fillRect(0, 0, 0, 0);
-}
-</script>
-
diff --git a/src/browser/tests/legacy/html/dataset.html b/src/browser/tests/legacy/html/dataset.html
deleted file mode 100644
index 8eff6927..00000000
--- a/src/browser/tests/legacy/html/dataset.html
+++ /dev/null
@@ -1,30 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-<div id=x data-power="over 9000" data-empty data-some-long-key=ok></div>
-
-<script id=dataset>
-  let el1 = document.createElement('div');
-  testing.expectEqual(undefined, el1.dataset.x);
-
-  el1.dataset.x = '123';
-  testing.expectEqual(true, delete el1.dataset.x);
-  testing.expectEqual(undefined, el1.dataset.x);
-  // yes, this is right
-  testing.expectEqual(true, delete el1.dataset.other);
-
-  let ds1 = el1.dataset;
-  ds1.helloWorld = 'yes';
-  testing.expectEqual('yes', el1.getAttribute('data-hello-world'));
-  el1.setAttribute('data-this-will-work', 'positive');
-  testing.expectEqual('positive', ds1.thisWillWork);
-</script>
-
-<script id=element>
-  let div = $('#x');
-  testing.expectEqual(undefined, div.dataset.nope);
-  testing.expectEqual('over 9000', div.dataset.power);
-  testing.expectEqual('', div.dataset.empty);
-  testing.expectEqual('ok', div.dataset.someLongKey);
-  testing.expectEqual(true, delete div.dataset.power);
-  testing.expectEqual(undefined, div.dataset.power);
-</script>
diff --git a/src/browser/tests/legacy/html/document.html b/src/browser/tests/legacy/html/document.html
deleted file mode 100644
index 01e5d76a..00000000
--- a/src/browser/tests/legacy/html/document.html
+++ /dev/null
@@ -1,70 +0,0 @@
-<!DOCTYPE html>
-<html>
-  <body>
-    <div id=content><a id=link href=#></a></div>
-  </body>
-</html>
-
-<script src="../testing.js"></script>
-<applet></applet>
-
-<script id=document>
-  testing.expectEqual('HTMLDocument', document.__proto__.constructor.name);
-  testing.expectEqual('Document', document.__proto__.__proto__.constructor.name);
-  testing.expectEqual('body', document.body.localName);
-
-  testing.expectEqual('localhost', document.domain);
-  testing.expectEqual('', document.referrer);
-  testing.expectEqual('', document.title);
-  testing.expectEqual('body', document.body.localName);
-  testing.expectEqual('head', document.head.localName);
-  testing.expectEqual(0, document.images.length);
-  testing.expectEqual(0, document.embeds.length);
-  testing.expectEqual(0, document.plugins.length);
-  testing.expectEqual(2, document.scripts.length);
-  testing.expectEqual(0, document.forms.length);
-  testing.expectEqual(1, document.links.length);
-  testing.expectEqual(0, document.applets.length); // deprecated, always returns 0
-  testing.expectEqual(0, document.anchors.length);
-  testing.expectEqual(7, document.all.length);
-  testing.expectEqual('document', document.currentScript.id);
-
-  document.title = 'foo';
-  testing.expectEqual('foo', document.title);
-  document.title = '';
-
-  document.getElementById('link').setAttribute('name', 'foo');
-  let list = document.getElementsByName('foo');
-  testing.expectEqual(1, list.length);
-
-  testing.expectEqual('', document.cookie);
-  document.cookie = 'name=Oeschger;';
-  document.cookie = 'favorite_food=tripe;';
-
-  testing.expectEqual('name=Oeschger; favorite_food=tripe', document.cookie);
-  // "" should be returned, but the framework overrules it atm
-  document.cookie = 'IgnoreMy=Ghost; HttpOnly';
-  testing.expectEqual('name=Oeschger; favorite_food=tripe', document.cookie);
-
-  // Return null since we only return elements when they have previously been localized
-  testing.expectEqual(null, document.elementFromPoint(2.5, 2.5));
-  testing.expectEqual([], document.elementsFromPoint(2.5, 2.5));
-
-  let div1 = document.createElement('div');
-  document.body.appendChild(div1);
-  div1.getClientRects(); // clal this to position it
-
-  let a = document.createElement('a');
-  a.href = "https://lightpanda.io";
-  document.body.appendChild(a);
-  // Note this will be placed after the div of previous test
-  a.getClientRects();
-
-  testing.expectEqual(true, !document.all);
-  testing.expectEqual(false, !!document.all);
-  testing.expectEqual('[object HTMLScriptElement]', document.all(6).toString());
-  testing.expectEqual('[object HTMLDivElement]', document.all('content').toString());
-
-  testing.expectEqual(document, document.defaultView.document );
-  testing.expectEqual('loading', document.readyState);
-</script>
diff --git a/src/browser/tests/legacy/html/element.html b/src/browser/tests/legacy/html/element.html
deleted file mode 100644
index d1701ae3..00000000
--- a/src/browser/tests/legacy/html/element.html
+++ /dev/null
@@ -1,53 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-<div id=content>a<strong>b</strong>cc</div>
-<script id=inner>
-  const content = $('#content');
-  testing.expectEqual('a<strong>b</strong>cc', content.innerHTML);
-  testing.expectEqual('abcc', content.innerText);
-  content. innerText = 'foo';
-
-  testing.expectEqual('foo', content.innerHTML);
-  testing.expectEqual('foo', content.innerText);
-</script>
-
-<script id=addEventListene>
-  let click_count = 0;
-  content.addEventListener('click', function() { click_count++ });
-  content.click()
-  testing.expectEqual(1, click_count);
-</script>
-
-<script id=style>
-  let style = content.style;
-  style.cssText = 'color: red; font-size: 12px; margin: 5px !important';
-  testing.expectEqual(3, style.length);
-  style.setProperty('background-color', 'blue')
-  testing.expectEqual('blue', style.getPropertyValue('background-color'));
-  testing.expectEqual(4, style.length);
-</script>
-
-<script id=a>
-  let a = document.createElement('a');
-  testing.expectEqual('', a.href);
-  testing.expectEqual('', a.host);
-  a.href = 'about';
-  testing.expectEqual('http://localhost:9589/html/about', a.href);
-</script>
-
-<script id=focus>
-  // detached node cannot be focused
-  const focused = document.activeElement;
-  document.createElement('a').focus();
-  testing.expectEqual(focused, document.activeElement);
-</script>
-
-<script id=link>
-  let l2 = document.createElement('link');
-  testing.expectEqual('', l2.href);
-  l2.href = 'https://lightpanda.io/opensource-browser/15';
-  testing.expectEqual('https://lightpanda.io/opensource-browser/15', l2.href);
-
-  l2.href = '/over/9000';
-  testing.expectEqual('http://localhost:9589/over/9000', l2.href);
-</script>
diff --git a/src/browser/tests/legacy/html/error_event.html b/src/browser/tests/legacy/html/error_event.html
deleted file mode 100644
index be2c56a4..00000000
--- a/src/browser/tests/legacy/html/error_event.html
+++ /dev/null
@@ -1,25 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-
-<script id=ErrorEvent>
-  let e1 = new ErrorEvent('err1')
-  testing.expectEqual('', e1.message);
-  testing.expectEqual('', e1.filename);
-  testing.expectEqual(0, e1.lineno);
-  testing.expectEqual(0, e1.colno);
-  testing.expectEqual(undefined, e1.error);
-
-  let e2 = new ErrorEvent('err1', {
-     message: 'm1',
-     filename: 'fx19',
-     lineno: 443,
-     colno: 8999,
-     error: 'under 9000!',
-   });
-
-  testing.expectEqual('m1', e2.message);
-  testing.expectEqual('fx19', e2.filename);
-  testing.expectEqual(443, e2.lineno);
-  testing.expectEqual(8999, e2.colno);
-  testing.expectEqual('under 9000!', e2.error);
-</script>
diff --git a/src/browser/tests/legacy/html/history/history.html b/src/browser/tests/legacy/html/history/history.html
deleted file mode 100644
index 3f6d0708..00000000
--- a/src/browser/tests/legacy/html/history/history.html
+++ /dev/null
@@ -1,37 +0,0 @@
-<!DOCTYPE html>
-<script src="../../testing.js"></script>
-
-<script id=history>
-    testing.expectEqual('auto', history.scrollRestoration);
-
-    history.scrollRestoration = 'manual';
-    testing.expectEqual('manual', history.scrollRestoration);
-
-    history.scrollRestoration = 'auto';
-    testing.expectEqual('auto', history.scrollRestoration);
-    testing.expectEqual(null, history.state)
-
-    history.pushState({ testInProgress: true }, null, 'http://127.0.0.1:9589/html/history/history_after_nav.skip.html');
-    testing.expectEqual({ testInProgress: true }, history.state);
-
-    history.pushState({ testInProgress: false }, null, 'http://127.0.0.1:9589/xhr/json');
-    history.replaceState({ "new": "field", testComplete: true }, null);
-
-    let state = { "new": "field", testComplete: true };
-    testing.expectEqual(state, history.state);
-
-    let popstateEventFired = false;
-    let popstateEventState = null;
-
-    window.addEventListener('popstate', (event) => {
-        popstateEventFired = true;
-        popstateEventState = event.state;
-    });
-
-    testing.onload(() => {
-      testing.expectEqual(true, popstateEventFired);
-      testing.expectEqual(state, popstateEventState);
-    })
-
-    history.back();
-</script>
diff --git a/src/browser/tests/legacy/html/history/history2.html b/src/browser/tests/legacy/html/history/history2.html
deleted file mode 100644
index 89fc73b4..00000000
--- a/src/browser/tests/legacy/html/history/history2.html
+++ /dev/null
@@ -1,23 +0,0 @@
-<!DOCTYPE html>
-<script src="../../testing.js"></script>
-
-<script id=history2>
-    let state = { "new": "field", testComplete: true, testInProgress: true };
-    history.replaceState(state, "");
-    history.pushState(null, null, 'http://127.0.0.1:9589/html/history/history_after_nav.skip.html');
-
-    let popstateEventFired = false;
-    let popstateEventState = null;
-
-    window.onpopstate = (event) => {
-        popstateEventFired = true;
-        popstateEventState = event.state;
-    };
-
-    testing.onload(() => {
-      testing.expectEqual(true, popstateEventFired);
-      testing.expectEqual(state, popstateEventState);
-    })
-
-    history.back();
-</script>
diff --git a/src/browser/tests/legacy/html/history/history_after_nav.skip.html b/src/browser/tests/legacy/html/history/history_after_nav.skip.html
deleted file mode 100644
index 5180b14a..00000000
--- a/src/browser/tests/legacy/html/history/history_after_nav.skip.html
+++ /dev/null
@@ -1,6 +0,0 @@
-<!DOCTYPE html>
-<script src="../../testing.js"></script>
-
-<script id=history-after-nav>
-    testing.expectEqual(true, history.state && history.state.testInProgress);
-</script>
diff --git a/src/browser/tests/legacy/html/image.html b/src/browser/tests/legacy/html/image.html
deleted file mode 100644
index 053b2cfa..00000000
--- a/src/browser/tests/legacy/html/image.html
+++ /dev/null
@@ -1,32 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-
-<script id=image>
-  img = new Image();
-  testing.expectEqual(0, img.width);
-  testing.expectEqual(0, img.height);
-
-  img = new Image(4);
-  testing.expectEqual(4, img.width);
-  testing.expectEqual(0, img.height);
-
-  img = new Image(5, 6);
-  testing.expectEqual(5, img.width);
-  testing.expectEqual(6, img.height);
-
-  let fruit = new Image
-  testing.expectEqual(0, fruit.width);
-  fruit.width = 5;
-  testing.expectEqual(5, fruit.width);
-  fruit.width = '15';
-  testing.expectEqual(15, fruit.width);
-  fruit.width = 'apple';
-  testing.expectEqual(0, fruit.width);
-
-  let lyric = new Image
-  testing.expectEqual('', lyric.src);
-  lyric.src = 'okay';
-  testing.expectEqual('http://localhost:9589/html/okay', lyric.src);
-  lyric.src = 15;
-  testing.expectEqual('http://localhost:9589/html/15', lyric.src);
-</script>
diff --git a/src/browser/tests/legacy/html/input.html b/src/browser/tests/legacy/html/input.html
deleted file mode 100644
index 0232ddbf..00000000
--- a/src/browser/tests/legacy/html/input.html
+++ /dev/null
@@ -1,111 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-
-<form action="test.php" target="_blank" id=form>
-  <p>
-    <label>First name: <input type="text" name="first-name" id=input /></label>
-  </p>
-</form>
-
-<script id=input_properties>
-  let input = document.createElement('input');
-
-  testing.expectEqual(null, input.form);
-  input.form = 'foo';
-  testing.expectEqual(null, input.form);
-
-  testing.expectEqual('', input.name);
-  input.name = 'leto';
-  testing.expectEqual('leto', input.name);
-
-  testing.expectEqual('', input.accept);
-  input.accept = 'anything';
-  testing.expectEqual('anything', input.accept);
-
-  testing.expectEqual('', input.alt);
-  input.alt = 'x1';
-  testing.expectEqual('x1', input.alt);
-
-  testing.expectEqual(false, input.disabled);
-  input.disabled = true;
-  testing.expectEqual(true, input.disabled);
-  input.disabled = false;
-  testing.expectEqual(false, input.disabled);
-
-  testing.expectEqual(false, input.readOnly);
-  input.readOnly = true;
-  testing.expectEqual(true, input.readOnly);
-  input.readOnly = false;
-  testing.expectEqual(false, input.readOnly);
-
-  testing.expectEqual(-1, input.maxLength);
-  input.maxLength = 5;
-  testing.expectEqual(5, input.maxLength);
-  input.maxLength = 'banana';
-  testing.expectEqual(0, input.maxLength);
-  testing.expectError('IndexSizeError: Index or size is negative or greater than the allowed amount', () => { input.maxLength = -45;});
-
-  testing.expectEqual(20, input.size);
-  input.size = 5;
-  testing.expectEqual(5, input.size);
-  input.size = -449;
-  testing.expectEqual(20, input.size);
-  testing.expectError('Error: ZeroNotAllowed', () => { input.size = 0; });
-
-  testing.expectEqual('', input.src);
-  input.src = 'foo'
-  testing.expectEqual('http://localhost:9589/html/foo', input.src);
-  input.src = '-3'
-  testing.expectEqual('http://localhost:9589/html/-3', input.src);
-  input.src = ''
-  testing.expectEqual('http://localhost:9589/html/input.html', input.src);
-
-  testing.expectEqual('text', input.type);
-  input.type = 'checkbox';
-  testing.expectEqual('checkbox', input.type);
-  input.type = '5';
-  testing.expectEqual('text', input.type);
-</script>
-
-<script id=related>
-  let input_checked = document.createElement('input')
-  testing.expectEqual(false, input_checked.defaultChecked);
-  testing.expectEqual(false, input_checked.checked);
-
-  input_checked.defaultChecked = true;
-  testing.expectEqual(true, input_checked.defaultChecked);
-  testing.expectEqual(true, input_checked.checked);
-
-  input_checked.checked = false;
-  testing.expectEqual(true, input_checked.defaultChecked);
-  testing.expectEqual(false, input_checked.checked);
-
-  input_checked.defaultChecked = true;
-  testing.expectEqual(false, input_checked.checked);
-</script>
-
-<script id=defaultValue>
-  testing.expectEqual('', input.defaultValue);
-  testing.expectEqual('', input.value);
-
-  input.defaultValue = 3.1;
-  testing.expectEqual('3.1', input.defaultValue);
-  testing.expectEqual('3.1', input.value)
-
-  input.value = 'mango';
-  testing.expectEqual('3.1', input.defaultValue);
-  testing.expectEqual('mango', input.value);
-
-  input.defaultValue = true;
-  testing.expectEqual('mango', input.value);
-</script>
-
-<script id=form>
-  const form = $('#form');
-  input = $('#input');
-  testing.expectEqual(form, input.form);
-
-  // invalid
-  input.form = 'foo';
-  testing.expectEqual(form, input.form);
-</script>
diff --git a/src/browser/tests/legacy/html/link.html b/src/browser/tests/legacy/html/link.html
deleted file mode 100644
index 95869052..00000000
--- a/src/browser/tests/legacy/html/link.html
+++ /dev/null
@@ -1,60 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-<a id=link href=foo>OK</a>
-
-<script id=link>
-  let link = $('#link');
-  testing.expectEqual('', link.target);
-  link.target = '_blank';
-  testing.expectEqual('_blank', link.target);
-  link.target = '';
-
-  testing.expectEqual('http://localhost:9589/html/foo', link.href);
-  link.href = 'https://lightpanda.io/';
-  testing.expectEqual('https://lightpanda.io/', link.href);
-
-  testing.expectEqual('https://lightpanda.io', link.origin);
-
-  link.host = 'lightpanda.io:443';
-  testing.expectEqual('lightpanda.io', link.host);
-  testing.expectEqual('', link.port);
-  testing.expectEqual('lightpanda.io', link.hostname);
-
-  link.host = 'lightpanda.io';
-  testing.expectEqual('lightpanda.io', link.host);
-  testing.expectEqual('', link.port);
-  testing.expectEqual('lightpanda.io', link.hostname);
-
-  testing.expectEqual('lightpanda.io', link.host);
-  testing.expectEqual('lightpanda.io', link.hostname);
-  link.hostname = 'foo.bar';
-  testing.expectEqual('https://foo.bar/', link.href);
-
-  testing.expectEqual('', link.search);
-  link.search = 'q=bar';
-  testing.expectEqual('?q=bar', link.search);
-  testing.expectEqual('https://foo.bar/?q=bar', link.href);
-
-  testing.expectEqual('', link.hash);
-  link.hash = 'frag';
-  testing.expectEqual('#frag', link.hash);
-  testing.expectEqual('https://foo.bar/?q=bar#frag', link.href);
-
-  testing.expectEqual('', link.port);
-  link.port = '443';
-  testing.expectEqual('foo.bar', link.host);
-  testing.expectEqual('foo.bar', link.hostname);
-  testing.expectEqual('https://foo.bar/?q=bar#frag', link.href);
-  link.port = null;
-  testing.expectEqual('https://foo.bar/?q=bar#frag', link.href);
-
-  testing.expectEqual('foo', link.href = 'foo');
-
-  testing.expectEqual('', link.type);
-  link.type = 'text/html';
-  testing.expectEqual('text/html', link.type);
-
-  testing.expectEqual('OK', link.text);
-  link.text = 'foo';
-  testing.expectEqual('foo', link.text);
-</script>
diff --git a/src/browser/tests/legacy/html/location.html b/src/browser/tests/legacy/html/location.html
deleted file mode 100644
index ad49b411..00000000
--- a/src/browser/tests/legacy/html/location.html
+++ /dev/null
@@ -1,33 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-
-<script id=location>
-  testing.expectEqual('http://localhost:9589/html/location.html', location.href);
-  testing.expectEqual('http://localhost:9589/html/location.html', document.location.href);
-
-  testing.expectEqual("localhost:9589", location.host);
-  testing.expectEqual("localhost", location.hostname);
-  testing.expectEqual("http://localhost:9589", location.origin);
-  testing.expectEqual("/html/location.html", location.pathname);
-  testing.expectEqual("", location.hash);
-  testing.expectEqual("9589", location.port);
-  testing.expectEqual("", location.search);
-</script>
-
-<script id=location_hash>
-  location.hash = "";
-  testing.expectEqual("", location.hash);
-  testing.expectEqual('http://localhost:9589/html/location.html', location.href);
-
-  location.hash = "#abcdef";
-  testing.expectEqual("#abcdef", location.hash);
-  testing.expectEqual('http://localhost:9589/html/location.html#abcdef', location.href);
-
-  location.hash = "xyzxyz";
-  testing.expectEqual("#xyzxyz", location.hash);
-  testing.expectEqual('http://localhost:9589/html/location.html#xyzxyz', location.href);
-
-  location.hash = "";
-  testing.expectEqual("", location.hash);
-  testing.expectEqual('http://localhost:9589/html/location.html', location.href);
-</script>
diff --git a/src/browser/tests/legacy/html/navigation/navigation.html b/src/browser/tests/legacy/html/navigation/navigation.html
deleted file mode 100644
index f30b9e8e..00000000
--- a/src/browser/tests/legacy/html/navigation/navigation.html
+++ /dev/null
@@ -1,18 +0,0 @@
-<!DOCTYPE html>
-<script src="../../testing.js"></script>
-
-<script id=navigation>
-    testing.expectEqual('object', typeof navigation);
-    testing.expectEqual('object', typeof navigation.currentEntry);
-
-    testing.expectEqual('string', typeof navigation.currentEntry.id);
-    testing.expectEqual('string', typeof navigation.currentEntry.key);
-    testing.expectEqual('string', typeof navigation.currentEntry.url);
-
-    const currentIndex = navigation.currentEntry.index;
-
-    navigation.navigate(
-        'http://localhost:9589/html/navigation/navigation_after_nav.skip.html',
-        { state: { currentIndex: currentIndex, navTestInProgress: true } }
-    );
-</script>
diff --git a/src/browser/tests/legacy/html/navigation/navigation_after_nav.skip.html b/src/browser/tests/legacy/html/navigation/navigation_after_nav.skip.html
deleted file mode 100644
index e55691bb..00000000
--- a/src/browser/tests/legacy/html/navigation/navigation_after_nav.skip.html
+++ /dev/null
@@ -1,8 +0,0 @@
-<!DOCTYPE html>
-<script src="../../testing.js"></script>
-
-<script id=navigation-after-nav>
-    const state = navigation.currentEntry.getState();
-    testing.expectEqual(true, state.navTestInProgress);
-    testing.expectEqual(state.currentIndex + 1, navigation.currentEntry.index);
-</script>
diff --git a/src/browser/tests/legacy/html/navigation/navigation_currententrychange.html b/src/browser/tests/legacy/html/navigation/navigation_currententrychange.html
deleted file mode 100644
index c84bcbad..00000000
--- a/src/browser/tests/legacy/html/navigation/navigation_currententrychange.html
+++ /dev/null
@@ -1,15 +0,0 @@
-<!DOCTYPE html>
-<script src="../../testing.js"></script>
-
-<script id=navigation_currententrychange>
-    let currentEntryChanged = false;
-
-    navigation.addEventListener("currententrychange", () => {
-      currentEntryChanged = true;
-    });
-
-    // Doesn't fully navigate if same document.
-    location.href = location.href + "#1";
-
-    testing.expectEqual(true, currentEntryChanged);
-</script>
diff --git a/src/browser/tests/legacy/html/navigator.html b/src/browser/tests/legacy/html/navigator.html
deleted file mode 100644
index fb2b3ffe..00000000
--- a/src/browser/tests/legacy/html/navigator.html
+++ /dev/null
@@ -1,8 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-
-<script id=navigator>
-  testing.expectEqual('Lightpanda/1.0',  navigator.userAgent);
-  testing.expectEqual('1.0',  navigator.appVersion);
-  testing.expectEqual('en-US',  navigator.language);
-</script>
diff --git a/src/browser/tests/legacy/html/screen.html b/src/browser/tests/legacy/html/screen.html
deleted file mode 100644
index 5239ba43..00000000
--- a/src/browser/tests/legacy/html/screen.html
+++ /dev/null
@@ -1,21 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-
-<script id=screen>
-  let screen = window.screen;
-  testing.expectEqual(1920, screen.width);
-  testing.expectEqual(1080, screen.height);
-
-  let orientation = screen.orientation;
-  testing.expectEqual(0, orientation.angle);
-  testing.expectEqual('landscape-primary', orientation.type);
-
-  // this shouldn't crash (it used to)
-  screen.addEventListener('change', () => {});
-</script>
-
-<script id=orientation>
-  screen.orientation.addEventListener('change', () => {})
-  // above shouldn't crash (it used to)
-  testing.expectEqual(true, true);
-</script>
diff --git a/src/browser/tests/legacy/html/script/dynamic_import.html b/src/browser/tests/legacy/html/script/dynamic_import.html
deleted file mode 100644
index ddaa19a2..00000000
--- a/src/browser/tests/legacy/html/script/dynamic_import.html
+++ /dev/null
@@ -1,32 +0,0 @@
-<!DOCTYPE html>
-
-<script src="../../testing.js"></script>
-
-<script id=dynamic_import type=module>
-  const promise1 = new Promise((resolve) => {
-    Promise.all([
-      import('./import.js'),
-      import('./import.js'),
-      import('./import.js'),
-      import('./import.js'),
-      import('./import.js'),
-      import('./import.js'),
-      import('./import2.js'),
-      import('./import.js'),
-      import('./import.js'),
-    ]).then(resolve);
-  });
-
-  testing.async(promise1, (res) => {
-    testing.expectEqual(9, res.length);
-    testing.expectEqual('hello', res[0].greeting);
-    testing.expectEqual('hello', res[1].greeting);
-    testing.expectEqual('hello', res[2].greeting);
-    testing.expectEqual('hello', res[3].greeting);
-    testing.expectEqual('hello', res[4].greeting);
-    testing.expectEqual('hello', res[5].greeting);
-    testing.expectEqual('world', res[6].greeting);
-    testing.expectEqual('hello', res[7].greeting);
-    testing.expectEqual('hello', res[8].greeting);
-  });
-</script>
diff --git a/src/browser/tests/legacy/html/script/import.html b/src/browser/tests/legacy/html/script/import.html
deleted file mode 100644
index 7a4037af..00000000
--- a/src/browser/tests/legacy/html/script/import.html
+++ /dev/null
@@ -1,15 +0,0 @@
-<!DOCTYPE html>
-
-<script src="../../testing.js"></script>
-
-<script id=import type=module>
-  import * as im from './import.js';
-  testing.expectEqual('hello', im.greeting);
-</script>
-
-<script id=cached type=module>
-  // hopefully cached, who knows, no real way to assert this
-  // but at least it works.
-  import * as im from './import.js';
-  testing.expectEqual('hello', im.greeting);
-</script>
diff --git a/src/browser/tests/legacy/html/script/import.js b/src/browser/tests/legacy/html/script/import.js
deleted file mode 100644
index fb140c03..00000000
--- a/src/browser/tests/legacy/html/script/import.js
+++ /dev/null
@@ -1,2 +0,0 @@
-let greeting = 'hello';
-export {greeting as 'greeting'};
diff --git a/src/browser/tests/legacy/html/script/import2.js b/src/browser/tests/legacy/html/script/import2.js
deleted file mode 100644
index 328b8943..00000000
--- a/src/browser/tests/legacy/html/script/import2.js
+++ /dev/null
@@ -1,2 +0,0 @@
-let greeting = 'world';
-export {greeting as 'greeting'};
diff --git a/src/browser/tests/legacy/html/script/importmap.html b/src/browser/tests/legacy/html/script/importmap.html
deleted file mode 100644
index 973d5080..00000000
--- a/src/browser/tests/legacy/html/script/importmap.html
+++ /dev/null
@@ -1,24 +0,0 @@
-<!DOCTYPE html>
-
-<script src="../../testing.js"></script>
-
-<script type=importmap>
-    {
-      "imports": {
-        "core": "./import.js"
-      }
-    }
-</script>
-
-<script id=use_importmap type=module>
-  import * as im from 'core';
-  testing.expectEqual('hello', im.greeting);
-</script>
-
-<script id=cached_importmap type=module>
-  // hopefully cached, who knows, no real way to assert this
-  // but at least it works.
-  import * as im from 'core';
-  testing.expectEqual('hello', im.greeting);
-</script>
-
diff --git a/src/browser/tests/legacy/html/script/inline_defer.html b/src/browser/tests/legacy/html/script/inline_defer.html
deleted file mode 100644
index 11350032..00000000
--- a/src/browser/tests/legacy/html/script/inline_defer.html
+++ /dev/null
@@ -1,28 +0,0 @@
-<!DOCTYPE html>
-<head>
-  <script>
-    let dyn1_loaded = 0;
-    function loadScript(src) {
-      const script = document.createElement('script');
-      script.src = src;
-      document.getElementsByTagName("head")[0].appendChild(script)
-    }
-  </script>
-</head>
-
-<script src="../../testing.js"></script>
-
-<script defer>
-  loadScript('inline_defer.js');
-</script>
-
-<script async>
-  loadScript('inline_defer.js');
-</script>
-
-<script id=inline_defer>
-  // inline script should ignore defer and async attributes. If we don't do
-  // this correctly, we'd end up in an infinite loop
-  // https://github.com/lightpanda-io/browser/issues/1014
-  testing.onload(() => testing.expectEqual(2, dyn1_loaded));
-</script>
diff --git a/src/browser/tests/legacy/html/script/inline_defer.js b/src/browser/tests/legacy/html/script/inline_defer.js
deleted file mode 100644
index 1e0ee1a4..00000000
--- a/src/browser/tests/legacy/html/script/inline_defer.js
+++ /dev/null
@@ -1 +0,0 @@
-dyn1_loaded += 1;
diff --git a/src/browser/tests/legacy/html/script/order.html b/src/browser/tests/legacy/html/script/order.html
deleted file mode 100644
index 7efbbef3..00000000
--- a/src/browser/tests/legacy/html/script/order.html
+++ /dev/null
@@ -1,35 +0,0 @@
-<!DOCTYPE html>
-<script src="../../testing.js"></script>
-
-<script defer id="remote_defer" src="order_defer.js"></script>
-<script defer id="remote_async" src="order_async.js"></script>
-
-<script type=module id="inline_module">
-    // inline module is always deferred.
-    list += 'g';
-    testing.expectEqual('abcdefg', list);
-</script>
-
-<script>
-    var list = '';
-</script>
-
-<script id="remote" src="order.js"></script>
-
-<script async id="inline_async">
-    // inline script ignore async
-    list += 'b';
-    testing.expectEqual('ab', list);
-</script>
-
-<script defer id="inline_defer">
-    // inline script ignore defer
-    list += 'c';
-    testing.expectEqual('abc', list);
-</script>
-
-<script id="default">
-    // simple inline script
-    list += 'd';
-    testing.expectEqual('abcd', list);
-</script>
diff --git a/src/browser/tests/legacy/html/script/order.js b/src/browser/tests/legacy/html/script/order.js
deleted file mode 100644
index 31e602fc..00000000
--- a/src/browser/tests/legacy/html/script/order.js
+++ /dev/null
@@ -1,2 +0,0 @@
-list += 'a';
-testing.expectEqual('a', list);
diff --git a/src/browser/tests/legacy/html/script/order_async.js b/src/browser/tests/legacy/html/script/order_async.js
deleted file mode 100644
index 97c9adac..00000000
--- a/src/browser/tests/legacy/html/script/order_async.js
+++ /dev/null
@@ -1,3 +0,0 @@
-list += 'f';
-testing.expectEqual('abcdef', list);
-
diff --git a/src/browser/tests/legacy/html/script/order_defer.js b/src/browser/tests/legacy/html/script/order_defer.js
deleted file mode 100644
index 3911b644..00000000
--- a/src/browser/tests/legacy/html/script/order_defer.js
+++ /dev/null
@@ -1,2 +0,0 @@
-list += 'e';
-testing.expectEqual('abcde', list);
diff --git a/src/browser/tests/legacy/html/script/script.html b/src/browser/tests/legacy/html/script/script.html
deleted file mode 100644
index d5910a62..00000000
--- a/src/browser/tests/legacy/html/script/script.html
+++ /dev/null
@@ -1,31 +0,0 @@
-<!DOCTYPE html>
-<script src="../../testing.js"></script>
-
-<script id=script>
-  let script = document.createElement('script')
-  script.src = 'foo.bar';
-
-  script.async = true;
-  testing.expectEqual(true, script.async);
-  script.async = false;
-  testing.expectEqual(false, script.async);
-
-  script.defer = true;
-  testing.expectEqual(true, script.defer);
-
-  testing.expectEqual('', script.nonce);
-  script.nonce = 'hello';
-  testing.expectEqual('hello', script.nonce);
-</script>
-
-<script id=datauri src="data:text/plain;charset=utf-8;base64,dGVzdGluZy5leHBlY3RFcXVhbCh0cnVlLCB0cnVlKTs="></script>
-
-<script id=datauri_url_encoded_text src="data:text/javascript,testing.expectEqual(3, 3);"></script>
-
-<script id=datauri_encoded_padding src="data:text/javascript;base64,dGVzdGluZy5leHBlY3RFcXVhbCgxLCAxKTs%3D"></script>
-
-<script id=datauri_fully_encoded src="data:text/javascript;base64,%64%47%56%7a%64%47%6c%75%5a%79%35%6c%65%48%42%6c%59%33%52%46%63%58%56%68%62%43%67%79%4c%43%41%79%4b%54%73%3d"></script>
-
-<script id=datauri_with_whitespace src="data:text/javascript;base64,%20ZD%20Qg%0D%0APS%20An%20Zm91cic%0D%0A%207%20"></script>
-
-<script id=datauri_url_encoded_unicode src="data:text/javascript,testing.expectEqual(4%2C%204)%3B"></script>
diff --git a/src/browser/tests/legacy/html/select.html b/src/browser/tests/legacy/html/select.html
deleted file mode 100644
index f18dfdab..00000000
--- a/src/browser/tests/legacy/html/select.html
+++ /dev/null
@@ -1,80 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-
-<form id=f1>
- <select id=s1 name=s1><option>o1<option>o2</select>
-</form>
-<select id=s2></select>
-
-<script id=select>
-  const s = document.getElementById('s1');
-  testing.expectEqual('[object HTMLFormElement]', s.form.toString());
-  testing.expectEqual(null, document.getElementById('s2').form);
-
-  testing.expectEqual(false, s.disabled);
-  s.disabled = true;
-  testing.expectEqual(true, s.disabled);
-
-  s.disabled = false;
-  testing.expectEqual(false, s.disabled);
-
-  testing.expectEqual(false, s.multiple);
-  s.multiple = true;
-  testing.expectEqual(true, s.multiple);
-  s.multiple = false;
-  testing.expectEqual(false, s.multiple);
-
-  testing.expectEqual('s1', s.name);
-  s.name = 'sel1';
-  testing.expectEqual('sel1', s.name);
-
-  testing.expectEqual(2, s.length);
-
-  testing.expectEqual(0, s.selectedIndex);
-  s.selectedIndex = 2; // out of range
-  testing.expectEqual(-1, s.selectedIndex);
-
-  s.selectedIndex = -1;
-  testing.expectEqual(-1, s.selectedIndex);
-
-  s.selectedIndex = 0;
-  testing.expectEqual(0, s.selectedIndex);
-
-  s.selectedIndex = 1;
-  testing.expectEqual(1, s.selectedIndex);
-
-  s.selectedIndex = -323;
-  testing.expectEqual(-1, s.selectedIndex);
-
-  let options = s.options;
-  testing.expectEqual(2, options.length);
-  testing.expectEqual('o2', options.item(1).value);
-  testing.expectEqual(-1, options.selectedIndex);
-
-  let o3 = document.createElement('option');
-  o3.value = 'o3';
-  options.add(o3)
-  testing.expectEqual(3, options.length);
-  testing.expectEqual('o3', options[2].value);
-  testing.expectEqual('o3', options.item(2).value);
-
-  let o4 = document.createElement('option');
-  o4.value = 'o4';
-  options.add(o4, 1);
-  testing.expectEqual(4, options.length);
-  testing.expectEqual('o4', options.item(1).value);
-
-  let o5 = document.createElement('option');
-  o5.value = 'o5';
-  options.add(o5, o3)
-  testing.expectEqual(5, options.length);
-  testing.expectEqual('o5', options.item(3).value);
-
-  options.remove(3)
-  testing.expectEqual(4, options.length);
-  testing.expectEqual('o3', options[3].value);
-  testing.expectEqual('o3', options.item(3).value);
-
-  testing.expectEqual(undefined, options[10]);
-  testing.expectEqual(null, options.item(10));
-</script>
diff --git a/src/browser/tests/legacy/html/slot.html b/src/browser/tests/legacy/html/slot.html
deleted file mode 100644
index 36e3bc1f..00000000
--- a/src/browser/tests/legacy/html/slot.html
+++ /dev/null
@@ -1,179 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-<script>
-  class LightPanda extends HTMLElement {
-    constructor() {
-      super();
-    }
-
-    connectedCallback() {
-      const shadow = this.attachShadow({ mode: "open" });
-
-      const slot1 = document.createElement('slot');
-      slot1.name = 'slot-1';
-      shadow.appendChild(slot1);
-
-      switch (this.getAttribute('mode')) {
-        case '1':
-          slot1.innerHTML = 'hello';
-          break;
-        case '2':
-          const slot2 = document.createElement('slot');
-          shadow.appendChild(slot2);
-          break;
-      }
-    }
-  }
-  window.customElements.define("lp-test", LightPanda);
-</script>
-
-<lp-test id=lp1 mode=1></lp-test>
-<lp-test id=lp2 mode=0></lp-test>
-<lp-test id=lp3 mode=0>default</lp-test>
-<lp-test id=lp4 mode=1><p slot=other>default</p></lp-test>
-<lp-test id=lp5 mode=1><p slot=slot-1>default</p> xx <b slot=slot-1>other</b></lp-test>
-<lp-test id=lp6 mode=2>More <p slot=slot-1>default2</p> <span>!!</span></lp-test>
-
-<script>
-  function assertNodes(expected, actual) {
-    actual = actual.map((n) => n.id || n.textContent)
-    testing.expectEqual(expected, actual);
-  }
-</script>
-<script id=HTMLSlotElement>
-  for (let idx of [1, 2, 3, 4]) {
-    const lp = $(`#lp${idx}`);
-    const slot = lp.shadowRoot.querySelector('slot');
-
-    assertNodes([], slot.assignedNodes());
-    assertNodes([], slot.assignedNodes({}));
-    assertNodes([], slot.assignedNodes({flatten: false}));
-    if (lp.getAttribute('mode') === '1') {
-      assertNodes(['hello'], slot.assignedNodes({flatten: true}));
-    } else {
-      assertNodes([], slot.assignedNodes({flatten: true}));
-    }
-  }
-
-  {
-    const lp5 = $('#lp5');
-    const s5 = lp5.shadowRoot.querySelector('slot');
-    assertNodes(['default', 'other'], s5.assignedNodes());
-
-    const lp6 = $('#lp6');
-    const s6 = lp6.shadowRoot.querySelectorAll('slot');
-    assertNodes(['default2'], s6[0].assignedNodes({}));
-    assertNodes(['default2'], s6[0].assignedNodes({flatten: true}));
-    assertNodes(['More ', ' ', '!!'], s6[1].assignedNodes({}));
-    assertNodes(['More ', ' ', '!!'], s6[1].assignedNodes({flatten: true}));
-
-    assertNodes(['default2'], s6[0].assignedElements({}));
-    assertNodes(['default2'], s6[0].assignedElements({flatten: true}));
-    assertNodes(['!!'], s6[1].assignedElements({}));
-    assertNodes(['!!'], s6[1].assignedElements({flatten: true}));
-  }
-</script>
-
-<lp-test id=sc1 mode=1></lp-test>
-<script id=slotChange1>
-  {
-    let calls = 0;
-    const lp = $('#sc1');
-    const slot = lp.shadowRoot.querySelector('slot');
-    slot.addEventListener('slotchange', (e) => {
-      assertNodes(['slotted'], slot.assignedNodes({}));
-      calls += 1
-    }, {});
-
-    const div = document.createElement('div');
-    div.textContent = 'Hello!';
-    div.id = 'slotted';
-    testing.expectEqual(null, div.assignedSlot);
-
-    div.setAttribute('slot', 'slot-1');
-    lp.appendChild(div);
-    testing.expectEqual(slot, div.assignedSlot);
-
-    testing.onload(() => {
-      testing.expectEqual(1, calls)
-    });
-  }
-</script>
-
-<lp-test id=sc2 mode=1><div id=s2 slot=slot-1>hello</div></lp-test>
-<script id=slotChange2>
-  {
-    let calls = 0;
-    const lp = $('#sc2');
-    const slot = lp.shadowRoot.querySelector('slot');
-    slot.addEventListener('slotchange', (e) => {
-      assertNodes([], slot.assignedNodes({}));
-      calls += 1;
-    });
-
-    const div = $('#s2');
-    div.removeAttribute('slot');
-    testing.onload(() => {
-      testing.expectEqual(1, calls)
-    });
-  }
-</script>
-
-<lp-test id=sc3 mode=1><div id=s3 slot=slot-1>hello</div></lp-test>
-<script id=slotChange3>
-  {
-    let calls = 0;
-    const lp = $('#sc3');
-    const slot = lp.shadowRoot.querySelector('slot');
-    slot.addEventListener('slotchange', (e) => {
-      assertNodes([], slot.assignedNodes({}));
-      calls += 1;
-    });
-
-    const div = $('#s3');
-    div.slot = 'other';
-    testing.onload(() => {
-      testing.expectEqual(1, calls)
-    });
-  }
-</script>
-
-<lp-test id=sc4 mode=1></lp-test>
-<script id=slotChange4>
-  {
-    let calls = 0;
-    const lp = $('#sc4');
-    const slot = lp.shadowRoot.querySelector('slot');
-    slot.addEventListener('slotchange', (e) => {
-      assertNodes(['slotted'], slot.assignedNodes({}));
-      calls += 1;
-    });
-
-    const div = document.createElement('div');
-    div.id = 'slotted';
-    div.slot = 'other';
-    lp.appendChild(div);
-    div.slot = 'slot-1'
-    testing.onload(() => {
-      testing.expectEqual(1, calls)
-    });
-  }
-</script>
-
-<lp-test id=sc5 mode=1><div id=s5 slot=slot-1>hello</div></lp-test>
-<script id=slotChange5>
-  {
-    let calls = 0;
-    const lp = $('#sc5');
-    const slot = lp.shadowRoot.querySelector('slot');
-    slot.addEventListener('slotchange', (e) => {
-      assertNodes([], slot.assignedNodes({}));
-      calls += 1;
-    });
-
-    $('#s5').remove();
-    testing.onload(() => {
-      testing.expectEqual(1, calls)
-    });
-  }
-</script>
diff --git a/src/browser/tests/legacy/html/style.html b/src/browser/tests/legacy/html/style.html
deleted file mode 100644
index e92cd3ca..00000000
--- a/src/browser/tests/legacy/html/style.html
+++ /dev/null
@@ -1,6 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-
-<script id=style>
-  testing.expectEqual(null, document.createElement('style').sheet);
-</script>
diff --git a/src/browser/tests/legacy/html/svg.html b/src/browser/tests/legacy/html/svg.html
deleted file mode 100644
index 36854649..00000000
--- a/src/browser/tests/legacy/html/svg.html
+++ /dev/null
@@ -1,38 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-
-<svg id=lower width="200" height="100" style="border:1px solid #ccc" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 200 100">
-  <rect></rect>
-  <text x="100" y="95" font-size="14" text-anchor="middle">OVER 9000!!</text>
-</svg>
-
-<SVG ID=UPPER WIDTH="200" HEIGHT="100" STYLE="BORDER:1PX SOLID #CCC" XMLNS="http://www.w3.org/2000/svg" VIEWBOX="0 0 200 100">
-  <RECT></RECT>
-  <TEXT X="100" Y="95" FONT-SIZE="14" TEXT-ANCHOR="MIDDLE">OVER 9000!!!</TEXT>
-</SVG>
-
-<script id=svg>
-  testing.expectEqual(false, 'AString' instanceof SVGElement);
-
-  const svg1 = $('#lower');
-  testing.expectEqual('http://www.w3.org/2000/svg', svg1.getAttribute('xmlns'));
-  testing.expectEqual('http://www.w3.org/2000/svg', svg1.getAttributeNode('xmlns').value);
-  testing.expectEqual('http://www.w3.org/2000/svg', svg1.attributes.getNamedItem('xmlns').value);
-  testing.expectEqual('0 0 200 100', svg1.getAttribute('viewBox'));
-  testing.expectEqual('viewBox', svg1.getAttributeNode('viewBox').name);
-  testing.expectEqual(true, svg1.outerHTML.includes('viewBox'));
-  testing.expectEqual('svg', svg1.tagName);
-  testing.expectEqual('rect', svg1.querySelector('rect').tagName);
-  testing.expectEqual('text', svg1.querySelector('text').tagName);
-
-  const svg2 = $('#UPPER');
-  testing.expectEqual('http://www.w3.org/2000/svg', svg2.getAttribute('xmlns'));
-  testing.expectEqual('http://www.w3.org/2000/svg', svg2.getAttributeNode('xmlns').value);
-  testing.expectEqual('http://www.w3.org/2000/svg', svg2.attributes.getNamedItem('xmlns').value);
-  testing.expectEqual('0 0 200 100', svg2.getAttribute('viewBox'));
-  testing.expectEqual('viewBox', svg2.getAttributeNode('viewBox').name);
-  testing.expectEqual(true, svg2.outerHTML.includes('viewBox'));
-  testing.expectEqual('svg', svg2.tagName);
-  testing.expectEqual('rect', svg2.querySelector('rect').tagName);
-  testing.expectEqual('text', svg2.querySelector('text').tagName);
-</script>
diff --git a/src/browser/tests/legacy/storage/local_storage.html b/src/browser/tests/legacy/storage/local_storage.html
deleted file mode 100644
index c78f3889..00000000
--- a/src/browser/tests/legacy/storage/local_storage.html
+++ /dev/null
@@ -1,29 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-
-<script id=localstorage>
-  testing.expectEqual(0, localStorage.length);
-  testing.expectEqual(null, localStorage.getItem('foo'));
-  testing.expectEqual(null, localStorage.key(0));
-
-  localStorage.setItem('foo', 'bar');
-  testing.expectEqual(1, localStorage.length)
-  testing.expectEqual('bar', localStorage.getItem('foo'));
-  testing.expectEqual('foo', localStorage.key(0));
-  testing.expectEqual(null, localStorage.key(1));
-
-  localStorage.removeItem('foo');
-  testing.expectEqual(0, localStorage.length)
-  testing.expectEqual(null, localStorage.getItem('foo'));
-
-  localStorage['foo'] = 'bar';
-  testing.expectEqual(1, localStorage.length);
-  testing.expectEqual('bar', localStorage['foo']);
-
-  localStorage.setItem('a', '1');
-  localStorage.setItem('b', '2');
-  localStorage.setItem('c', '3');
-  testing.expectEqual(4, localStorage.length)
-  localStorage.clear();
-  testing.expectEqual(0, localStorage.length)
-</script>
diff --git a/src/browser/tests/legacy/streams/readable_stream.html b/src/browser/tests/legacy/streams/readable_stream.html
deleted file mode 100644
index a8339cc5..00000000
--- a/src/browser/tests/legacy/streams/readable_stream.html
+++ /dev/null
@@ -1,134 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-
-<script id=readable_stream>
-  const stream = new ReadableStream({
-    start(controller) {
-      controller.enqueue("hello");
-      controller.enqueue("world");
-      controller.close();
-    }
-  });
-
-  const reader = stream.getReader();
-
-  testing.async(reader.read(), (data) => {
-    testing.expectEqual("hello", data.value);
-    testing.expectEqual(false, data.done);
-  });
-</script>
-
-<script id=readable_stream_binary>
-  const input = new TextEncoder().encode('over 9000!');
-  const binStream = new ReadableStream({
-    start(controller) {
-      controller.enqueue(input);
-      controller.enqueue("world");
-      controller.close();
-    }
-  });
-
-  testing.async(binStream.getReader().read(), (data) => {
-    testing.expectEqual(input, data.value);
-    testing.expectEqual(false, data.done);
-  });
-</script>
-
-<script id=readable_stream_close>
-  var closeResult;
-
-  const stream1 = new ReadableStream({
-    start(controller) {
-      controller.enqueue("first");
-      controller.enqueue("second");
-      controller.close();
-    }
-  });
-
-  const reader1 = stream1.getReader();
-
-  testing.async(reader1.read(), (data) => {
-    testing.expectEqual("first", data.value);
-    testing.expectEqual(false, data.done);
-  });
-
-  testing.async(reader1.read(), (data) => {
-    testing.expectEqual("second", data.value);
-    testing.expectEqual(false, data.done);
-  });
-
-  testing.async(reader1.read(), (data) => {
-    testing.expectEqual(undefined, data.value);
-    testing.expectEqual(true, data.done);
-  });
-</script>
-
-<script id=readable_stream_cancel>
-  var readResult;
-  var cancelResult;
-  var closeResult;
-
-  const stream2 = new ReadableStream({
-    start(controller) {
-      controller.enqueue("data1");
-      controller.enqueue("data2");
-      controller.enqueue("data3");
-    },
-    cancel(reason) {
-      closeResult = `Stream cancelled: ${reason}`;
-    }
-  });
-
-  const reader2 = stream2.getReader();
-
-  testing.async(reader2.read(), (data) => {
-    testing.expectEqual("data1", data.value);
-    testing.expectEqual(false, data.done);
-  });
-
-  testing.async(reader2.cancel("user requested"), (result) => {
-    testing.expectEqual(undefined, result);
-    testing.expectEqual("Stream cancelled: user requested", closeResult);
-  });
-</script>
-
-<script id=readable_stream_cancel_no_reason>
-  var closeResult2;
-
-  const stream3 = new ReadableStream({
-    start(controller) {
-      controller.enqueue("test");
-    },
-    cancel(reason) {
-      closeResult2 = reason === undefined ? "no reason" : reason;
-    }
-  });
-
-  const reader3 = stream3.getReader();
-
-  testing.async(reader3.cancel(), (result) => {
-    testing.expectEqual(undefined, result);
-    testing.expectEqual("no reason", closeResult2);
-  });
-</script>
-
-<script id=readable_stream_read_after_cancel>
-  var readAfterCancelResult;
-
-  const stream4 = new ReadableStream({
-    start(controller) {
-      controller.enqueue("before_cancel");
-    },
-  });
-
-  const reader4 = stream4.getReader();
-
-  testing.async(reader4.cancel("test cancel"), (cancelResult) => {
-    testing.expectEqual(undefined, cancelResult);
-  });
-
-  testing.async(reader4.read(), (data) => {
-    testing.expectEqual(undefined, data.value);
-    testing.expectEqual(true, data.done);
-  });
-</script>
diff --git a/src/browser/tests/legacy/testing.js b/src/browser/tests/legacy/testing.js
deleted file mode 100644
index 8e732f70..00000000
--- a/src/browser/tests/legacy/testing.js
+++ /dev/null
@@ -1,206 +0,0 @@
-// Note: this code tries to make sure that we don't fail to execute a <script>
-// block without reporting an error. In other words, if the test passes, you
-// should be confident that the code actually ran.
-// We do a couple things to ensure this.
-// 1 - We make sure that ever script with an id has at least 1 assertion called
-// 2 - We add an onerror handler to every script and, on error, fail.
-//
-// This is pretty straightforward, with the only complexity coming from "eventually"
-// assertions, which are assertions we lazily check in `getStatus()`. We
-// do this because, by the time `getStatus()`, `frame.wait()` will have been called
-// and any timer (setTimeout, requestAnimation, MutationObserver, etc...) will
-// have been evaluated. Test which use/test these behavior will use `eventually`.
-(() => {
-  function expectEqual(expected, actual) {
-    _recordExecution();
-    if (_equal(expected, actual)) {
-      return;
-    }
-    testing._status = 'fail';
-    let msg = `expected: ${JSON.stringify(expected)}, got: ${JSON.stringify(actual)}`;
-
-    console.warn(
-      `id: ${testing._captured?.script_id || document.currentScript.id}`,
-      `msg: ${msg}`,
-      `stack: ${testing._captured?.stack || new Error().stack}`,
-    );
-  }
-
-  function expectError(expected, fn) {
-    withError((err) => {
-      expectEqual(expected, err.toString());
-    }, fn);
-  }
-
-  function withError(cb, fn) {
-    try{
-      fn();
-    } catch (err) {
-      cb(err);
-      return;
-    }
-    expectEqual('an error', null);
-  }
-
-  function skip() {
-    _recordExecution();
-  }
-
-  // Should only be called by the test runner
-  function assertOk() {
-    // if we're already in a fail state, return fail, nothing can recover this
-    if (testing._status === 'fail') {
-      throw new Error('Failed');
-    }
-
-    // run any eventually's that we've captured
-    for (const ev of testing._eventually) {
-      testing._captured = ev[1];
-      ev[0]();
-      testing._captured = null;
-    }
-
-    // Again, if we're in a fail state, we can immediately fail
-    if (testing._status === 'fail') {
-      throw new Error('Failed');
-    }
-
-    // make sure that any <script id=xyz></script> tags we have have had at least
-    // 1 assertion. This helps ensure that if a script tag fails to execute,
-    // we'll report an error, even if no assertions failed.
-    const scripts = document.getElementsByTagName('script');
-    for (script of scripts) {
-      const id = script.id;
-      if (!id) {
-        continue;
-      }
-
-      if (!testing._executed_scripts.has(id)) {
-        console.warn(`Failed to execute any expectations for <script id="${id}">...</script>`);
-      	throw new Error('Failed');
-      }
-    }
-
-    if (testing._status != 'ok') {
-      throw new Error(testing._status);
-    }
-  }
-
-  // Set expectations to happen at some point in the future. Necessary for
-  // testing callbacks which will only be executed after frame.wait is called.
-  function eventually(fn) {
-    // capture the current state (script id, stack) so that, when we do run this
-    // we can display more meaningful details on failure.
-    testing._eventually.push([fn, {
-      script_id: document.currentScript.id,
-      stack: new Error().stack,
-    }]);
-
-    _registerErrorCallback();
-  }
-
-  async function async(promise, cb) {
-    const script_id = document.currentScript ? document.currentScript.id : '<script id is unavailable in browsers>';
-    const stack = new Error().stack;
-    this._captured = {script_id: script_id, stack: stack};
-    const value = await promise;
-    // reset it, because await promise could change it.
-    this._captured = {script_id: script_id, stack: stack};
-    cb(value);
-    this._captured = null;
-  }
-
-  function _recordExecution() {
-    if (testing._status === 'fail') {
-      return;
-    }
-    testing._status = 'ok';
-
-    if (testing._captured || document.currentScript) {
-    	const script_id = testing._captured?.script_id || document.currentScript.id;
-    	testing._executed_scripts.add(script_id);
-	    _registerErrorCallback();
-    }
-  }
-
-  // We want to attach an onError callback to each <script>, so that we can
-  // properly fail it.
-  function _registerErrorCallback() {
-    const script = document.currentScript;
-    if (!script) {
-      // can be null if we're executing an eventually assertion, but that's ok
-      // because the errorCallback would have been registered for this script
-      // already
-      return;
-    }
-
-    if (script.onerror) {
-      // already registered
-      return;
-    }
-
-    script.onerror = function(err, b) {
-      testing._status = 'fail';
-      console.warn(
-        `id: ${script.id}`,
-        `msg: There was an error executing the <script id=${script.id}>...</script>.\n      There should be a eval error printed above this.`,
-      );
-    }
-  }
-
-  function _equal(a, b) {
-    if (a === b) {
-      return true;
-    }
-    if (a === null || b === null) {
-      return false;
-    }
-    if (typeof a !== 'object' || typeof b !== 'object') {
-      return false;
-    }
-
-    if (Object.keys(a).length != Object.keys(b).length) {
-      return false;
-    }
-
-    for (property in a) {
-      if (b.hasOwnProperty(property) === false) {
-        return false;
-      }
-      if (_equal(a[property], b[property]) === false) {
-        return false;
-      }
-    }
-
-    return true;
-  }
-
-  window.testing = {
-    _status: 'empty',
-    _eventually: [],
-    _executed_scripts: new Set(),
-    _captured: null,
-    skip: skip,
-    async: async,
-    assertOk: assertOk,
-    eventually: eventually,
-    expectEqual: expectEqual,
-    expectError: expectError,
-    withError: withError,
-  };
-
-  // Helper, so you can do $(sel) in a test
-  window.$ = function(sel) {
-    return document.querySelector(sel);
-  }
-
-  // Helper, so you can do $$(sel) in a test
-  window.$$ = function(sel) {
-    return document.querySelectorAll(sel);
-  }
-
-  if (!console.lp) {
-    // make this work in the browser
-    console.lp = console.log;
-  }
-})();
diff --git a/src/browser/tests/legacy/url/url.html b/src/browser/tests/legacy/url/url.html
deleted file mode 100644
index 72ca45f0..00000000
--- a/src/browser/tests/legacy/url/url.html
+++ /dev/null
@@ -1,109 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-<script id=url>
-  var url = new URL('https://foo.bar/path?query#fragment');
-  testing.expectEqual("https://foo.bar", url.origin);
-  testing.expectEqual("https://foo.bar/path?query#fragment", url.href);
-  testing.expectEqual("https:", url.protocol);
-  testing.expectEqual("", url.username);
-  testing.expectEqual("", url.password);
-  testing.expectEqual("foo.bar", url.host);
-  testing.expectEqual("foo.bar", url.hostname);
-  testing.expectEqual("", url.port);
-  testing.expectEqual("/path", url.pathname);
-  testing.expectEqual("?query", url.search);
-  testing.expectEqual("#fragment", url.hash);
-  testing.expectEqual("", url.searchParams.get('query'));
-
-  url.search = 'hello=world';
-  testing.expectEqual(1, url.searchParams.size);
-  testing.expectEqual("world", url.searchParams.get('hello'));
-
-  url.search = '?over=9000';
-  testing.expectEqual(1, url.searchParams.size);
-  testing.expectEqual("9000", url.searchParams.get('over'));
-
-  url.search = '';
-  testing.expectEqual(0, url.searchParams.size);
-
-  const url2 = new URL(url);
-  testing.expectEqual("https://foo.bar/path#fragment", url2.href);
-</script>
-
-<script id="constructor">
-  testing.expectError("Error: TypeError", () => {
-    new URL(document.createElement('a'));
-  });
-
-  let a = document.createElement('a');
-  a.href = 'https://www.lightpanda.io/over?9000=!!';
-  const url3 = new URL(a);
-  testing.expectEqual("https://www.lightpanda.io/over?9000=!!", url3.href);
- </script>
-
-<script id=searchParams>
-  url = new URL('https://foo.bar/path?a=~&b=%7E#fragment');
-  testing.expectEqual("~", url.searchParams.get('a'));
-  testing.expectEqual("~", url.searchParams.get('b'));
-
-  url.searchParams.append('c', 'foo');
-  testing.expectEqual("foo", url.searchParams.get('c'));
-  testing.expectEqual(1, url.searchParams.getAll('c').length);
-  testing.expectEqual("foo", url.searchParams.getAll('c')[0]);
-  testing.expectEqual(3, url.searchParams.size);
-
-  // search is dynamic
-  testing.expectEqual("?a=%7E&b=%7E&c=foo", url.search);
-
-  // href is dynamic
-  testing.expectEqual("https://foo.bar/path?a=%7E&b=%7E&c=foo#fragment", url.href);
-
-  url.searchParams.delete('c', 'foo');
-  testing.expectEqual(null, url.searchParams.get('c'));
-  url.searchParams.delete('a');
-  testing.expectEqual(null, url.searchParams.get('a'));
-</script>
-
-<script id=searchParamsSetHref>
-  url = new URL("https://foo.bar");
-  const searchParams = url.searchParams;
-
-  // SearchParams should be empty.
-  testing.expectEqual(0, searchParams.size);
-
-  url.href = "https://lightpanda.io?over=9000&light=panda";
-  // It won't hurt to check href and host too.
-  testing.expectEqual("https://lightpanda.io/?over=9000&light=panda", url.href);
-  testing.expectEqual("lightpanda.io", url.host);
-  // SearchParams should be updated too when URL is set.
-  testing.expectEqual(2, searchParams.size);
-  testing.expectEqual("9000", searchParams.get("over"));
-  testing.expectEqual("panda", searchParams.get("light"));
-</script>
-
-<script id=base>
-  url = new URL('over?9000', 'https://lightpanda.io');
-  testing.expectEqual("https://lightpanda.io/over?9000", url.href);
-</script>
-
-<script id="svelkit">
-  let sk = new URL('sveltekit-internal://');
-  testing.expectEqual("sveltekit-internal:", sk.protocol);
-  testing.expectEqual("", sk.host);
-  testing.expectEqual("", sk.hostname);
-  testing.expectEqual("sveltekit-internal://", sk.href);
-</script>
-
-<script id=invalidUrl>
-  testing.expectError("Error: TypeError", () => {
-    _ = new URL("://foo.bar/path?query#fragment");
-  });
-</script>
-
-<script id=URL.canParse>
-  testing.expectEqual(true, URL.canParse("https://lightpanda.io"));
-  testing.expectEqual(false, URL.canParse("://lightpanda.io"));
-
-  testing.expectEqual(true, URL.canParse("/home", "https://lightpanda.io"));
-  testing.expectEqual(false, URL.canParse("lightpanda.io", "https"));
-</script>
diff --git a/src/browser/tests/legacy/url/url_search_params.html b/src/browser/tests/legacy/url/url_search_params.html
deleted file mode 100644
index 738253d2..00000000
--- a/src/browser/tests/legacy/url/url_search_params.html
+++ /dev/null
@@ -1,93 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-<script id=url_search_params>
-  let usp = new URLSearchParams();
-  usp.get('a')
-  testing.expectEqual(false, usp.has('a'));
-  testing.expectEqual([], usp.getAll('a'));
-  usp.delete('a');
-
-  usp.set('a', 1);
-  testing.expectEqual(true, usp.has('a'));
-  testing.expectEqual("1", usp.get('a'));
-  testing.expectEqual(["1"], usp.getAll('a'));
-
-  usp.append('a', 2);
-  testing.expectEqual(true, usp.has('a'));
-  testing.expectEqual("1", usp.get('a'));
-  testing.expectEqual(['1','2'], usp.getAll('a'));
-
-  usp.append('b', '3');
-  testing.expectEqual(true, usp.has('a'));
-  testing.expectEqual("1", usp.get('a'));
-  testing.expectEqual(['1','2'], usp.getAll('a'));
-  testing.expectEqual(true, usp.has('b'));
-  testing.expectEqual("3", usp.get('b'));
-  testing.expectEqual(['3'], usp.getAll('b'));
-
-  let acc = [];
-  for (const key of usp.keys()) { acc.push(key) };
-  testing.expectEqual(['a', 'a', 'b'], acc);
-
-  acc = [];
-  for (const value of usp.values()) { acc.push(value) };
-  testing.expectEqual(['1', '2', '3'], acc);
-
-  acc = [];
-  for (const entry of usp.entries()) { acc.push(entry) };
-  testing.expectEqual([['a', '1'], ['a', '2'], ['b', '3']], acc);
-
-  acc = [];
-  for (const entry of usp) { acc.push(entry) };
-  testing.expectEqual([['a', '1'], ['a', '2'], ['b', '3']], acc);
-
-  usp.delete('a');
-  testing.expectEqual(false, usp.has('a'));
-  testing.expectEqual(true, usp.has('b'));
-
-  acc = [];
-  for (const key of usp.keys()) { acc.push(key) };
-  testing.expectEqual(['b'], acc);
-
-  acc = [];
-  for (const value of usp.values()) { acc.push(value) };
-  testing.expectEqual(['3'], acc);
-
-  acc = [];
-  for (const entry of usp.entries()) { acc.push(entry) };
-  testing.expectEqual([['b', '3']], acc);
-
-  acc = [];
-  for (const entry of usp) { acc.push(entry) };
-  testing.expectEqual([['b', '3']], acc);
-</script>
-
- <script id=parsed>
-  usp = new URLSearchParams('?hello');
-  testing.expectEqual('', usp.get('hello'));
-
-  usp = new URLSearchParams('?abc=');
-  testing.expectEqual('', usp.get('abc'));
-
-  usp = new URLSearchParams('?abc=123&');
-  testing.expectEqual('123', usp.get('abc'));
-  testing.expectEqual(1, usp.size);
-
-  var fd = new FormData();
-  fd.append('a', '1');
-  fd.append('a', '2');
-  fd.append('b', '3');
-  ups = new URLSearchParams(fd);
-
-  testing.expectEqual(3, ups.size);
-  testing.expectEqual(['1', '2'], ups.getAll('a'));
-  testing.expectEqual(['3'], ups.getAll('b'));
-
-  fd.delete('a'); // the two aren't linked, it created a copy
-  testing.expectEqual(3, ups.size);
-
-  ups = new URLSearchParams({over: 9000, spice: 'flow'});
-  testing.expectEqual(2, ups.size);
-  testing.expectEqual(['9000'], ups.getAll('over'));
-  testing.expectEqual(['flow'], ups.getAll('spice'));
-</script>
diff --git a/src/browser/tests/legacy/window/frames.html b/src/browser/tests/legacy/window/frames.html
deleted file mode 100644
index 669fbfde..00000000
--- a/src/browser/tests/legacy/window/frames.html
+++ /dev/null
@@ -1,12 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-
-<body>
- <iframe src="https://httpbin.io/html" title="iframea"></iframe>
- <iframe src="https://httpbin.io/html" title="iframeb"></iframe>
-</body>
-
-<script id=frames>
-  testing.expectEqual(2, frames.length);
-  testing.expectEqual(undefined, frames[3])
-</script>
diff --git a/src/browser/tests/legacy/window/window.html b/src/browser/tests/legacy/window/window.html
deleted file mode 100644
index dee57062..00000000
--- a/src/browser/tests/legacy/window/window.html
+++ /dev/null
@@ -1,117 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-<body style=height:4000px;width:4000px></body>
-
-<script id=aliases>
-  testing.expectEqual(window, window.self);
-  testing.expectEqual(window, window.parent);
-  testing.expectEqual(window, window.top);
-  testing.expectEqual(window, window.frames);
-  testing.expectEqual(0, window.frames.length);
-</script>
-
-<script id=request_animation>
-  let start = 0;
-  function step(timestamp) {
-    start = timestamp;
-  }
-  requestAnimationFrame(step);
-  testing.onload(() => {
-    testing.expectEqual(true, start > 0)
-  });
-
-  let request_id = requestAnimationFrame(() => {
-    start = 0;
-  });
-  cancelAnimationFrame(request_id);
-  testing.onload(() => testing.expectEqual(true, start > 0));
-</script>
-
-<script id=setTimeout>
-  let longCall = false;
-  window.setTimeout(() => {longCall = true}, 5001);
-  testing.onload(() => testing.expectEqual(false, longCall));
-
-  let wst1 = 0;
-  window.setTimeout(() => {wst1 += 1}, 1);
-  testing.onload(() => testing.expectEqual(1, wst1));
-
-  let wst2 = 1;
-  window.setTimeout((a, b) => {
-    wst2 = a + b;
-  }, 1, 2, 3);
-  testing.onload(() => testing.expectEqual(5, wst2));
-</script>
-
-<script id=eventTarget>
-  let called = false;
-
-  window.addEventListener("ready", (e) => {
-    called = (e.currentTarget == window);
-  }, {capture: false, once: false});
-
-  const evt = new Event("ready", { bubbles: true, cancelable: false });
-  window.dispatchEvent(evt);
-  testing.expectEqual(true, called);
-</script>
-
-<script id=btoa_atob>
-  const b64 = btoa('https://ziglang.org/documentation/master/std/#std.base64.Base64Decoder')
-  testing.expectEqual('aHR0cHM6Ly96aWdsYW5nLm9yZy9kb2N1bWVudGF0aW9uL21hc3Rlci9zdGQvI3N0ZC5iYXNlNjQuQmFzZTY0RGVjb2Rlcg==', b64);
-
-  const str = atob(b64)
-  testing.expectEqual('https://ziglang.org/documentation/master/std/#std.base64.Base64Decoder', str);
-
-  testing.expectError('Error: InvalidCharacterError', () => {
-    atob('b');
-  });
-</script>
-
-<script id=queueMicroTask>
-  var qm = false;
-  window.queueMicrotask(() => {qm = true });
-  testing.onload(() => testing.expectEqual(true, qm));
-</script>
-
-<script id=DOMContentLoaded>
-  let dcl = false;
-  window.queueMicrotask(() => {qm = true });
-  window.addEventListener('DOMContentLoaded', (e) => {
-    dcl = e.target == document;
-  });
-  testing.onload(() => testing.expectEqual(true, dcl));
-</script>
-
-<script id=window.onload>
-  let isDocumentTarget = false;
-
-  const callback = (e) => {
-    isDocumentTarget = e.target === document;
-  };
-  // Callback is not set yet.
-  testing.expectEqual(null, window.onload);
-  // Setting an object.
-  window.onload = {};
-  testing.expectEqual(null, window.onload);
-  // Callback is set.
-  window.onload = callback;
-  testing.expectEqual(callback, window.onload);
-
-  testing.onload(() => testing.expectEqual(true, isDocumentTarget));
-</script>
-
-<script id=reportError>
-  let errorEventFired = false;
-  let capturedError = null;
-
-  window.addEventListener('error', (e) => {
-    errorEventFired = true;
-    capturedError = e.error;
-  });
-
-  const testError = new Error('Test error message');
-  window.reportError(testError);
-
-  testing.expectEqual(true, errorEventFired);
-  testing.expectEqual(testError, capturedError);
-</script>
diff --git a/src/browser/tests/legacy/xhr/form_data.html b/src/browser/tests/legacy/xhr/form_data.html
deleted file mode 100644
index cda34c06..00000000
--- a/src/browser/tests/legacy/xhr/form_data.html
+++ /dev/null
@@ -1,133 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-
-<form id="form1">
-  <input id="has_no_name" value="nope1">
-  <input id="is_disabled" disabled value="nope2">
-
-  <input name="txt-1" value="txt-1-v">
-  <input name="txt-2" value="txt-~-v" type=password>
-
-  <input name="chk-3" value="chk-3-va" type=checkbox>
-  <input name="chk-3" value="chk-3-vb" type=checkbox checked>
-  <input name="chk-3" value="chk-3-vc" type=checkbox checked>
-  <input name="chk-4" value="chk-4-va" type=checkbox>
-  <input name="chk-4" value="chk-4-va" type=checkbox>
-
-  <input name="rdi-1" value="rdi-1-va" type=radio>
-  <input name="rdi-1" value="rdi-1-vb" type=radio>
-  <input name="rdi-1" value="rdi-1-vc" type=radio checked>
-  <input name="rdi-2" value="rdi-2-va" type=radio>
-  <input name="rdi-2" value="rdi-2-vb" type=radio>
-
-  <textarea name="ta-1"> ta-1-v</textarea>
-  <textarea name="ta"></textarea>
-
-  <input type=hidden name=h1 value="h1-v">
-  <input type=hidden name=h2 value="h2-v" disabled=disabled>
-
-  <select name="sel-1"><option>blue<option>red</select>
-  <select name="sel-2"><option>blue<option value=sel-2-v selected>red</select>
-  <select name="sel-3"><option disabled>nope1<option>nope2</select>
-  <select name="mlt-1" multiple><option>water<option>tea</select>
-  <select name="mlt-2" multiple><option selected>water<option selected>tea<option>coffee</select>
-  <input type=submit id=s1 name=s1 value=s1-v>
-  <input type=submit name=s2 value=s2-v>
-  <input type=image name=i1 value=i1-v>
-</form>
-<input type=text name=abc value=123 form=form1>
-
-<script id=formData>
-  let f = new FormData();
-  testing.expectEqual(null, f.get('a'));
-  testing.expectEqual(false, f.has('a'));
-  testing.expectEqual([], f.getAll('a'));
-  testing.expectEqual(undefined, f.delete('a'));
-
-  f.set('a', 1);
-  testing.expectEqual(true, f.has('a'));
-  testing.expectEqual('1', f.get('a'));
-  testing.expectEqual(['1'], f.getAll('a'));
-
-  f.append('a', 2);
-  testing.expectEqual(true, f.has('a'));
-  testing.expectEqual('1', f.get('a'));
-  testing.expectEqual(['1', '2'], f.getAll('a'));
-
-  f.append('b', '3');
-  testing.expectEqual(true, f.has('a'));
-  testing.expectEqual('1', f.get('a'));
-  testing.expectEqual(['1', '2'], f.getAll('a'));
-  testing.expectEqual(true, f.has('b'));
-  testing.expectEqual('3', f.get('b'));
-  testing.expectEqual(['3'], f.getAll('b'));
-
-  let acc = [];
-  for (const key of f.keys()) { acc.push(key) }
-  testing.expectEqual(['a', 'a', 'b'], acc);
-
-  acc = [];
-  for (const value of f.values()) { acc.push(value) }
-  testing.expectEqual(['1', '2', '3'], acc);
-
-  acc = [];
-  for (const entry of f.entries()) { acc.push(entry) }
-  testing.expectEqual([['a', '1'], ['a', '2'], ['b', '3']], acc);
-
-  acc = [];
-  for (const entry of f) { acc.push(entry) };
-  testing.expectEqual([['a', '1'], ['a', '2'], ['b', '3']], acc);
-
-  f.delete('a');
-  testing.expectEqual(false, f.has('a'));
-  testing.expectEqual(true, f.has('b'));
-
-  acc = [];
-  for (const key of f.keys()) { acc.push(key) }
-  testing.expectEqual(['b'], acc);
-
-  acc = [];
-  for (const value of f.values()) { acc.push(value) }
-  testing.expectEqual(['3'], acc);
-
-  acc = [];
-  for (const entry of f.entries()) { acc.push(entry) }
-  testing.expectEqual([['b', '3']], acc);
-
-  acc = [];
-  for (const entry of f) { acc.push(entry) }
-  testing.expectEqual([['b', '3']], acc);
-</script>
-
-<script id=serialize>
-  let form1 = $('#form1');
-  let submit1 = $('#s1');
-
-  let input = document.createElement('input');
-  input.name = 'dyn';
-  input.value = 'dyn-v';
-  form1.appendChild(input);
-  let f2 = new FormData(form1, submit1);
-
-  acc = [];
-  for (const entry of f2) {
-    acc.push(entry);
-  };
-
-  testing.expectEqual(['txt-1', 'txt-1-v'], acc[0]);
-  testing.expectEqual(['txt-2', 'txt-~-v'], acc[1]);
-  testing.expectEqual(['chk-3', 'chk-3-vb'], acc[2]);
-  testing.expectEqual(['chk-3', 'chk-3-vc'], acc[3]);
-  testing.expectEqual(['rdi-1', 'rdi-1-vc'], acc[4]);
-  testing.expectEqual(['ta-1', ' ta-1-v'], acc[5]);
-  testing.expectEqual(['ta', ''], acc[6]);
-  testing.expectEqual(['h1', 'h1-v'], acc[7]);
-  testing.expectEqual(['sel-1', 'blue'], acc[8]);
-  testing.expectEqual(['sel-2', 'sel-2-v'], acc[9]);
-  testing.expectEqual(['sel-3', 'nope2'], acc[10]);
-  testing.expectEqual(['mlt-2', 'water'], acc[11]);
-  testing.expectEqual(['mlt-2', 'tea'], acc[12]);
-  testing.expectEqual(['s1', 's1-v'], acc[13]);
-</script>
-
-
diff --git a/src/browser/tests/legacy/xhr/progress_event.html b/src/browser/tests/legacy/xhr/progress_event.html
deleted file mode 100644
index 4b7f5df4..00000000
--- a/src/browser/tests/legacy/xhr/progress_event.html
+++ /dev/null
@@ -1,17 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-<script id=progressEvent>
-  let pevt = new ProgressEvent('foo');
-  testing.expectEqual(0, pevt.loaded);
-
-  testing.expectEqual(true, pevt instanceof ProgressEvent);
-
-  var eevt = null;
-  function ccbk(event) {
-    eevt =  event;
-  }
-  document.addEventListener('foo', ccbk)
-  document.dispatchEvent(pevt);
-  testing.expectEqual('foo', eevt.type);
-  testing.expectEqual(true, eevt instanceof ProgressEvent);
-</script>
diff --git a/src/browser/tests/legacy/xhr/xhr.html b/src/browser/tests/legacy/xhr/xhr.html
deleted file mode 100644
index c7c557bd..00000000
--- a/src/browser/tests/legacy/xhr/xhr.html
+++ /dev/null
@@ -1,122 +0,0 @@
-<!DOCTYPE html>
-<script src="../testing.js"></script>
-<script id=xhr type=module>
-  const req = new XMLHttpRequest();
-  const promise1 = new Promise((resolve) => {
-    function cbk(event) {
-      resolve(event)
-    }
-
-    req.onload = cbk;
-    testing.expectEqual(cbk, req.onload);
-    req.onload = cbk;
-
-    req.open('GET', 'http://127.0.0.1:9589/xhr');
-    testing.expectEqual(0, req.status);
-    testing.expectEqual('', req.statusText);
-    testing.expectEqual('', req.getAllResponseHeaders());
-    testing.expectEqual(null, req.getResponseHeader('Content-Type'));
-    testing.expectEqual('', req.responseText);
-    req.send();
-  });
-
-  testing.async(promise1, (event) => {
-    testing.expectEqual('load', event.type);
-    testing.expectEqual(true, event.loaded > 0);
-    testing.expectEqual(true, event instanceof ProgressEvent);
-    testing.expectEqual(200, req.status);
-    testing.expectEqual('OK', req.statusText);
-    testing.expectEqual('text/html; charset=utf-8', req.getResponseHeader('Content-Type'));
-    testing.expectEqual('content-length: 100\r\nContent-Type: text/html; charset=utf-8\r\n', req.getAllResponseHeaders());
-    testing.expectEqual(100, req.responseText.length);
-    testing.expectEqual(req.responseText.length, req.response.length);
-  });
-</script>
-
-<script id=xhr2 type=module>
-  const req2 = new XMLHttpRequest()
-  const promise2 = new Promise((resolve) => {
-    req2.onload = resolve;
-    req2.open('GET', 'http://127.0.0.1:9589/xhr')
-    req2.responseType = 'document';
-    req2.send()
-  });
-
-  testing.async(promise2, () => {
-    testing.expectEqual(200, req2.status);
-    testing.expectEqual('OK', req2.statusText);
-    testing.expectEqual(true, req2.response instanceof Document);
-    testing.expectEqual(true, req2.responseXML instanceof Document);
-  });
-</script>
-
-<script id=xhr3 type=module>
-  const req3 = new XMLHttpRequest()
-  const promise3 = new Promise((resolve) => {
-    req3.onload = resolve;
-    req3.open('GET', 'http://127.0.0.1:9589/xhr/json')
-    req3.responseType = 'json';
-    req3.send()
-  });
-
-  testing.async(promise3, () => {
-    testing.expectEqual(200, req3.status);
-    testing.expectEqual('OK', req3.statusText);
-    testing.expectEqual('9000!!!', req3.response.over);
-  });
-</script>
-
-<script id=xhr4 type=module>
-  const req4 = new XMLHttpRequest()
-  const promise4 = new Promise((resolve) => {
-    req4.onload = resolve;
-    req4.open('POST', 'http://127.0.0.1:9589/xhr')
-    req4.send('foo')
-  });
-
-  testing.async(promise4, () => {
-    testing.expectEqual(200, req4.status);
-    testing.expectEqual('OK', req4.statusText);
-    testing.expectEqual(true, req4.responseText.length > 64);
-  });
-</script>
-
-<script id=xhr5 type=module>
-  const promise5 = new Promise((resolve) => {
-    var state = [];
-    const req5 = new XMLHttpRequest();
-    req5.onreadystatechange = (e) => {
-      state.push(req5.readyState);
-      if (req5.readyState === XMLHttpRequest.DONE) {
-        resolve({states: state, target: e.currentTarget});
-      }
-    }
-
-    req5.open('GET', 'http://127.0.0.1:9589/xhr');
-    req5.send();
-  });
-
-  testing.async(promise5, (result) => {
-    const {states: states, target: target} = result;
-    testing.expectEqual(4, states.length)
-    testing.expectEqual(XMLHttpRequest.OPENED, readyStates[0]);
-    testing.expectEqual(XMLHttpRequest.HEADERS_RECEIVED, readyStates[1]);
-    testing.expectEqual(XMLHttpRequest.LOADING, readyStates[2]);
-    testing.expectEqual(XMLHttpRequest.DONE, readyStates[3]);
-    testing.expectEqual(req5, target);
-  })
-</script>
-
-<script id=xhr6 type=module>
-  const req5 = new XMLHttpRequest()
-  const promise5 = new Promise((resolve) => {
-    req5.onload = resolve;
-    req5.open('PROPFIND', 'http://127.0.0.1:9589/xhr')
-    req5.send('foo')
-  });
-
-  testing.async(promise5, () => {
-    testing.expectEqual(200, req5.status);
-    testing.expectEqual('OK', req5.statusText);
-    testing.expectEqual(true, req5.responseText.length > 65);
-  });
diff --git a/src/browser/tests/legacy/xmlserializer.html b/src/browser/tests/legacy/xmlserializer.html
deleted file mode 100644
index 0d3d4628..00000000
--- a/src/browser/tests/legacy/xmlserializer.html
+++ /dev/null
@@ -1,8 +0,0 @@
-<!DOCTYPE html>
-<script src="testing.js"></script>
-<p id="para"> And</p>
-<script id=xmlserializer>
-  const s = new XMLSerializer();
-  testing.expectEqual('<p id="para"> And</p>', s.serializeToString($('#para')));
-  testing.expectEqual('<!DOCTYPE html>', s.serializeToString(document.doctype));
-</script>
diff --git a/src/browser/tests/navigator/navigator.html b/src/browser/tests/navigator/navigator.html
index 92f33bab..09419d69 100644
--- a/src/browser/tests/navigator/navigator.html
+++ b/src/browser/tests/navigator/navigator.html
@@ -27,6 +27,36 @@
   testing.expectEqual('Gecko', navigator.product);
   testing.expectEqual(false, navigator.javaEnabled());
   testing.expectEqual(false, navigator.webdriver);
+
+  testing.expectEqual(null, navigator.doNotTrack);
+
+  // Every Navigator attribute must be a native accessor on the prototype
+  for (const name of [
+    'userAgent', 'appName', 'appCodeName', 'appVersion', 'platform',
+    'language', 'languages', 'onLine', 'cookieEnabled', 'hardwareConcurrency',
+    'deviceMemory', 'maxTouchPoints', 'vendor', 'product', 'webdriver',
+    'plugins', 'doNotTrack', 'globalPrivacyControl',
+  ]) {
+    const desc = Object.getOwnPropertyDescriptor(Navigator.prototype, name);
+    testing.expectEqual('function', typeof desc.get); // accessor on prototype
+    testing.expectEqual(undefined, desc.value);        // not a data property
+    testing.expectEqual(undefined, Object.getOwnPropertyDescriptor(navigator, name)); // not own
+    testing.expectEqual(true, desc.get.toString().includes('[native code]'));
+  }
+</script>
+
+<script id=navigator_native_descriptor_walk>
+  // Mirror the bot-detection fingerprint: read every navigator property's
+  // descriptor and call toString() on its value/getter. This must not throw.
+  let obj = navigator;
+  do {
+    for (const name of Object.getOwnPropertyNames(obj)) {
+      const d = Object.getOwnPropertyDescriptor(obj, name);
+      if (d.value !== undefined) { d.value.toString(); }
+      else if (d.get !== undefined) { d.get.toString(); }
+    }
+  } while (obj = Object.getPrototypeOf(obj));
+  testing.expectEqual(null, navigator.doNotTrack);
 </script>
 
 <script id=permission_query type=module>
diff --git a/src/browser/tests/shadowroot/declarative.html b/src/browser/tests/shadowroot/declarative.html
new file mode 100644
index 00000000..91371a17
--- /dev/null
+++ b/src/browser/tests/shadowroot/declarative.html
@@ -0,0 +1,124 @@
+<!DOCTYPE html>
+<script src="../testing.js"></script>
+
+<div id="host"></div>
+
+<!-- Declarative shadow root in the document markup itself: exercises the
+     document-parse path (the SSR scenario), not just setHTMLUnsafe. -->
+<div id="dochost"><template shadowrootmode="open"><p>doc shadow</p></template></div>
+
+<script id="document_parse_attaches_shadow">
+{
+    const host = $('#dochost');
+    testing.expectTrue(host.shadowRoot !== null);
+    testing.expectEqual('doc shadow', host.shadowRoot.querySelector('p').textContent);
+    testing.expectEqual(null, host.querySelector('template'));
+}
+</script>
+
+<script id="setHTMLUnsafe_open">
+{
+    const host = $('#host');
+    host.setHTMLUnsafe('<div id="inner"><template shadowrootmode="open"><p>shadow content</p></template></div>');
+
+    const inner = host.querySelector('#inner');
+    // A real shadow root was attached, and no <template> was left in light DOM.
+    testing.expectTrue(inner.shadowRoot !== null);
+    testing.expectEqual('open', inner.shadowRoot.mode);
+    testing.expectEqual('shadow content', inner.shadowRoot.querySelector('p').textContent);
+    testing.expectEqual(null, inner.querySelector('template'));
+}
+</script>
+
+<script id="setHTMLUnsafe_closed">
+{
+    const host = document.createElement('div');
+    host.setHTMLUnsafe('<div id="inner"><template shadowrootmode="closed"><p>x</p></template></div>');
+
+    const inner = host.querySelector('#inner');
+    // Closed shadow root: not exposed via .shadowRoot, but the template is consumed.
+    testing.expectEqual(null, inner.shadowRoot);
+    testing.expectEqual(null, inner.querySelector('template'));
+}
+</script>
+
+<script id="innerHTML_does_not_attach">
+{
+    const host = document.createElement('div');
+    // innerHTML must NOT process declarative shadow roots (only setHTMLUnsafe does).
+    host.innerHTML = '<div id="inner"><template shadowrootmode="open"><p>x</p></template></div>';
+
+    const inner = host.querySelector('#inner');
+    testing.expectEqual(null, inner.shadowRoot);
+    testing.expectTrue(inner.querySelector('template') !== null);
+}
+</script>
+
+<script id="second_declarative_template_retained">
+{
+    const host = document.createElement('div');
+    host.setHTMLUnsafe('<div id="inner"><template shadowrootmode="open"><p>first</p></template><template shadowrootmode="open"><p>second</p></template></div>');
+
+    const inner = host.querySelector('#inner');
+    testing.expectTrue(inner.shadowRoot !== null);
+    testing.expectEqual('first', inner.shadowRoot.querySelector('p').textContent);
+    // The host already has a shadow root, so the second template stays in light DOM.
+    testing.expectTrue(inner.querySelector('template') !== null);
+}
+</script>
+
+<script id="declarative_slot_projection">
+{
+    const host = document.createElement('div');
+    host.setHTMLUnsafe('<div id="inner"><template shadowrootmode="open"><slot></slot></template><p>light</p></div>');
+
+    const inner = host.querySelector('#inner');
+    const slot = inner.shadowRoot.querySelector('slot');
+    const assigned = slot.assignedNodes();
+    testing.expectEqual(1, assigned.length);
+    testing.expectEqual('light', assigned[0].textContent);
+}
+</script>
+
+<script id="attachShadow_invalid_host_throws">
+{
+    // Host validation: <input> cannot host a shadow root.
+    testing.expectError('NotSupportedError', () => {
+        document.createElement('input').attachShadow({ mode: 'open' });
+    });
+}
+</script>
+
+<script id="attachShadow_twice_throws">
+{
+    const host = document.createElement('div');
+    host.attachShadow({ mode: 'open' });
+    testing.expectError('NotSupportedError', () => {
+        host.attachShadow({ mode: 'open' });
+    });
+}
+</script>
+
+<script id="disabled_features_blocks_declarative_shadow">
+{
+    class ShadowDisabledElement extends HTMLElement {
+        static get disabledFeatures() { return ['shadow']; }
+    }
+    customElements.define('shadow-disabled-host', ShadowDisabledElement);
+
+    const host = document.createElement('div');
+    host.setHTMLUnsafe('<shadow-disabled-host><template shadowrootmode="open"><span>x</span></template></shadow-disabled-host>');
+
+    const sd = host.querySelector('shadow-disabled-host');
+    // disabledFeatures: ['shadow'] -> declarative attach must fail, template kept.
+    testing.expectEqual(null, sd.shadowRoot);
+    testing.expectTrue(sd.querySelector('template') !== null);
+}
+</script>
+
+<script id="disabled_features_blocks_imperative_shadow">
+{
+    const sd = document.createElement('shadow-disabled-host');
+    testing.expectError('NotSupportedError', () => sd.attachShadow({ mode: 'open' }));
+}
+</script>
diff --git a/src/browser/tests/staticrange.html b/src/browser/tests/staticrange.html
new file mode 100644
index 00000000..c11952ef
--- /dev/null
+++ b/src/browser/tests/staticrange.html
@@ -0,0 +1,136 @@
+<!DOCTYPE html>
+<script src="testing.js"></script>
+<body>
+<div id="testDiv">abc<span>def</span>ghi</div>
+
+<script id=construct_element>
+{
+  const testDiv = $('#testDiv');
+  const sr = new StaticRange({startContainer: testDiv, startOffset: 1, endContainer: testDiv, endOffset: 2});
+  testing.expectEqual(testDiv, sr.startContainer);
+  testing.expectEqual(1, sr.startOffset);
+  testing.expectEqual(testDiv, sr.endContainer);
+  testing.expectEqual(2, sr.endOffset);
+  testing.expectEqual(false, sr.collapsed);
+}
+</script>
+
+<script id=construct_text>
+{
+  const text = $('#testDiv').firstChild;
+  const sr = new StaticRange({startContainer: text, startOffset: 1, endContainer: text, endOffset: 2});
+  testing.expectEqual(text, sr.startContainer);
+  testing.expectEqual(text, sr.endContainer);
+  testing.expectEqual(false, sr.collapsed);
+}
+</script>
+
+<script id=construct_mixed>
+{
+  const testDiv = $('#testDiv');
+  const text = testDiv.firstChild;
+  const sr = new StaticRange({startContainer: testDiv, startOffset: 0, endContainer: text, endOffset: 1});
+  testing.expectEqual(testDiv, sr.startContainer);
+  testing.expectEqual(0, sr.startOffset);
+  testing.expectEqual(text, sr.endContainer);
+  testing.expectEqual(1, sr.endOffset);
+}
+</script>
+
+<script id=construct_comment>
+{
+  const comment = document.createComment('abc');
+  const sr = new StaticRange({startContainer: comment, startOffset: 1, endContainer: comment, endOffset: 2});
+  testing.expectEqual(comment, sr.startContainer);
+  testing.expectEqual(2, sr.endOffset);
+}
+</script>
+
+<script id=construct_pi>
+{
+  const pi = document.createProcessingInstruction('foo', 'abc');
+  const sr = new StaticRange({startContainer: pi, startOffset: 1, endContainer: pi, endOffset: 2});
+  testing.expectEqual(pi, sr.startContainer);
+}
+</script>
+
+<script id=construct_document>
+{
+  const sr = new StaticRange({startContainer: document, startOffset: 0, endContainer: document, endOffset: 1});
+  testing.expectEqual(document, sr.startContainer);
+  testing.expectEqual(false, sr.collapsed);
+}
+</script>
+
+<script id=construct_fragment>
+{
+  const frag = document.createDocumentFragment();
+  const sr = new StaticRange({startContainer: frag, startOffset: 0, endContainer: frag, endOffset: 1});
+  testing.expectEqual(frag, sr.startContainer);
+}
+</script>
+
+<script id=collapsed>
+{
+  const testDiv = $('#testDiv');
+  const sr = new StaticRange({startContainer: testDiv, startOffset: 0, endContainer: testDiv, endOffset: 0});
+  testing.expectEqual(true, sr.collapsed);
+}
+</script>
+
+<script id=no_offset_validation>
+{
+  // StaticRange is static: it does NOT validate offsets against node length,
+  // nor reorder inverted endpoints (unlike Range).
+  const testDiv = $('#testDiv');
+  const sr = new StaticRange({startContainer: testDiv, startOffset: 0, endContainer: testDiv, endOffset: 15});
+  testing.expectEqual(0, sr.startOffset);
+  testing.expectEqual(15, sr.endOffset);
+
+  const inverted = new StaticRange({startContainer: testDiv, startOffset: 1, endContainer: document.body, endOffset: 0});
+  testing.expectEqual(testDiv, inverted.startContainer);
+  testing.expectEqual(document.body, inverted.endContainer);
+  testing.expectEqual(0, inverted.endOffset);
+}
+</script>
+
+<script id=prototype_chain>
+{
+  const testDiv = $('#testDiv');
+  const sr = new StaticRange({startContainer: testDiv, startOffset: 0, endContainer: testDiv, endOffset: 0});
+  testing.expectEqual(true, sr instanceof StaticRange);
+  testing.expectEqual(true, sr instanceof AbstractRange);
+  testing.expectEqual(false, sr instanceof Range);
+  // commonAncestorContainer is Range-only and must NOT leak onto StaticRange.
+  testing.expectEqual('undefined', typeof sr.commonAncestorContainer);
+  // ... but it remains on Range.
+  testing.expectEqual('object', typeof document.createRange().commonAncestorContainer);
+}
+</script>
+
+<script id=invalid_node_type>
+{
+  const testDiv = $('#testDiv');
+  testing.expectError('InvalidNodeTypeError', () => {
+    new StaticRange({startContainer: document.doctype, startOffset: 0, endContainer: document.doctype, endOffset: 0});
+  });
+  const attr = testDiv.getAttributeNode('id');
+  testing.expectError('InvalidNodeTypeError', () => {
+    new StaticRange({startContainer: attr, startOffset: 0, endContainer: attr, endOffset: 0});
+  });
+}
+</script>
+
+<script id=missing_arguments>
+{
+  const testDiv = $('#testDiv');
+  testing.expectError('TypeError', () => new StaticRange());
+  testing.expectError('TypeError', () => new StaticRange({startOffset: 0, endContainer: testDiv, endOffset: 0}));
+  testing.expectError('TypeError', () => new StaticRange({startContainer: testDiv, endContainer: testDiv, endOffset: 0}));
+  testing.expectError('TypeError', () => new StaticRange({startContainer: testDiv, startOffset: 0, endOffset: 0}));
+  testing.expectError('TypeError', () => new StaticRange({startContainer: testDiv, startOffset: 0, endContainer: testDiv}));
+  testing.expectError('TypeError', () => new StaticRange({startContainer: null, startOffset: 0, endContainer: testDiv, endOffset: 0}));
+  testing.expectError('TypeError', () => new StaticRange({startContainer: testDiv, startOffset: 0, endContainer: null, endOffset: 0}));
+}
+</script>
+</body>
diff --git a/src/browser/tests/window/replaceable.html b/src/browser/tests/window/replaceable.html
new file mode 100644
index 00000000..21828378
--- /dev/null
+++ b/src/browser/tests/window/replaceable.html
@@ -0,0 +1,33 @@
+<!DOCTYPE html>
+<script src="../testing.js"></script>
+
+<script id=replaceable>
+    "use strict";
+    // [Replaceable] attributes: assignment must replace the value (not throw,
+    // not silently no-op), even in strict mode, and survive being read first.
+    function checkReplaceable(name) {
+        const prev = window[name];
+        window[name] = "REPLACED:" + name;
+        testing.expectEqual("REPLACED:" + name, window[name]);
+        // now a writable own data property; this restores the original value.
+        window[name] = prev;
+        testing.expectEqual(true, window[name] === prev);
+    }
+    [
+        "console", "self", "frames", "parent", "length",
+        "scrollX", "scrollY", "pageXOffset", "pageYOffset",
+        "innerWidth", "innerHeight", "devicePixelRatio",
+    ].forEach(checkReplaceable);
+</script>
+
+<script id=not-replaceable>
+    "use strict";
+    // [LegacyUnforgeable] / plain readonly attributes must STILL throw on
+    // assignment in strict mode (location is excluded: it navigates).
+    function expectReadOnly(name) {
+        let threw = false;
+        try { window[name] = {}; } catch (e) { threw = true; }
+        testing.expectEqual(true, threw);
+    }
+    ["window", "top", "document", "navigator"].forEach(expectReadOnly);
+</script>
diff --git a/src/browser/tests/worker/replaceable-worker.js b/src/browser/tests/worker/replaceable-worker.js
new file mode 100644
index 00000000..525ded43
--- /dev/null
+++ b/src/browser/tests/worker/replaceable-worker.js
@@ -0,0 +1,27 @@
+// `console` and `self` are [Replaceable] on WorkerGlobalScope: assignment must
+// replace the value even in strict mode, rather than throwing through the
+// getter-only accessor. Capture the global in a local binding first, since
+// `self` is itself replaceable (reassigning it would break global lookups).
+(function () {
+  "use strict";
+  const g = self;
+  try {
+    const results = {};
+
+    const prevConsole = g.console;
+    g.console = { marker: 7 };
+    results.console_replaced = g.console.marker === 7;
+    g.console = prevConsole;
+    results.console_restored = g.console === prevConsole;
+
+    const prevSelf = g.self;
+    g.self = "REPLACED";
+    results.self_replaced = g.self === "REPLACED";
+    g.self = prevSelf;
+    results.self_restored = g.self === prevSelf;
+
+    g.postMessage({ ok: true, results });
+  } catch (e) {
+    g.postMessage({ ok: false, err: String(e) });
+  }
+})();
diff --git a/src/browser/tests/worker/worker.html b/src/browser/tests/worker/worker.html
index 8b15346a..cabe5d14 100644
--- a/src/browser/tests/worker/worker.html
+++ b/src/browser/tests/worker/worker.html
@@ -172,6 +172,25 @@
   }
 </script>
 
+<script id="worker_replaceable" type=module>
+  {
+    const state = await testing.async();
+    const worker = new Worker('./replaceable-worker.js');
+
+    worker.onmessage = function(event) {
+      state.resolve(event.data);
+    };
+
+    await state.done((data) => {
+      testing.expectTrue(data.ok, 'worker replaceable error: ' + data.err);
+      testing.expectEqual(true, data.results.console_replaced);
+      testing.expectEqual(true, data.results.console_restored);
+      testing.expectEqual(true, data.results.self_replaced);
+      testing.expectEqual(true, data.results.self_restored);
+    });
+  }
+</script>
+
 <script id="worker_webapi_net" type=module>
   {
     const state = await testing.async();
@@ -360,3 +379,25 @@
     });
   }
 </script>
+
+<script id="worker_from_blob_url" type=module>
+  // A blob: worker resolves its initial script through the HTTP client's
+  // synthetic-scheme path against the frame's blob registry, like any URL.
+  {
+    const state = await testing.async();
+    const blob = new Blob(["onmessage = (e) => postMessage({ echo: e.data, from: 'blob-worker' });"], { type: 'text/javascript' });
+    const blobUrl = URL.createObjectURL(blob);
+    const worker = new Worker(blobUrl);
+
+    worker.onmessage = function(event) {
+      state.resolve(event.data);
+    };
+    worker.postMessage({ greeting: 'from-blob' });
+
+    await state.done((response) => {
+      testing.expectEqual('from-blob', response.echo.greeting);
+      testing.expectEqual('blob-worker', response.from);
+      URL.revokeObjectURL(blobUrl);
+    });
+  }
+</script>
diff --git a/src/browser/webapi/AbortSignal.zig b/src/browser/webapi/AbortSignal.zig
index f6bd450f..88bc4ee4 100644
--- a/src/browser/webapi/AbortSignal.zig
+++ b/src/browser/webapi/AbortSignal.zig
@@ -130,7 +130,7 @@ fn markAborted(self: *AbortSignal, reason_: ?Reason, exec: *const Execution) !vo
 fn dispatchAbortEvent(self: *AbortSignal, exec: *const Execution) !void {
     const target = self.asEventTarget();
     const on_abort = self._on_abort;
-    switch (exec.context.global) {
+    switch (exec.js.global) {
         inline else => |g| {
             if (g._event_manager.hasDirectListeners(target, "abort", on_abort)) {
                 const event = try Event.initTrusted(comptime .wrap("abort"), .{}, g._page);
@@ -191,7 +191,7 @@ const ThrowIfAborted = union(enum) {
     undefined: void,
 };
 pub fn throwIfAborted(self: *const AbortSignal, exec: *const Execution) !ThrowIfAborted {
-    const local = exec.context.local.?;
+    const local = exec.js.local.?;
 
     if (self._aborted) {
         const exception = switch (self._reason) {
diff --git a/src/browser/webapi/AbstractRange.zig b/src/browser/webapi/AbstractRange.zig
index 2a530d9b..732acc7e 100644
--- a/src/browser/webapi/AbstractRange.zig
+++ b/src/browser/webapi/AbstractRange.zig
@@ -24,6 +24,7 @@ const Page = @import("../Page.zig");
 
 const Node = @import("Node.zig");
 const Range = @import("Range.zig");
+const StaticRange = @import("StaticRange.zig");
 
 const Allocator = std.mem.Allocator;
 
@@ -48,8 +49,11 @@ pub fn acquireRef(self: *AbstractRange) void {
 }
 
 pub fn deinit(self: *AbstractRange, page: *Page) void {
-    if (page.findFrameByLoaderId(self._frame_loader_id)) |frame| {
-        frame._live_ranges.remove(&self._range_link);
+    // StaticRanges are never registered in the live-range list
+    if (self._type != .static_range) {
+        if (page.findFrameByLoaderId(self._frame_loader_id)) |frame| {
+            frame._live_ranges.remove(&self._range_link);
+        }
     }
     page.releaseArena(self._arena);
 }
@@ -60,7 +64,7 @@ pub fn releaseRef(self: *AbstractRange, page: *Page) void {
 
 pub const Type = union(enum) {
     range: *Range,
-    // TODO: static_range: *StaticRange,
+    static_range: *StaticRange,
 };
 
 pub fn as(self: *AbstractRange, comptime T: type) *T {
@@ -70,6 +74,7 @@ pub fn as(self: *AbstractRange, comptime T: type) *T {
 pub fn is(self: *AbstractRange, comptime T: type) ?*T {
     switch (self._type) {
         .range => |r| return if (T == Range) r else null,
+        .static_range => |sr| return if (T == StaticRange) sr else null,
     }
 }
 
@@ -339,5 +344,4 @@ pub const JsApi = struct {
     pub const endContainer = bridge.accessor(AbstractRange.getEndContainer, null, .{});
     pub const endOffset = bridge.accessor(AbstractRange.getEndOffset, null, .{});
     pub const collapsed = bridge.accessor(AbstractRange.getCollapsed, null, .{});
-    pub const commonAncestorContainer = bridge.accessor(AbstractRange.getCommonAncestorContainer, null, .{});
 };
diff --git a/src/browser/webapi/Blob.zig b/src/browser/webapi/Blob.zig
index 4b393b50..df09e16d 100644
--- a/src/browser/webapi/Blob.zig
+++ b/src/browser/webapi/Blob.zig
@@ -261,7 +261,7 @@ pub fn writePartWithEndings(part: []const u8, use_native_endings: bool, writer:
 /// Returns a Promise that resolves with the contents of the blob
 /// as binary data contained in an ArrayBuffer.
 pub fn arrayBuffer(self: *const Blob, exec: *Execution) !js.Promise {
-    return exec.context.local.?.resolvePromise(js.ArrayBuffer{ .values = self._slice });
+    return exec.js.local.?.resolvePromise(js.ArrayBuffer{ .values = self._slice });
 }
 
 const ReadableStream = @import("streams/ReadableStream.zig");
@@ -274,7 +274,7 @@ pub fn stream(self: *const Blob, exec: *Execution) !*ReadableStream {
 /// Returns a Promise that resolves with a string containing
 /// the contents of the blob, interpreted as UTF-8.
 pub fn text(self: *const Blob, exec: *Execution) !js.Promise {
-    return exec.context.local.?.resolvePromise(self._slice);
+    return exec.js.local.?.resolvePromise(self._slice);
 }
 
 /// Extension to Blob; works on Firefox and Safari.
@@ -282,7 +282,7 @@ pub fn text(self: *const Blob, exec: *Execution) !js.Promise {
 /// Returns a Promise that resolves with a Uint8Array containing
 /// the contents of the blob as an array of bytes.
 pub fn bytes(self: *const Blob, exec: *Execution) !js.Promise {
-    return exec.context.local.?.resolvePromise(js.TypedArray(u8){ .values = self._slice });
+    return exec.js.local.?.resolvePromise(js.TypedArray(u8){ .values = self._slice });
 }
 
 /// Returns a new Blob object which contains data
diff --git a/src/browser/webapi/Console.zig b/src/browser/webapi/Console.zig
index b38a324e..23be6a1e 100644
--- a/src/browser/webapi/Console.zig
+++ b/src/browser/webapi/Console.zig
@@ -34,7 +34,7 @@ _counts: std.StringHashMapUnmanaged(u64) = .{},
 pub const init: Console = .{};
 
 fn dispatchConsoleMessage(values: []js.Value, console_type: Notification.ConsoleMessageType, exec: *js.Execution) void {
-    const notification = exec.context.page.session.notification;
+    const notification = exec.session.notification;
     const ts = datetime.timestamp(.monotonic);
 
     notification.dispatch(.console_message, &.{
@@ -54,7 +54,7 @@ fn dispatchConsoleMessage(values: []js.Value, console_type: Notification.Console
 
 pub fn trace(_: *const Console, values: []js.Value, exec: *js.Execution) !void {
     logger.debug(.js, "console.trace", .{
-        .stack = exec.context.local.?.stackTrace() catch "???",
+        .stack = exec.js.local.?.stackTrace() catch "???",
         .args = ValueWriter{ .values = values },
     });
     dispatchConsoleMessage(values, .trace, exec);
@@ -91,7 +91,7 @@ pub fn assert(_: *const Console, assertion: js.Value, values: []js.Value, exec:
 }
 
 pub fn @"error"(_: *const Console, values: []js.Value, exec: *js.Execution) void {
-    logger.warn(.js, "console.error", .{ValueWriter{ .values = values, .stack = exec.context.local.?.stackTrace() catch |err| @errorName(err) orelse "???" }});
+    logger.warn(.js, "console.error", .{ValueWriter{ .values = values, .stack = exec.js.local.?.stackTrace() catch |err| @errorName(err) orelse "???" }});
     dispatchConsoleMessage(values, .@"error", exec);
 }
 
diff --git a/src/browser/webapi/CustomElementDefinition.zig b/src/browser/webapi/CustomElementDefinition.zig
index 2e60a8ac..6b3eab48 100644
--- a/src/browser/webapi/CustomElementDefinition.zig
+++ b/src/browser/webapi/CustomElementDefinition.zig
@@ -36,6 +36,9 @@ observed_attributes: std.StringHashMapUnmanaged(void) = .{},
 // For autonomous custom elements, this is null
 extends: ?Element.Tag = null,
 
+// when disabledFeatures = ["shadow"], we'll throw if attachShadow is called
+disable_shadow: bool = false,
+
 pub fn isAttributeObserved(self: *const CustomElementDefinition, name: String) bool {
     return self.observed_attributes.contains(name.str());
 }
diff --git a/src/browser/webapi/CustomElementRegistry.zig b/src/browser/webapi/CustomElementRegistry.zig
index 4b2e0fe3..a1dbbf5e 100644
--- a/src/browser/webapi/CustomElementRegistry.zig
+++ b/src/browser/webapi/CustomElementRegistry.zig
@@ -81,6 +81,20 @@ pub fn define(self: *CustomElementRegistry, name: []const u8, constructor: js.Fu
         }
     }
 
+    // Read disabledFeatures static property: ["shadow"] makes attachShadow throw.
+    if (constructor.getPropertyValue("disabledFeatures") catch null) |disabled| {
+        if (disabled.isArray()) {
+            var js_arr = disabled.toArray();
+            for (0..js_arr.len()) |i| {
+                const val = js_arr.get(@intCast(i)) catch continue;
+                const feature = val.toSSO(false) catch continue;
+                if (feature.eql(comptime .wrap("shadow"))) {
+                    definition.disable_shadow = true;
+                }
+            }
+        }
+    }
+
     gop.key_ptr.* = owned_name;
     gop.value_ptr.* = definition;
 
diff --git a/src/browser/webapi/DOMParser.zig b/src/browser/webapi/DOMParser.zig
index 8ab2fb9d..c85b497d 100644
--- a/src/browser/webapi/DOMParser.zig
+++ b/src/browser/webapi/DOMParser.zig
@@ -77,7 +77,7 @@ pub fn parseFromString(
             }
 
             // Parse HTML into the document
-            var parser = Parser.init(arena, doc.asNode(), frame);
+            var parser = Parser.init(arena, doc.asNode(), frame, .{});
             parser.parse(normalized);
 
             if (parser.err) |pe| {
@@ -94,13 +94,13 @@ pub fn parseFromString(
 
             // Parse XML into XMLDocument.
             const doc_node = doc.asNode();
-            var parser = Parser.init(arena, doc_node, frame);
+            var parser = Parser.init(arena, doc_node, frame, .{});
             parser.parseXML(html);
 
             if (parser.err != null or doc_node.firstChild() == null) {
                 // Return a document with a <parsererror> element per spec.
                 const err_doc = try frame._factory.document(XMLDocument{ ._proto = undefined });
-                var err_parser = Parser.init(arena, err_doc.asNode(), frame);
+                var err_parser = Parser.init(arena, err_doc.asNode(), frame, .{});
                 err_parser.parseXML("<parsererror xmlns=\"http://www.mozilla.org/newlayout/xml/parsererror.xml\">error</parsererror>");
                 return err_doc.asDocument();
             }
diff --git a/src/browser/webapi/Document.zig b/src/browser/webapi/Document.zig
index 6cd67392..44f777a4 100644
--- a/src/browser/webapi/Document.zig
+++ b/src/browser/webapi/Document.zig
@@ -786,7 +786,7 @@ fn writeInternal(self: *Document, text: []const []const u8, append_newline: bool
     const arena = try frame.getArena(.medium, "Document.write");
     defer frame.releaseArena(arena);
 
-    var parser = Parser.init(arena, fragment_node, frame);
+    var parser = Parser.init(arena, fragment_node, frame, .{ .allow_declarative_shadow = true });
     parser.parseFragment(html);
 
     // Extract children from wrapper HTML element (html5ever wraps fragments)
@@ -873,7 +873,7 @@ pub fn open(self: *Document, call_frame: *Frame) !*Document {
     self._implementation = null;
     self._ready_state = .loading;
 
-    self._script_created_parser = Parser.Streaming.init(frame.arena, doc_node, frame);
+    self._script_created_parser = Parser.Streaming.init(frame.arena, doc_node, frame, .{ .allow_declarative_shadow = true });
     try self._script_created_parser.?.start();
     frame._parse_mode = .document;
 
diff --git a/src/browser/webapi/DocumentFragment.zig b/src/browser/webapi/DocumentFragment.zig
index cc692649..324af261 100644
--- a/src/browser/webapi/DocumentFragment.zig
+++ b/src/browser/webapi/DocumentFragment.zig
@@ -153,18 +153,13 @@ pub fn getInnerHTML(self: *DocumentFragment, writer: *std.Io.Writer, frame: *Fra
 
 pub fn setInnerHTML(self: *DocumentFragment, html: []const u8, frame: *Frame) !void {
     const parent = self.asNode();
+    return parent.setHTML(html, false, frame);
+}
 
-    frame.domChanged();
-    var it = parent.childrenIterator();
-    while (it.next()) |child| {
-        frame.removeNode(parent, child, .{ .will_be_reconnected = false });
-    }
-
-    if (html.len == 0) {
-        return;
-    }
-
-    try frame.parseHtmlAsChildren(parent, html);
+/// allows declarative shadow dom
+pub fn setHTMLUnsafe(self: *DocumentFragment, html: []const u8, frame: *Frame) !void {
+    const parent = self.asNode();
+    return parent.setHTML(html, true, frame);
 }
 
 pub fn cloneFragment(self: *DocumentFragment, deep: bool, frame: *Frame) !*Node {
diff --git a/src/browser/webapi/Element.zig b/src/browser/webapi/Element.zig
index 98eef93a..3a26798e 100644
--- a/src/browser/webapi/Element.zig
+++ b/src/browser/webapi/Element.zig
@@ -484,18 +484,13 @@ pub fn getInnerHTML(self: *Element, writer: *std.Io.Writer, frame: *Frame) !void
 
 pub fn setInnerHTML(self: *Element, html: []const u8, frame: *Frame) !void {
     const parent = self.asNode();
+    return parent.setHTML(html, false, frame);
+}
 
-    frame.domChanged();
-    var it = parent.childrenIterator();
-    while (it.next()) |child| {
-        frame.removeNode(parent, child, .{ .will_be_reconnected = false });
-    }
-
-    if (html.len == 0) {
-        return;
-    }
-
-    try frame.parseHtmlAsChildren(parent, html);
+/// allows declarative shadow dom
+pub fn setHTMLUnsafe(self: *Element, html: []const u8, frame: *Frame) !void {
+    const parent = self.asNode();
+    return parent.setHTML(html, true, frame);
 }
 
 pub fn getId(self: *const Element) []const u8 {
@@ -726,11 +721,41 @@ pub fn getAssignedSlot(self: *Element, frame: *Frame) ?*Html.Slot {
     return frame._element_assigned_slots.get(self);
 }
 
-pub fn attachShadow(self: *Element, mode_str: []const u8, frame: *Frame) !*ShadowRoot {
-    if (frame._element_shadow_roots.get(self)) |_| {
-        return error.AlreadyHasShadowRoot;
+// Whether this element may host a shadow root
+fn isValidShadowHost(self: *const Element) bool {
+    if (self._namespace != .html) {
+        return false;
     }
-    const mode = try ShadowRoot.Mode.fromString(mode_str);
+
+    return switch (self.getTag()) {
+        .article, .aside, .blockquote, .body, .div, .footer, .header, .main, .nav, .p, .section, .span, .h1, .h2, .h3, .h4, .h5, .h6, .custom => true,
+        else => false,
+    };
+}
+
+pub fn attachShadow(self: *Element, mode_str: String, frame: *Frame) !*ShadowRoot {
+    if (frame._element_shadow_roots.get(self)) |_| {
+        return error.NotSupported;
+    }
+    if (!self.isValidShadowHost()) {
+        return error.NotSupported;
+    }
+
+    // A custom element whose definition lists "shadow" in disabledFeatures
+    // cannot host a shadow root (imperative or declarative).
+    if (self.is(Html.Custom)) |custom| {
+        if (frame.window._custom_elements._definitions.get(custom._tag_name.str())) |def| {
+            if (def.disable_shadow) {
+                return error.NotSupported;
+            }
+        }
+    }
+    const mode: ShadowRoot.Mode = blk: {
+        if (mode_str.eql(comptime .wrap("open"))) break :blk .open;
+        if (mode_str.eql(comptime .wrap("closed"))) break :blk .closed;
+        return error.InvalidArgument;
+    };
+
     const shadow_root = try ShadowRoot.init(self, mode, frame);
     try frame._element_shadow_roots.put(frame.arena, self, shadow_root);
     return shadow_root;
@@ -1792,11 +1817,12 @@ pub const JsApi = struct {
     pub const assignedSlot = bridge.accessor(Element.getAssignedSlot, null, .{});
     pub const attachShadow = bridge.function(_attachShadow, .{ .dom_exception = true });
     pub const insertAdjacentHTML = bridge.function(Element.insertAdjacentHTML, .{ .dom_exception = true, .ce_reactions = true });
+    pub const setHTMLUnsafe = bridge.function(Element.setHTMLUnsafe, .{ .dom_exception = true, .ce_reactions = true });
     pub const insertAdjacentElement = bridge.function(Element.insertAdjacentElement, .{ .dom_exception = true, .ce_reactions = true });
     pub const insertAdjacentText = bridge.function(Element.insertAdjacentText, .{ .dom_exception = true, .ce_reactions = true });
 
     const ShadowRootInit = struct {
-        mode: []const u8,
+        mode: String,
     };
     fn _attachShadow(self: *Element, init: ShadowRootInit, frame: *Frame) !*ShadowRoot {
         return self.attachShadow(init.mode, frame);
diff --git a/src/browser/webapi/Event.zig b/src/browser/webapi/Event.zig
index 5e66e42d..a59c2210 100644
--- a/src/browser/webapi/Event.zig
+++ b/src/browser/webapi/Event.zig
@@ -329,7 +329,7 @@ pub fn composedPath(self: *Event, exec: *Execution) ![]const *EventTarget {
     // Add window at the end (unless we stopped at shadow boundary)
     if (!stopped_at_shadow_boundary) {
         if (path_len < path_buffer.len) {
-            switch (exec.context.global) {
+            switch (exec.js.global) {
                 .worker => {},
                 .frame => |frame| {
                     path_buffer[path_len] = frame.window.asEventTarget();
diff --git a/src/browser/webapi/EventTarget.zig b/src/browser/webapi/EventTarget.zig
index 4c18cd31..01505d5e 100644
--- a/src/browser/webapi/EventTarget.zig
+++ b/src/browser/webapi/EventTarget.zig
@@ -63,7 +63,7 @@ pub fn dispatchEvent(self: *EventTarget, event: *Event, exec: *js.Execution) !bo
     }
     event._is_trusted = false;
 
-    switch (exec.context.global) {
+    switch (exec.js.global) {
         .frame => |frame| {
             event.acquireRef();
             defer _ = event.releaseRef(frame._page);
@@ -99,7 +99,7 @@ pub fn addEventListener(self: *EventTarget, typ: []const u8, callback_: ?EventLi
         };
     };
 
-    switch (exec.context.global) {
+    switch (exec.js.global) {
         inline else => |g| _ = try g._event_manager.register(self, typ, em_callback, options),
     }
 }
@@ -135,7 +135,7 @@ pub fn removeEventListener(self: *EventTarget, typ: []const u8, callback_: ?Even
         };
     };
 
-    switch (exec.context.global) {
+    switch (exec.js.global) {
         inline else => |g| g._event_manager.remove(self, typ, em_callback, use_capture),
     }
 }
diff --git a/src/browser/webapi/FileReader.zig b/src/browser/webapi/FileReader.zig
index 3c352443..9924f4ac 100644
--- a/src/browser/webapi/FileReader.zig
+++ b/src/browser/webapi/FileReader.zig
@@ -257,7 +257,7 @@ fn dispatch(self: *FileReader, comptime event_type: DispatchType, progress_: ?Pr
     const event = (try ProgressEvent.initTrusted(
         comptime .wrap(typ),
         .{ .total = progress.total, .loaded = progress.loaded },
-        exec.context.page,
+        exec.page,
     )).asEvent();
 
     return exec.dispatch(
diff --git a/src/browser/webapi/ImageData.zig b/src/browser/webapi/ImageData.zig
index b295a7e7..333630e8 100644
--- a/src/browser/webapi/ImageData.zig
+++ b/src/browser/webapi/ImageData.zig
@@ -80,7 +80,7 @@ pub fn init(
     return exec._factory.create(ImageData{
         ._width = width,
         ._height = height,
-        ._data = try exec.context.local.?.createTypedArray(.uint8_clamped, size).persist(),
+        ._data = try exec.js.local.?.createTypedArray(.uint8_clamped, size).persist(),
     });
 }
 
diff --git a/src/browser/webapi/ModelContext.zig b/src/browser/webapi/ModelContext.zig
index 19323a3f..ae79fb4b 100644
--- a/src/browser/webapi/ModelContext.zig
+++ b/src/browser/webapi/ModelContext.zig
@@ -121,7 +121,7 @@ pub fn registerTool(
     // native MCP forwarder) can surface the new tool.
     const event: Notification.ModelContextToolEvent = .{ .exec = exec, .tool = entry };
 
-    const session = switch (exec.context.global) {
+    const session = switch (exec.js.global) {
         inline else => |g| g._session,
     };
 
@@ -147,7 +147,7 @@ pub fn findTool(self: *ModelContext, name: []const u8) ?*Tool {
 /// dispatching `model_context_tool_removed` for each. Cheap when no
 /// signals fired (which is the common case).
 fn markAborted(self: *ModelContext, tool: *Tool, exec: *const Execution) !void {
-    const session = switch (exec.context.global) {
+    const session = switch (exec.js.global) {
         inline else => |g| g._session,
     };
 
@@ -191,7 +191,7 @@ pub const ModelContextClient = struct {
         exec: *const Execution,
     ) !js.Promise {
         var ls: js.Local.Scope = undefined;
-        exec.context.global.getJs().localScope(&ls);
+        exec.js.global.getJs().localScope(&ls);
         defer ls.deinit();
         const resolver = ls.local.createPromiseResolver();
 
diff --git a/src/browser/webapi/Navigator.zig b/src/browser/webapi/Navigator.zig
index c51e3da2..958fd109 100644
--- a/src/browser/webapi/Navigator.zig
+++ b/src/browser/webapi/Navigator.zig
@@ -48,6 +48,62 @@ pub fn getLanguages(_: *const Navigator) [2][]const u8 {
     return .{ "en-US", "en" };
 }
 
+pub fn getDoNotTrack(_: *const Navigator) ?[]const u8 {
+    return null;
+}
+
+pub fn getAppName(_: *const Navigator) []const u8 {
+    return "Netscape";
+}
+
+pub fn getAppCodeName(_: *const Navigator) []const u8 {
+    return "Mozilla";
+}
+
+pub fn getAppVersion(_: *const Navigator) []const u8 {
+    return "1.0";
+}
+
+pub fn getLanguage(_: *const Navigator) []const u8 {
+    return "en-US";
+}
+
+pub fn getOnLine(_: *const Navigator) bool {
+    return true;
+}
+
+pub fn getCookieEnabled(_: *const Navigator) bool {
+    return true;
+}
+
+pub fn getHardwareConcurrency(_: *const Navigator) u32 {
+    return 4;
+}
+
+pub fn getDeviceMemory(_: *const Navigator) f64 {
+    return 8.0;
+}
+
+pub fn getMaxTouchPoints(_: *const Navigator) u32 {
+    return 0;
+}
+
+pub fn getVendor(_: *const Navigator) []const u8 {
+    return "";
+}
+
+pub fn getProduct(_: *const Navigator) []const u8 {
+    return "Gecko";
+}
+
+pub fn getWebdriver(_: *const Navigator) bool {
+    return false;
+}
+
+pub fn getGlobalPrivacyControl(_: *const Navigator) bool {
+    return true;
+}
+
 pub fn getPlatform(_: *const Navigator) []const u8 {
     return switch (builtin.os.tag) {
         .macos => "MacIntel",
@@ -166,25 +222,27 @@ pub const JsApi = struct {
         pub const empty_with_no_proto = true;
     };
 
-    // Read-only properties
+    // Read-only properties. All are accessors (not data properties) so they
+    // present as native getters on Navigator.prototype, matching real browsers
+    // — see the getter definitions above for why.
     pub const userAgent = bridge.accessor(Navigator.getUserAgent, null, .{});
-    pub const appName = bridge.property("Netscape", .{ .template = false });
-    pub const appCodeName = bridge.property("Mozilla", .{ .template = false });
-    pub const appVersion = bridge.property("1.0", .{ .template = false });
+    pub const appName = bridge.accessor(Navigator.getAppName, null, .{});
+    pub const appCodeName = bridge.accessor(Navigator.getAppCodeName, null, .{});
+    pub const appVersion = bridge.accessor(Navigator.getAppVersion, null, .{});
     pub const platform = bridge.accessor(Navigator.getPlatform, null, .{});
-    pub const language = bridge.property("en-US", .{ .template = false });
+    pub const language = bridge.accessor(Navigator.getLanguage, null, .{});
     pub const languages = bridge.accessor(Navigator.getLanguages, null, .{});
-    pub const onLine = bridge.property(true, .{ .template = false });
-    pub const cookieEnabled = bridge.property(true, .{ .template = false });
-    pub const hardwareConcurrency = bridge.property(4, .{ .template = false });
-    pub const deviceMemory = bridge.property(@as(f64, 8.0), .{ .template = false });
-    pub const maxTouchPoints = bridge.property(0, .{ .template = false });
-    pub const vendor = bridge.property("", .{ .template = false });
-    pub const product = bridge.property("Gecko", .{ .template = false });
-    pub const webdriver = bridge.property(false, .{ .template = false });
+    pub const onLine = bridge.accessor(Navigator.getOnLine, null, .{});
+    pub const cookieEnabled = bridge.accessor(Navigator.getCookieEnabled, null, .{});
+    pub const hardwareConcurrency = bridge.accessor(Navigator.getHardwareConcurrency, null, .{});
+    pub const deviceMemory = bridge.accessor(Navigator.getDeviceMemory, null, .{});
+    pub const maxTouchPoints = bridge.accessor(Navigator.getMaxTouchPoints, null, .{});
+    pub const vendor = bridge.accessor(Navigator.getVendor, null, .{});
+    pub const product = bridge.accessor(Navigator.getProduct, null, .{});
+    pub const webdriver = bridge.accessor(Navigator.getWebdriver, null, .{});
     pub const plugins = bridge.accessor(Navigator.getPlugins, null, .{});
-    pub const doNotTrack = bridge.property(null, .{ .template = false });
-    pub const globalPrivacyControl = bridge.property(true, .{ .template = false });
+    pub const doNotTrack = bridge.accessor(Navigator.getDoNotTrack, null, .{});
+    pub const globalPrivacyControl = bridge.accessor(Navigator.getGlobalPrivacyControl, null, .{});
     pub const registerProtocolHandler = bridge.function(Navigator.registerProtocolHandler, .{ .dom_exception = true });
     pub const unregisterProtocolHandler = bridge.function(Navigator.unregisterProtocolHandler, .{ .dom_exception = true });
 
diff --git a/src/browser/webapi/Node.zig b/src/browser/webapi/Node.zig
index 00779af0..c57913aa 100644
--- a/src/browser/webapi/Node.zig
+++ b/src/browser/webapi/Node.zig
@@ -1076,6 +1076,25 @@ pub fn replaceChildren(self: *Node, nodes: []const NodeOrText, frame: *Frame) !v
     }
 }
 
+/// Shared implementation in Element and DocumentFragment
+pub fn setHTML(self: *Node, html: []const u8, allow_declarative_shadow: bool, frame: *Frame) !void {
+    frame.domChanged();
+    var it = self.childrenIterator();
+    while (it.next()) |child| {
+        frame.removeNode(self, child, .{ .will_be_reconnected = false });
+    }
+
+    if (html.len == 0) {
+        return;
+    }
+
+    if (allow_declarative_shadow) {
+        try frame.parseHtmlUnsafeAsChildren(self, html);
+    } else {
+        try frame.parseHtmlAsChildren(self, html);
+    }
+}
+
 // Writes a JSON representation of the node and its children
 pub fn jsonStringify(self: *const Node, writer: *std.json.Stringify) !void {
     // stupid json api requires this to be const,
diff --git a/src/browser/webapi/PerformanceObserver.zig b/src/browser/webapi/PerformanceObserver.zig
index d4a2de53..1c879e38 100644
--- a/src/browser/webapi/PerformanceObserver.zig
+++ b/src/browser/webapi/PerformanceObserver.zig
@@ -61,7 +61,7 @@ pub fn init(callback: js.Function.Global, exec: *const Execution) !*PerformanceO
         ._interests = 0,
         ._entries = .{},
         ._performance = exec.performance(),
-        ._js = exec.context,
+        ._js = exec.js,
         ._arena = exec.arena,
     });
 }
diff --git a/src/browser/webapi/Range.zig b/src/browser/webapi/Range.zig
index 2a367093..e7c76873 100644
--- a/src/browser/webapi/Range.zig
+++ b/src/browser/webapi/Range.zig
@@ -43,6 +43,10 @@ pub fn asAbstractRange(self: *Range) *AbstractRange {
     return self._proto;
 }
 
+pub fn getCommonAncestorContainer(self: *const Range) *Node {
+    return self._proto.getCommonAncestorContainer();
+}
+
 pub fn setStart(self: *Range, node: *Node, offset: u32) !void {
     if (node._type == .document_type) {
         return error.InvalidNodeType;
@@ -703,6 +707,7 @@ pub const JsApi = struct {
     pub const END_TO_START = bridge.property(3, .{ .template = true });
 
     pub const constructor = bridge.constructor(Range.init, .{});
+    pub const commonAncestorContainer = bridge.accessor(Range.getCommonAncestorContainer, null, .{});
     pub const setStart = bridge.function(Range.setStart, .{ .dom_exception = true });
     pub const setEnd = bridge.function(Range.setEnd, .{ .dom_exception = true });
     pub const setStartBefore = bridge.function(Range.setStartBefore, .{ .dom_exception = true });
diff --git a/src/browser/webapi/ShadowRoot.zig b/src/browser/webapi/ShadowRoot.zig
index 3af7ccfe..53e19289 100644
--- a/src/browser/webapi/ShadowRoot.zig
+++ b/src/browser/webapi/ShadowRoot.zig
@@ -29,10 +29,6 @@ const ShadowRoot = @This();
 pub const Mode = enum {
     open,
     closed,
-
-    pub fn fromString(str: []const u8) !Mode {
-        return std.meta.stringToEnum(Mode, str) orelse error.InvalidMode;
-    }
 };
 
 _proto: *DocumentFragment,
@@ -70,6 +66,10 @@ pub fn getHost(self: *const ShadowRoot) *Element {
     return self._host;
 }
 
+pub fn setHTMLUnsafe(self: *ShadowRoot, html: []const u8, frame: *Frame) !void {
+    return self.asDocumentFragment().setHTMLUnsafe(html, frame);
+}
+
 pub fn getElementById(self: *ShadowRoot, id: []const u8, frame: *Frame) ?*Element {
     if (id.len == 0) {
         return null;
@@ -137,6 +137,7 @@ pub const JsApi = struct {
         return self.getElementById(try value.toZig([]const u8), frame);
     }
     pub const adoptedStyleSheets = bridge.accessor(ShadowRoot.getAdoptedStyleSheets, ShadowRoot.setAdoptedStyleSheets, .{});
+    pub const setHTMLUnsafe = bridge.function(ShadowRoot.setHTMLUnsafe, .{ .dom_exception = true, .ce_reactions = true });
 };
 
 const testing = @import("../../testing.zig");
diff --git a/src/browser/webapi/StaticRange.zig b/src/browser/webapi/StaticRange.zig
new file mode 100644
index 00000000..a9e5997b
--- /dev/null
+++ b/src/browser/webapi/StaticRange.zig
@@ -0,0 +1,85 @@
+// Copyright (C) 2023-2025  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// 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 js = @import("../js/js.zig");
+const Frame = @import("../Frame.zig");
+
+const Node = @import("Node.zig");
+const AbstractRange = @import("AbstractRange.zig");
+
+const StaticRange = @This();
+
+// The boundary points and `collapsed` accessor live on the shared AbstractRange
+// prototype. Unlike Range, a StaticRange is *static*: the factory keeps it out
+// of the frame's live-range list, so DOM mutations never move its boundaries.
+_proto: *AbstractRange,
+
+// https://dom.spec.whatwg.org/#dictdef-staticrangeinit
+// All members are required. The fields are non-optional with no default, so the
+// argument decoder rejects a missing or null member with a TypeError.
+pub const StaticRangeInit = struct {
+    startContainer: *Node,
+    startOffset: u32,
+    endContainer: *Node,
+    endOffset: u32,
+};
+
+pub fn init(opts: StaticRangeInit, frame: *Frame) !*StaticRange {
+    // https://dom.spec.whatwg.org/#dom-staticrange-staticrange
+    // Throw InvalidNodeTypeError if either container is a DocumentType or Attr.
+    // Note: offsets are stored verbatim — StaticRange does no length validation.
+    if (isInvalidContainer(opts.startContainer) or isInvalidContainer(opts.endContainer)) {
+        return error.InvalidNodeType;
+    }
+
+    const arena = try frame.getArena(.medium, "StaticRange");
+    errdefer frame.releaseArena(arena);
+
+    const static_range = try frame._factory.abstractRange(arena, StaticRange{ ._proto = undefined }, frame);
+    const proto = static_range._proto;
+    proto._start_container = opts.startContainer;
+    proto._start_offset = opts.startOffset;
+    proto._end_container = opts.endContainer;
+    proto._end_offset = opts.endOffset;
+    return static_range;
+}
+
+fn isInvalidContainer(node: *Node) bool {
+    return node._type == .document_type or node._type == .attribute;
+}
+
+pub fn asAbstractRange(self: *StaticRange) *AbstractRange {
+    return self._proto;
+}
+
+pub const JsApi = struct {
+    pub const bridge = js.Bridge(StaticRange);
+
+    pub const Meta = struct {
+        pub const name = "StaticRange";
+        pub const prototype_chain = bridge.prototypeChain();
+        pub var class_id: bridge.ClassId = undefined;
+    };
+
+    pub const constructor = bridge.constructor(StaticRange.init, .{ .dom_exception = true });
+};
+
+const testing = @import("../../testing.zig");
+test "WebApi: StaticRange" {
+    try testing.htmlRunner("staticrange.html", .{});
+}
diff --git a/src/browser/webapi/SubtleCrypto.zig b/src/browser/webapi/SubtleCrypto.zig
index 3220352c..242938aa 100644
--- a/src/browser/webapi/SubtleCrypto.zig
+++ b/src/browser/webapi/SubtleCrypto.zig
@@ -51,7 +51,7 @@ pub fn generateKey(
     key_usages: []const []const u8,
     exec: *const Execution,
 ) !js.Promise {
-    const local = exec.context.local.?;
+    const local = exec.js.local.?;
     switch (algo) {
         .hmac_key_gen => |params| return HMAC.init(params, extractable, key_usages, exec),
         .aes_key_gen => |params| {
@@ -87,7 +87,7 @@ fn generateKeyFromName(
     exec: *const Execution,
 ) !js.Promise {
     return _generateKeyFromName(name, extractable, key_usages, exec) catch |err| {
-        return exec.context.local.?.rejectPromise(.{ .dom_exception = .{ .err = err } });
+        return exec.js.local.?.rejectPromise(.{ .dom_exception = .{ .err = err } });
     };
 }
 
@@ -147,7 +147,7 @@ pub fn exportKey(
     key: *CryptoKey,
     exec: *const Execution,
 ) !js.Promise {
-    const local = exec.context.local.?;
+    const local = exec.js.local.?;
     if (!key.canExportKey()) {
         return local.rejectPromise(.{ .dom_exception = .{ .err = error.InvalidAccessError } });
     }
@@ -175,7 +175,7 @@ pub fn deriveBits(
     length: usize,
     exec: *const Execution,
 ) !js.Promise {
-    const local = exec.context.local.?;
+    const local = exec.js.local.?;
     return switch (algo) {
         .ecdh_or_x25519 => |params| {
             const name = params.name;
@@ -213,7 +213,7 @@ pub fn sign(
         .hmac => return HMAC.sign(algo, key, data, exec),
         else => {
             log.warn(.not_implemented, "SubtleCrypto.sign", .{ .key_type = key._type });
-            return exec.context.local.?.rejectPromise(.{ .dom_exception = .{ .err = error.InvalidAccessError } });
+            return exec.js.local.?.rejectPromise(.{ .dom_exception = .{ .err = error.InvalidAccessError } });
         },
     };
 }
@@ -227,7 +227,7 @@ pub fn verify(
     data: []const u8, // ArrayBuffer.
     exec: *const Execution,
 ) !js.Promise {
-    const local = exec.context.local.?;
+    const local = exec.js.local.?;
     if (!algo.isHMAC()) {
         return local.rejectPromise(.{ .dom_exception = .{ .err = error.InvalidAccessError } });
     }
@@ -240,7 +240,7 @@ pub fn verify(
 
 /// Generates a digest of the given data, using the specified hash function.
 pub fn digest(_: *const SubtleCrypto, algo: []const u8, data: js.TypedArray(u8), exec: *const Execution) !js.Promise {
-    const local = exec.context.local.?;
+    const local = exec.js.local.?;
 
     if (algo.len > 10) {
         return local.rejectPromise(.{ .dom_exception = .{ .err = error.NotSupported } });
diff --git a/src/browser/webapi/Timers.zig b/src/browser/webapi/Timers.zig
index 1793b2a6..f3ac1c61 100644
--- a/src/browser/webapi/Timers.zig
+++ b/src/browser/webapi/Timers.zig
@@ -108,7 +108,7 @@ pub fn schedule(
     };
     gop.value_ptr.* = callback;
 
-    try exec.context.scheduler.add(callback, ScheduleCallback.run, delay_ms, .{
+    try exec.js.scheduler.add(callback, ScheduleCallback.run, delay_ms, .{
         .name = opts.name,
         .low_priority = opts.low_priority,
         .finalizer = ScheduleCallback.cancelled,
@@ -135,7 +135,7 @@ pub const LegacyHandler = union(enum) {
         switch (handler) {
             .function => |fun| return fun,
             .string => |str| {
-                const fun = try exec.context.local.?.compileFunction(str, &.{}, &.{});
+                const fun = try exec.js.local.?.compileFunction(str, &.{}, &.{});
                 return fun.temp();
             },
         }
@@ -182,7 +182,7 @@ const ScheduleCallback = struct {
         }
 
         var ls: js.Local.Scope = undefined;
-        self.exec.context.localScope(&ls);
+        self.exec.js.localScope(&ls);
         defer ls.deinit();
 
         switch (self.mode) {
@@ -195,7 +195,7 @@ const ScheduleCallback = struct {
             .animation_frame => {
                 // requestAnimationFrame is window-only; if a worker ever
                 // schedules with this mode it's a programming error.
-                const window = switch (self.exec.context.global) {
+                const window = switch (self.exec.js.global) {
                     .frame => |frame| frame.window,
                     .worker => unreachable,
                 };
diff --git a/src/browser/webapi/URL.zig b/src/browser/webapi/URL.zig
index ba8a6083..6ca775ff 100644
--- a/src/browser/webapi/URL.zig
+++ b/src/browser/webapi/URL.zig
@@ -251,7 +251,7 @@ pub fn createObjectURL(blob: *Blob, exec: *const Execution) ![]const u8 {
     var uuid_buf: [36]u8 = undefined;
     @import("../../id.zig").uuidv4(&uuid_buf);
 
-    switch (exec.context.global) {
+    switch (exec.js.global) {
         inline else => |g| {
             const blob_url = try std.fmt.allocPrint(
                 g.arena,
@@ -271,7 +271,7 @@ pub fn revokeObjectURL(url: []const u8, exec: *const Execution) void {
         return;
     }
 
-    switch (exec.context.global) {
+    switch (exec.js.global) {
         inline else => |g| {
             if (g._blob_urls.fetchRemove(url)) |entry| {
                 entry.value.releaseRef(g._page);
diff --git a/src/browser/webapi/Window.zig b/src/browser/webapi/Window.zig
index 6e8be504..f6bef76c 100644
--- a/src/browser/webapi/Window.zig
+++ b/src/browser/webapi/Window.zig
@@ -39,6 +39,7 @@ const Event = @import("Event.zig");
 const EventTarget = @import("EventTarget.zig");
 const ErrorEvent = @import("event/ErrorEvent.zig");
 const MessageEvent = @import("event/MessageEvent.zig");
+const MessagePort = @import("MessagePort.zig");
 const MediaQueryList = @import("css/MediaQueryList.zig");
 const storage = @import("storage/storage.zig");
 const Element = @import("Element.zig");
@@ -168,6 +169,42 @@ pub fn getConsole(self: *Window) *Console {
     return &self._console;
 }
 
+pub fn setConsole(_: *Window, value: js.Value) void {
+    replaceGlobalProperty(value, "console");
+}
+
+pub fn setSelf(_: *Window, value: js.Value) void {
+    replaceGlobalProperty(value, "self");
+}
+
+pub fn setFrames(_: *Window, value: js.Value) void {
+    replaceGlobalProperty(value, "frames");
+}
+
+pub fn setParent(_: *Window, value: js.Value) void {
+    replaceGlobalProperty(value, "parent");
+}
+
+pub fn setLength(_: *Window, value: js.Value) void {
+    replaceGlobalProperty(value, "length");
+}
+
+pub fn setScrollX(_: *Window, value: js.Value) void {
+    replaceGlobalProperty(value, "scrollX");
+}
+
+pub fn setScrollY(_: *Window, value: js.Value) void {
+    replaceGlobalProperty(value, "scrollY");
+}
+
+pub fn setPageXOffset(_: *Window, value: js.Value) void {
+    replaceGlobalProperty(value, "pageXOffset");
+}
+
+pub fn setPageYOffset(_: *Window, value: js.Value) void {
+    replaceGlobalProperty(value, "pageYOffset");
+}
+
 pub fn getNavigator(self: *Window) *Navigator {
     return &self._navigator;
 }
@@ -561,7 +598,7 @@ pub fn close(self: *Window) void {
     };
 }
 
-pub fn postMessage(self: *Window, message: js.Value.Temp, target_origin: ?[]const u8, frame: *Frame) !void {
+pub fn postMessage(self: *Window, message: js.Value.Temp, target_origin: ?[]const u8, transfer: ?[]const *MessagePort, frame: *Frame) !void {
     // For now, we ignore targetOrigin checking and just dispatch the message
     // In a full implementation, we would validate the origin
     _ = target_origin;
@@ -581,6 +618,7 @@ pub fn postMessage(self: *Window, message: js.Value.Temp, target_origin: ?[]cons
         .frame = target_frame,
         .source = source_window,
         .origin = try arena.dupe(u8, origin),
+        .ports = if (transfer) |t| try arena.dupe(*MessagePort, t) else &.{},
     };
 
     try target_frame.js.scheduler.add(callback, PostMessageCallback.run, 0, .{
@@ -763,6 +801,14 @@ pub fn unhandledPromiseRejection(self: *Window, no_handler: bool, rejection: js.
     }
 }
 
+// `console` and a handful of other Window attributes are [Replaceable]: assigning
+// to them redefines the attribute as an own data property on the global instead
+// of throwing (which a getter-only accessor does in strict mode / modules).
+fn replaceGlobalProperty(value: js.Value, comptime name: []const u8) void {
+    const global = value.local.getGlobal();
+    _ = global.defineOwnProperty(name, value, 0);
+}
+
 pub const Access = union(enum) {
     window: *Window,
     cross_origin: *CrossOriginWindow,
@@ -788,6 +834,7 @@ const PostMessageCallback = struct {
     arena: Allocator,
     origin: []const u8,
     message: js.Value.Temp,
+    ports: []const *MessagePort,
 
     fn deinit(self: *PostMessageCallback) void {
         self.frame.releaseArena(self.arena);
@@ -811,6 +858,7 @@ const PostMessageCallback = struct {
                 .data = .{ .value = self.message },
                 .origin = self.origin,
                 .source = self.source,
+                .ports = self.ports,
                 .bubbles = false,
                 .cancelable = false,
             }, frame._page)).asEvent();
@@ -861,12 +909,12 @@ pub const JsApi = struct {
     };
 
     pub const document = bridge.accessor(Window.getDocument, null, .{ .cache = .{ .internal = 1 }, .deletable = false });
-    pub const console = bridge.accessor(Window.getConsole, null, .{ .cache = .{ .internal = 2 } });
+    pub const console = bridge.accessor(Window.getConsole, Window.setConsole, .{});
 
     pub const top = bridge.accessor(Window.getTop, null, .{});
-    pub const self = bridge.accessor(Window.getWindow, null, .{});
+    pub const self = bridge.accessor(Window.getWindow, Window.setSelf, .{});
     pub const window = bridge.accessor(Window.getWindow, null, .{});
-    pub const parent = bridge.accessor(Window.getParent, null, .{});
+    pub const parent = bridge.accessor(Window.getParent, Window.setParent, .{});
     pub const navigator = bridge.accessor(Window.getNavigator, null, .{});
     pub const screen = bridge.accessor(Window.getScreen, null, .{});
     pub const visualViewport = bridge.accessor(Window.getVisualViewport, null, .{});
@@ -910,13 +958,13 @@ pub const JsApi = struct {
     pub const getSelection = bridge.function(Window.getSelection, .{});
     pub const frameElement = bridge.accessor(Window.getFrameElement, null, .{});
 
-    pub const frames = bridge.accessor(Window.getWindow, null, .{});
+    pub const frames = bridge.accessor(Window.getWindow, Window.setFrames, .{});
     pub const index = bridge.indexed(Window.getFrame, null, .{ .null_as_undefined = true });
-    pub const length = bridge.accessor(Window.getFramesLength, null, .{});
-    pub const scrollX = bridge.accessor(Window.getScrollX, null, .{});
-    pub const scrollY = bridge.accessor(Window.getScrollY, null, .{});
-    pub const pageXOffset = bridge.accessor(Window.getScrollX, null, .{});
-    pub const pageYOffset = bridge.accessor(Window.getScrollY, null, .{});
+    pub const length = bridge.accessor(Window.getFramesLength, Window.setLength, .{});
+    pub const scrollX = bridge.accessor(Window.getScrollX, Window.setScrollX, .{});
+    pub const scrollY = bridge.accessor(Window.getScrollY, Window.setScrollY, .{});
+    pub const pageXOffset = bridge.accessor(Window.getScrollX, Window.setPageXOffset, .{});
+    pub const pageYOffset = bridge.accessor(Window.getScrollY, Window.setPageYOffset, .{});
     pub const scrollTo = bridge.function(Window.scrollTo, .{});
     pub const scroll = bridge.function(Window.scrollTo, .{});
     pub const scrollBy = bridge.function(Window.scrollBy, .{});
@@ -927,9 +975,10 @@ pub const JsApi = struct {
     // sites not to try to access those features
     pub const isSecureContext = bridge.property(false, .{ .template = false });
 
-    pub const innerWidth = bridge.property(1920, .{ .template = false });
-    pub const innerHeight = bridge.property(1080, .{ .template = false });
-    pub const devicePixelRatio = bridge.property(1, .{ .template = false });
+    // [Replaceable] (CSSOM-View): writable so assignment overwrites rather than throws.
+    pub const innerWidth = bridge.property(1920, .{ .template = false, .readonly = false });
+    pub const innerHeight = bridge.property(1080, .{ .template = false, .readonly = false });
+    pub const devicePixelRatio = bridge.property(1, .{ .template = false, .readonly = false });
 
     pub const opener = bridge.accessor(Window.getOpener, null, .{});
     pub const closed = bridge.accessor(Window.getClosed, null, .{});
@@ -987,8 +1036,8 @@ pub const JsApi = struct {
 const CrossOriginWindow = struct {
     window: *Window,
 
-    pub fn postMessage(self: *CrossOriginWindow, message: js.Value.Temp, target_origin: ?[]const u8, frame: *Frame) !void {
-        return self.window.postMessage(message, target_origin, frame);
+    pub fn postMessage(self: *CrossOriginWindow, message: js.Value.Temp, target_origin: ?[]const u8, transfer: ?[]const *MessagePort, frame: *Frame) !void {
+        return self.window.postMessage(message, target_origin, transfer, frame);
     }
 
     pub fn getTop(self: *CrossOriginWindow, frame: *Frame) Access {
diff --git a/src/browser/webapi/Worker.zig b/src/browser/webapi/Worker.zig
index 4c96a0e4..be698018 100644
--- a/src/browser/webapi/Worker.zig
+++ b/src/browser/webapi/Worker.zig
@@ -25,7 +25,6 @@ const URL = @import("../URL.zig");
 const Frame = @import("../Frame.zig");
 const HttpClient = @import("../HttpClient.zig");
 
-const Blob = @import("Blob.zig");
 const EventTarget = @import("EventTarget.zig");
 const MessageEvent = @import("event/MessageEvent.zig");
 const ErrorEvent = @import("event/ErrorEvent.zig");
@@ -89,16 +88,6 @@ pub fn init(url: []const u8, frame: *Frame) !*Worker {
         return self;
     }
 
-    if (std.mem.startsWith(u8, url, "blob:")) {
-        errdefer frame.removeWorker(self);
-        const blob: *Blob = frame.lookupBlobUrl(url) orelse {
-            log.warn(.js, "invalid blob", .{ .target = "worker" });
-            return error.BlobNotFound;
-        };
-        try self.loadInitialScript(blob._slice);
-        return self;
-    }
-
     const headers = try session.browser.http_client.newHeaders();
     frame.makeRequest(.{
         .ctx = self,
diff --git a/src/browser/webapi/WorkerGlobalScope.zig b/src/browser/webapi/WorkerGlobalScope.zig
index 7744eca0..621993af 100644
--- a/src/browser/webapi/WorkerGlobalScope.zig
+++ b/src/browser/webapi/WorkerGlobalScope.zig
@@ -144,6 +144,8 @@ pub fn init(worker: *Worker, url: [:0]const u8) !*WorkerGlobalScope {
     });
     errdefer factory.destroy(self);
 
+    self._http_owner.blob_urls = &self._blob_urls;
+
     self._script_manager = ScriptManagerBase.init(
         arena,
         &session.browser.http_client,
@@ -231,10 +233,6 @@ pub fn isSameOrigin(self: *const WorkerGlobalScope, url: [:0]const u8) bool {
     return std.mem.eql(u8, URL.getHost(url), URL.getHost(current_origin));
 }
 
-pub fn lookupBlobUrl(self: *WorkerGlobalScope, url: []const u8) ?*Blob {
-    return self._blob_urls.get(url);
-}
-
 pub fn makeRequest(self: *WorkerGlobalScope, req: HttpClient.Request) !void {
     return self._session.browser.http_client.request(req, &self._http_owner);
 }
@@ -247,6 +245,14 @@ pub fn getConsole(self: *WorkerGlobalScope) *Console {
     return &self._console;
 }
 
+pub fn setConsole(_: *WorkerGlobalScope, value: JS.Value) void {
+    replaceGlobalProperty(value, "console");
+}
+
+pub fn setSelf(_: *WorkerGlobalScope, value: JS.Value) void {
+    replaceGlobalProperty(value, "self");
+}
+
 pub fn getCrypto(self: *WorkerGlobalScope) *Crypto {
     return &self._crypto;
 }
@@ -556,6 +562,14 @@ pub fn clearInterval(self: *WorkerGlobalScope, id: u32) void {
     self._timers.clear(id);
 }
 
+// `console` and `self` are [Replaceable] assignment redefines them as own data
+// properties on the global rather than throwing through the getter-only accessor
+// in strict mode.
+fn replaceGlobalProperty(value: JS.Value, comptime name: []const u8) void {
+    const global = value.local.getGlobal();
+    _ = global.defineOwnProperty(name, value, 0);
+}
+
 const FunctionSetter = union(enum) {
     func: JS.Function.Global,
     anything: JS.Value,
@@ -632,8 +646,8 @@ pub const JsApi = struct {
         pub var class_id: bridge.ClassId = undefined;
     };
 
-    pub const self = bridge.accessor(WorkerGlobalScope.getSelf, null, .{});
-    pub const console = bridge.accessor(WorkerGlobalScope.getConsole, null, .{});
+    pub const self = bridge.accessor(WorkerGlobalScope.getSelf, WorkerGlobalScope.setSelf, .{});
+    pub const console = bridge.accessor(WorkerGlobalScope.getConsole, WorkerGlobalScope.setConsole, .{});
     pub const crypto = bridge.accessor(WorkerGlobalScope.getCrypto, null, .{});
     pub const performance = bridge.accessor(struct {
         // Unnecessary, But, our WebAPI getters are ALWAYS `fn getPerformance()...`.
diff --git a/src/browser/webapi/canvas/OffscreenCanvas.zig b/src/browser/webapi/canvas/OffscreenCanvas.zig
index 96363756..f3e113a9 100644
--- a/src/browser/webapi/canvas/OffscreenCanvas.zig
+++ b/src/browser/webapi/canvas/OffscreenCanvas.zig
@@ -73,8 +73,8 @@ pub fn getContext(_: *OffscreenCanvas, context_type: []const u8, exec: *Executio
 /// Returns a Promise that resolves to a Blob containing the image.
 /// Since we have no actual rendering, this returns an empty blob.
 pub fn convertToBlob(_: *OffscreenCanvas, exec: *Execution) !js.Promise {
-    const blob = try Blob.init(null, null, exec.context.page);
-    return exec.context.local.?.resolvePromise(blob);
+    const blob = try Blob.init(null, null, exec.page);
+    return exec.js.local.?.resolvePromise(blob);
 }
 
 /// Returns an ImageBitmap with the rendered content (stub).
diff --git a/src/browser/webapi/crypto/HMAC.zig b/src/browser/webapi/crypto/HMAC.zig
index 3ab0e507..89277177 100644
--- a/src/browser/webapi/crypto/HMAC.zig
+++ b/src/browser/webapi/crypto/HMAC.zig
@@ -35,7 +35,7 @@ pub fn init(
     key_usages: []const []const u8,
     exec: *const Execution,
 ) !js.Promise {
-    const local = exec.context.local.?;
+    const local = exec.js.local.?;
     // Per spec, an unrecognized hash is caught during algorithm normalization
     // and surfaces as NotSupportedError.
     const digest = crypto.findDigest(switch (params.hash) {
@@ -99,7 +99,7 @@ pub fn sign(
     data: []const u8,
     exec: *const Execution,
 ) !js.Promise {
-    var resolver = exec.context.local.?.createPromiseResolver();
+    var resolver = exec.js.local.?.createPromiseResolver();
 
     if (!algo.isHMAC() or !crypto_key.canSign()) {
         resolver.rejectError("HMAC.sign", .{ .dom_exception = .{ .err = error.InvalidAccessError } });
@@ -135,7 +135,7 @@ pub fn verify(
     data: []const u8,
     exec: *const Execution,
 ) !js.Promise {
-    var resolver = exec.context.local.?.createPromiseResolver();
+    var resolver = exec.js.local.?.createPromiseResolver();
 
     if (!crypto_key.canVerify()) {
         resolver.rejectError("HMAC.verify", .{ .dom_exception = .{ .err = error.InvalidAccessError } });
diff --git a/src/browser/webapi/crypto/X25519.zig b/src/browser/webapi/crypto/X25519.zig
index aaa1798c..048ab999 100644
--- a/src/browser/webapi/crypto/X25519.zig
+++ b/src/browser/webapi/crypto/X25519.zig
@@ -37,7 +37,7 @@ pub fn init(
     // gather them together with a single alloc call. Not sure if factory
     // pattern is suitable for it though.
 
-    const local = exec.context.local.?;
+    const local = exec.js.local.?;
 
     // Calculate usages; only matters for private key.
     // Only deriveKey() and deriveBits() be used for X25519.
diff --git a/src/browser/webapi/event/MessageEvent.zig b/src/browser/webapi/event/MessageEvent.zig
index d4a649e3..2bd07147 100644
--- a/src/browser/webapi/event/MessageEvent.zig
+++ b/src/browser/webapi/event/MessageEvent.zig
@@ -35,11 +35,13 @@ _proto: *Event,
 _data: ?Data = null,
 _origin: []const u8 = "",
 _source: ?*Window = null,
+_ports: []const *MessagePort = &.{},
 
 const MessageEventOptions = struct {
     data: ?Data = null,
     origin: ?[]const u8 = null,
     source: ?*Window = null,
+    ports: []const *MessagePort = &.{},
 };
 
 pub const Data = union(enum) {
@@ -75,6 +77,7 @@ fn initWithTrusted(arena: Allocator, typ: String, opts_: ?Options, trusted: bool
             ._data = opts.data,
             ._origin = if (opts.origin) |str| try arena.dupe(u8, str) else "",
             ._source = opts.source,
+            ._ports = if (opts.ports.len == 0) &.{} else try arena.dupe(*MessagePort, opts.ports),
         },
     );
 
@@ -117,8 +120,8 @@ pub fn getSource(self: *const MessageEvent) ?*Window {
     return self._source;
 }
 
-pub fn getPorts(_: *const MessageEvent) []*MessagePort {
-    return &.{};
+pub fn getPorts(self: *const MessageEvent) []const *MessagePort {
+    return self._ports;
 }
 
 pub const JsApi = struct {
diff --git a/src/browser/webapi/net/Fetch.zig b/src/browser/webapi/net/Fetch.zig
index a3576535..1f69ef0e 100644
--- a/src/browser/webapi/net/Fetch.zig
+++ b/src/browser/webapi/net/Fetch.zig
@@ -24,7 +24,6 @@ const js = @import("../../js/js.zig");
 const Page = @import("../../Page.zig");
 const URL = @import("../../URL.zig");
 
-const Blob = @import("../Blob.zig");
 const Request = @import("Request.zig");
 const Response = @import("Response.zig");
 const AbortSignal = @import("../AbortSignal.zig");
@@ -48,7 +47,7 @@ pub const Input = Request.Input;
 pub const InitOpts = Request.InitOpts;
 
 pub fn init(input: Input, options: ?InitOpts, exec: *const Execution) !js.Promise {
-    const resolver = exec.context.local.?.createPromiseResolver();
+    const resolver = exec.js.local.?.createPromiseResolver();
 
     // A bad RequestInit (e.g. an invalid priority) must reject the promise,
     // not throw synchronously.
@@ -64,12 +63,8 @@ pub fn init(input: Input, options: ?InitOpts, exec: *const Execution) !js.Promis
         }
     }
 
-    if (std.mem.startsWith(u8, request._url, "blob:")) {
-        return handleBlobUrl(request._url, resolver, exec);
-    }
-
     const response = try Response.init(null, .{ .status = 0 }, exec);
-    errdefer response.deinit(exec.context.page);
+    errdefer response.deinit(exec.page);
 
     const fetch = try response._arena.create(Fetch);
     fetch.* = .{
@@ -82,7 +77,7 @@ pub fn init(input: Input, options: ?InitOpts, exec: *const Execution) !js.Promis
         ._signal = request._signal,
     };
 
-    const session = exec.context.page.session;
+    const session = exec.session;
     const http_client = &session.browser.http_client;
     var headers = try http_client.newHeaders();
     if (request._headers) |h| {
@@ -127,26 +122,6 @@ pub fn init(input: Input, options: ?InitOpts, exec: *const Execution) !js.Promis
     return resolver.promise();
 }
 
-fn handleBlobUrl(url: []const u8, resolver: js.PromiseResolver, exec: *const Execution) !js.Promise {
-    const blob: *Blob = exec.lookupBlobUrl(url) orelse {
-        resolver.rejectError("fetch blob error", .{ .type_error = "BlobNotFound" });
-        return resolver.promise();
-    };
-
-    const response = try Response.init(null, .{ .status = 200 }, exec);
-    response._body = .{ .bytes = try response._arena.dupe(u8, blob._slice) };
-    response._url = try response._arena.dupeZ(u8, url);
-    response._type = .basic;
-
-    if (blob._mime.len > 0) {
-        try response._headers.append("Content-Type", blob._mime, exec);
-    }
-
-    const js_val = try exec.context.local.?.zigValueToJs(response, .{});
-    resolver.resolve("fetch blob done", js_val);
-    return resolver.promise();
-}
-
 fn httpStartCallback(response: HttpClient.Response) !void {
     const self: *Fetch = @ptrCast(@alignCast(response.ctx));
     if (comptime IS_DEBUG) {
@@ -238,7 +213,7 @@ fn httpDoneCallback(ctx: *anyopaque) !void {
     });
 
     var ls: js.Local.Scope = undefined;
-    self._exec.context.localScope(&ls);
+    self._exec.js.localScope(&ls);
     defer ls.deinit();
 
     const js_val = try ls.local.zigValueToJs(self._response, .{});
@@ -269,11 +244,11 @@ fn httpErrorCallback(ctx: *anyopaque, err: anyerror) void {
     // clear this. (defer since `self is in the response's arena).
 
     defer if (owns_response) {
-        response.deinit(self._exec.context.page);
+        response.deinit(self._exec.page);
     };
 
     var ls: js.Local.Scope = undefined;
-    self._exec.context.localScope(&ls);
+    self._exec.js.localScope(&ls);
     defer ls.deinit();
 
     // fetch() must reject with a TypeError on network errors per spec
@@ -286,7 +261,7 @@ fn httpShutdownCallback(ctx: *anyopaque) void {
     if (self._owns_response) {
         var response = self._response;
         response._http_response = null;
-        response.deinit(self._exec.context.page);
+        response.deinit(self._exec.page);
         // Do not access `self` after this point: the Fetch struct was
         // allocated from response._arena which has been released.
     }
diff --git a/src/browser/webapi/net/FormData.zig b/src/browser/webapi/net/FormData.zig
index 12f0ecf6..5fd493a8 100644
--- a/src/browser/webapi/net/FormData.zig
+++ b/src/browser/webapi/net/FormData.zig
@@ -68,7 +68,7 @@ pub fn init(form_: ?*Form, submitter: ?*Element, exec: *const Execution) !*FormD
         });
     };
 
-    const frame = switch (exec.context.global) {
+    const frame = switch (exec.js.global) {
         .frame => |f| f,
         .worker => lp.assert(false, "FormData worker form", .{}),
     };
diff --git a/src/browser/webapi/net/Request.zig b/src/browser/webapi/net/Request.zig
index 8954b4b2..1c0854cf 100644
--- a/src/browser/webapi/net/Request.zig
+++ b/src/browser/webapi/net/Request.zig
@@ -214,7 +214,7 @@ fn consume(self: *Request, local: *const js.Local) ?js.Promise {
 }
 
 pub fn blob(self: *Request, exec: *const Execution) !js.Promise {
-    const local = exec.context.local.?;
+    const local = exec.js.local.?;
     if (self.consume(local)) |rejected| {
         return rejected;
     }
@@ -223,12 +223,12 @@ pub fn blob(self: *Request, exec: *const Execution) !js.Promise {
     const headers = try self.getHeaders(exec);
     const content_type = try headers.get("content-type", exec) orelse "";
 
-    const b = try Blob.initFromBytes(body, content_type, true, exec.context.page);
+    const b = try Blob.initFromBytes(body, content_type, true, exec.page);
     return local.resolvePromise(b);
 }
 
 pub fn text(self: *Request, exec: *const Execution) !js.Promise {
-    const local = exec.context.local.?;
+    const local = exec.js.local.?;
     if (self.consume(local)) |rejected| {
         return rejected;
     }
@@ -236,7 +236,7 @@ pub fn text(self: *Request, exec: *const Execution) !js.Promise {
 }
 
 pub fn json(self: *Request, exec: *const Execution) !js.Promise {
-    const local = exec.context.local.?;
+    const local = exec.js.local.?;
     if (self.consume(local)) |rejected| {
         return rejected;
     }
@@ -248,7 +248,7 @@ pub fn json(self: *Request, exec: *const Execution) !js.Promise {
 }
 
 pub fn arrayBuffer(self: *Request, exec: *const Execution) !js.Promise {
-    const local = exec.context.local.?;
+    const local = exec.js.local.?;
     if (self.consume(local)) |rejected| {
         return rejected;
     }
@@ -256,7 +256,7 @@ pub fn arrayBuffer(self: *Request, exec: *const Execution) !js.Promise {
 }
 
 pub fn bytes(self: *Request, exec: *const Execution) !js.Promise {
-    const local = exec.context.local.?;
+    const local = exec.js.local.?;
     if (self.consume(local)) |rejected| {
         return rejected;
     }
diff --git a/src/browser/webapi/net/Response.zig b/src/browser/webapi/net/Response.zig
index a4986efb..b68149fc 100644
--- a/src/browser/webapi/net/Response.zig
+++ b/src/browser/webapi/net/Response.zig
@@ -70,7 +70,7 @@ const InitOpts = struct {
 pub const BodyInit = body_init.BodyInit;
 
 pub fn init(body_: ?BodyInit, opts_: ?InitOpts, exec: *const Execution) !*Response {
-    const session = exec.context.page.session;
+    const session = exec.session;
     const arena = try session.getArena(.large, "Response");
     errdefer session.releaseArena(arena);
 
@@ -191,7 +191,7 @@ fn consume(self: *Response, local: *const js.Local) ?js.Promise {
 }
 
 pub fn getText(self: *Response, exec: *const Execution) !js.Promise {
-    const local = exec.context.local.?;
+    const local = exec.js.local.?;
     if (self.consume(local)) |rejected| {
         return rejected;
     }
@@ -205,7 +205,7 @@ pub fn getText(self: *Response, exec: *const Execution) !js.Promise {
 }
 
 pub fn getJson(self: *Response, exec: *const Execution) !js.Promise {
-    const local = exec.context.local.?;
+    const local = exec.js.local.?;
     if (self.consume(local)) |rejected| {
         return rejected;
     }
@@ -222,7 +222,7 @@ pub fn getJson(self: *Response, exec: *const Execution) !js.Promise {
 }
 
 pub fn arrayBuffer(self: *Response, exec: *const Execution) !js.Promise {
-    const local = exec.context.local.?;
+    const local = exec.js.local.?;
     if (self.consume(local)) |rejected| {
         return rejected;
     }
@@ -246,7 +246,7 @@ const StreamConsumer = struct {
     resolver: js.PromiseResolver.Global,
 
     fn start(stream: *ReadableStream, exec: *const Execution) !js.Promise {
-        const local = exec.context.local.?;
+        const local = exec.js.local.?;
         var resolver = local.createPromiseResolver();
         const promise = resolver.promise();
 
@@ -267,7 +267,7 @@ const StreamConsumer = struct {
     }
 
     fn pumpRead(self: *StreamConsumer) !void {
-        const local = self.execution.context.local.?;
+        const local = self.execution.js.local.?;
         const read_promise = try self.reader.read(self.execution);
 
         const then_fn = local.newCallback(onReadFulfilled, self);
@@ -284,7 +284,7 @@ const StreamConsumer = struct {
     };
 
     fn onReadFulfilled(self: *StreamConsumer, data_: ?ReadData) void {
-        const local = self.execution.context.local.?;
+        const local = self.execution.js.local.?;
 
         const data = data_ orelse {
             return self.finish(local, null);
@@ -297,7 +297,7 @@ const StreamConsumer = struct {
 
     fn _onReadFulfilled(self: *StreamConsumer, data: ReadData) !void {
         const exec = self.execution;
-        const local = exec.context.local.?;
+        const local = exec.js.local.?;
 
         if (data.done) {
             // Stream is finished, concatenate all chunks and resolve
@@ -328,7 +328,7 @@ const StreamConsumer = struct {
     }
 
     fn onReadRejected(self: *StreamConsumer) void {
-        self.finish(self.execution.context.local.?, null);
+        self.finish(self.execution.js.local.?, null);
     }
 
     fn concatenateChunks(self: *StreamConsumer, allocator: Allocator) ![]const u8 {
@@ -348,7 +348,7 @@ const StreamConsumer = struct {
 };
 
 pub fn blob(self: *Response, exec: *const Execution) !js.Promise {
-    const local = exec.context.local.?;
+    const local = exec.js.local.?;
     if (self.consume(local)) |rejected| return rejected;
     const body = switch (self._body) {
         .bytes => |b| b,
@@ -356,12 +356,12 @@ pub fn blob(self: *Response, exec: *const Execution) !js.Promise {
         .stream => return local.rejectPromise(.{ .type_error = "Cannot read blob from stream body" }),
     };
     const content_type = try self._headers.get("content-type", exec) orelse "";
-    const b = try Blob.initFromBytes(body, content_type, true, exec.context.page);
+    const b = try Blob.initFromBytes(body, content_type, true, exec.page);
     return local.resolvePromise(b);
 }
 
 pub fn bytes(self: *Response, exec: *const Execution) !js.Promise {
-    const local = exec.context.local.?;
+    const local = exec.js.local.?;
     if (self.consume(local)) |rejected| return rejected;
     const body = switch (self._body) {
         .bytes => |b| b,
@@ -372,7 +372,7 @@ pub fn bytes(self: *Response, exec: *const Execution) !js.Promise {
 }
 
 pub fn clone(self: *const Response, exec: *const Execution) !*Response {
-    const session = exec.context.page.session;
+    const session = exec.session;
     const body_len = switch (self._body) {
         .bytes => |b| b.len,
         .empty => 0,
diff --git a/src/browser/webapi/net/WebSocket.zig b/src/browser/webapi/net/WebSocket.zig
index f033fb44..4d2b589f 100644
--- a/src/browser/webapi/net/WebSocket.zig
+++ b/src/browser/webapi/net/WebSocket.zig
@@ -117,7 +117,7 @@ pub fn init(url: []const u8, protocols: [][]const u8, exec: *const Execution) !*
 
     const resolved_url = try URL.resolve(arena, exec.base(), url, .{ .always_dupe = true, .encoding = exec.charset.* });
 
-    const http_client = &exec.context.page.session.browser.http_client;
+    const http_client = &exec.session.browser.http_client;
     const conn = http_client.network.newConnection() orelse {
         return error.NoFreeConnection;
     };
@@ -240,7 +240,7 @@ fn cleanup(self: *WebSocket) void {
         self._http_client.removeConn(conn);
         self._req_headers.deinit();
         self._conn = null;
-        self.releaseRef(self._exec.context.page);
+        self.releaseRef(self._exec.page);
         self._send_queue.clearRetainingCapacity();
     }
 }
@@ -457,7 +457,7 @@ fn dispatchOpenEvent(self: *WebSocket) !void {
     const target = self.asEventTarget();
 
     if (exec.hasDirectListeners(target, "open", self._on_open)) {
-        const event = try Event.initTrusted(comptime .wrap("open"), .{}, exec.context.page);
+        const event = try Event.initTrusted(comptime .wrap("open"), .{}, exec.page);
         try exec.dispatch(target, event, self._on_open, .{ .context = "WebSocket open" });
     }
 }
@@ -471,7 +471,7 @@ fn dispatchMessageEvent(self: *WebSocket, data: []const u8, frame_type: http.WsF
             switch (self._binary_type) {
                 .arraybuffer => .{ .arraybuffer = .{ .values = data } },
                 .blob => blk: {
-                    const blob = try Blob.initFromBytes(data, "", false, exec.context.page);
+                    const blob = try Blob.initFromBytes(data, "", false, exec.page);
                     blob.acquireRef();
                     break :blk .{ .blob = blob };
                 },
@@ -482,7 +482,7 @@ fn dispatchMessageEvent(self: *WebSocket, data: []const u8, frame_type: http.WsF
         const event = try MessageEvent.initTrusted(comptime .wrap("message"), .{
             .data = msg_data,
             .origin = "",
-        }, exec.context.page);
+        }, exec.page);
         try exec.dispatch(target, event.asEvent(), self._on_message, .{ .context = "WebSocket message" });
     }
 }
@@ -492,7 +492,7 @@ fn dispatchErrorEvent(self: *WebSocket) !void {
     const target = self.asEventTarget();
 
     if (exec.hasDirectListeners(target, "error", self._on_error)) {
-        const event = try Event.initTrusted(comptime .wrap("error"), .{}, exec.context.page);
+        const event = try Event.initTrusted(comptime .wrap("error"), .{}, exec.page);
         try exec.dispatch(target, event, self._on_error, .{ .context = "WebSocket error" });
     }
 }
@@ -506,7 +506,7 @@ fn dispatchCloseEvent(self: *WebSocket, code: u16, reason: []const u8, was_clean
             .code = code,
             .reason = reason,
             .wasClean = was_clean,
-        }, exec.context.page);
+        }, exec.page);
         try exec.dispatch(target, event.asEvent(), self._on_close, .{ .context = "WebSocket close" });
     }
 }
@@ -580,7 +580,7 @@ fn writeContent(self: *WebSocket, conn: *http.Connection, buf: []u8, byte_msg: M
 
     if (self._send_offset >= byte_msg.data.len) {
         const removed = self._send_queue.orderedRemove(0);
-        removed.deinit(self._exec.context.page);
+        removed.deinit(self._exec.page);
         if (comptime IS_DEBUG) {
             log.debug(.websocket, "send complete", .{ .url = self._url, .len = byte_msg.data.len, .queue = self._send_queue.items.len });
         }
diff --git a/src/browser/webapi/net/XMLHttpRequest.zig b/src/browser/webapi/net/XMLHttpRequest.zig
index 98027202..9dd5de4b 100644
--- a/src/browser/webapi/net/XMLHttpRequest.zig
+++ b/src/browser/webapi/net/XMLHttpRequest.zig
@@ -146,7 +146,7 @@ fn releaseSelfRef(self: *XMLHttpRequest) void {
         return;
     }
     self._active_request = false;
-    self.releaseRef(self._exec.context.page);
+    self.releaseRef(self._exec.page);
 }
 
 pub fn releaseRef(self: *XMLHttpRequest, page: *Page) void {
@@ -249,11 +249,7 @@ pub fn send(self: *XMLHttpRequest, body_: ?BodyInit, exec_: *const Execution) !v
 
     const exec = self._exec;
 
-    if (std.mem.startsWith(u8, self._url, "blob:")) {
-        return self.handleBlobUrl(exec);
-    }
-
-    const session = exec.context.page.session;
+    const session = exec.session;
     const http_client = &session.browser.http_client;
     var headers = try http_client.newHeaders();
 
@@ -293,38 +289,6 @@ pub fn send(self: *XMLHttpRequest, body_: ?BodyInit, exec_: *const Execution) !v
     };
 }
 
-fn handleBlobUrl(self: *XMLHttpRequest, exec: *const Execution) !void {
-    const blob = exec.lookupBlobUrl(self._url) orelse {
-        self.handleError(error.BlobNotFound);
-        return;
-    };
-
-    self._response_status = 200;
-    self._response_url = self._url;
-
-    try self._response_data.appendSlice(self._arena, blob._slice);
-    self._response_len = blob._slice.len;
-
-    try self.stateChanged(.headers_received, exec);
-    try self._proto.dispatch(.load_start, .{ .loaded = 0, .total = self._response_len orelse 0 }, exec);
-    try self.stateChanged(.loading, exec);
-    try self._proto.dispatch(.progress, .{
-        .total = self._response_len orelse 0,
-        .loaded = self._response_data.items.len,
-    }, exec);
-    try self.stateChanged(.done, exec);
-
-    const loaded = self._response_data.items.len;
-    try self._proto.dispatch(.load, .{
-        .total = loaded,
-        .loaded = loaded,
-    }, exec);
-    try self._proto.dispatch(.load_end, .{
-        .total = loaded,
-        .loaded = loaded,
-    }, exec);
-}
-
 pub fn getReadyState(self: *const XMLHttpRequest) u32 {
     return @intFromEnum(self._ready_state);
 }
@@ -403,13 +367,13 @@ pub fn getResponse(self: *XMLHttpRequest, exec: *const Execution) !?Response {
     const res: Response = switch (self._response_type) {
         .text => .{ .text = data },
         .json => blk: {
-            const value = try exec.context.local.?.parseJSON(data);
+            const value = try exec.js.local.?.parseJSON(data);
             break :blk .{ .json = try value.persist() };
         },
         .document => blk: {
             // responseType=document is only meaningful in a Frame; workers
             // have no DOM. Drastically different impls -> switch on global.
-            switch (exec.context.global) {
+            switch (exec.js.global) {
                 .frame => |frame| {
                     const document = try exec._factory.node(Node.Document{ ._proto = undefined, ._type = .generic });
                     try frame.parseHtmlAsChildren(document.asNode(), data);
@@ -485,7 +449,7 @@ fn httpHeaderDoneCallback(response: HttpClient.Response) !bool {
     const exec = self._exec;
 
     var ls: js.Local.Scope = undefined;
-    exec.context.localScope(&ls);
+    exec.js.localScope(&ls);
     defer ls.deinit();
 
     try self.stateChanged(.headers_received, exec);
@@ -606,7 +570,7 @@ fn stateChanged(self: *XMLHttpRequest, state: ReadyState, exec: *const Execution
 
     const target = self.asEventTarget();
     if (exec.hasDirectListeners(target, "readystatechange", self._on_ready_state_change)) {
-        const event = try Event.initTrusted(.wrap("readystatechange"), .{}, exec.context.page);
+        const event = try Event.initTrusted(.wrap("readystatechange"), .{}, exec.page);
         try exec.dispatch(target, event, self._on_ready_state_change, .{ .context = "XHR state change" });
     }
 }
diff --git a/src/browser/webapi/net/XMLHttpRequestEventTarget.zig b/src/browser/webapi/net/XMLHttpRequestEventTarget.zig
index 7cbedc70..af5fd38f 100644
--- a/src/browser/webapi/net/XMLHttpRequestEventTarget.zig
+++ b/src/browser/webapi/net/XMLHttpRequestEventTarget.zig
@@ -61,7 +61,7 @@ pub fn dispatch(self: *XMLHttpRequestEventTarget, comptime event_type: DispatchT
     const event = (try ProgressEvent.initTrusted(
         comptime .wrap(typ),
         .{ .total = progress.total, .loaded = progress.loaded },
-        exec.context.page,
+        exec.page,
     )).asEvent();
 
     return exec.dispatch(
diff --git a/src/browser/webapi/streams/ReadableStream.zig b/src/browser/webapi/streams/ReadableStream.zig
index 809d95af..1089d750 100644
--- a/src/browser/webapi/streams/ReadableStream.zig
+++ b/src/browser/webapi/streams/ReadableStream.zig
@@ -145,9 +145,9 @@ pub fn callPullIfNeeded(self: *ReadableStream) !void {
 
     const exec = self._execution;
     if (comptime IS_DEBUG) {
-        if (exec.context.local == null) {
+        if (exec.js.local == null) {
             log.fatal(.bug, "null context scope", .{ .src = "ReadableStream.callPullIfNeeded", .url = exec.url.* });
-            std.debug.assert(exec.context.local != null);
+            std.debug.assert(exec.js.local != null);
         }
     }
 
@@ -155,7 +155,7 @@ pub fn callPullIfNeeded(self: *ReadableStream) !void {
         const func = self._pull_fn orelse return;
 
         var ls: js.Local.Scope = undefined;
-        exec.context.localScope(&ls);
+        exec.js.localScope(&ls);
         defer ls.deinit();
 
         // Call the pull function
@@ -187,7 +187,7 @@ fn shouldCallPull(self: *const ReadableStream) bool {
 }
 
 pub fn cancel(self: *ReadableStream, reason: ?[]const u8, exec: *const Execution) !js.Promise {
-    const local = exec.context.local.?;
+    const local = exec.js.local.?;
 
     if (self._state != .readable) {
         if (self._cancel) |c| {
@@ -257,10 +257,10 @@ pub fn pipeThrough(self: *ReadableStream, transform: PipeTransform, exec: *const
 /// Returns a promise that resolves when piping is complete.
 pub fn pipeTo(self: *ReadableStream, destination: *WritableStream, exec: *const Execution) !js.Promise {
     if (self.getLocked()) {
-        return exec.context.local.?.rejectPromise(.{ .type_error = "ReadableStream is locked" });
+        return exec.js.local.?.rejectPromise(.{ .type_error = "ReadableStream is locked" });
     }
 
-    const local = exec.context.local.?;
+    const local = exec.js.local.?;
     var pipe_resolver = local.createPromiseResolver();
     const promise = pipe_resolver.promise();
     const persisted_resolver = try pipe_resolver.persist();
@@ -295,7 +295,7 @@ const PipeState = struct {
 
     fn pumpRead(state: *PipeState) !void {
         const exec = state.execution;
-        const local = exec.context.local.?;
+        const local = exec.js.local.?;
 
         // Call reader.read() which returns a Promise
         const read_promise = try state.reader.read(exec);
@@ -315,7 +315,7 @@ const PipeState = struct {
     };
     fn onReadFulfilled(self: *PipeState, data_: ?ReadData) void {
         const exec = self.execution;
-        const local = exec.context.local.?;
+        const local = exec.js.local.?;
         const data = data_ orelse {
             return self.finish(local);
         };
@@ -346,7 +346,7 @@ const PipeState = struct {
     }
 
     fn onReadRejected(self: *PipeState) void {
-        self.finish(self.execution.context.local.?);
+        self.finish(self.execution.js.local.?);
     }
 
     fn finish(self: *PipeState, local: *const js.Local) void {
@@ -399,7 +399,7 @@ pub const AsyncIterator = struct {
 
     pub fn @"return"(self: *AsyncIterator, exec: *const Execution) !js.Promise {
         self._reader.releaseLock();
-        return exec.context.local.?.resolvePromise(.{ .done = true, .value = null });
+        return exec.js.local.?.resolvePromise(.{ .done = true, .value = null });
     }
 
     pub const JsApi = struct {
diff --git a/src/browser/webapi/streams/ReadableStreamDefaultController.zig b/src/browser/webapi/streams/ReadableStreamDefaultController.zig
index 9d258676..feda0705 100644
--- a/src/browser/webapi/streams/ReadableStreamDefaultController.zig
+++ b/src/browser/webapi/streams/ReadableStreamDefaultController.zig
@@ -64,7 +64,7 @@ pub fn init(stream: *ReadableStream, high_water_mark: u32, exec: *const Executio
 }
 
 pub fn addPendingRead(self: *ReadableStreamDefaultController) !js.Promise {
-    const resolver = self._execution.context.local.?.createPromiseResolver();
+    const resolver = self._execution.js.local.?.createPromiseResolver();
     try self._pending_reads.append(self._arena, try resolver.persist());
     return resolver.promise();
 }
@@ -89,14 +89,14 @@ pub fn enqueue(self: *ReadableStreamDefaultController, chunk: Chunk) !void {
     };
 
     if (comptime IS_DEBUG) {
-        if (exec.context.local == null) {
+        if (exec.js.local == null) {
             log.fatal(.bug, "null context scope", .{ .src = "ReadableStreamDefaultController.enqueue", .url = exec.url.* });
-            std.debug.assert(exec.context.local != null);
+            std.debug.assert(exec.js.local != null);
         }
     }
 
     var ls: js.Local.Scope = undefined;
-    exec.context.localScope(&ls);
+    exec.js.localScope(&ls);
     defer ls.deinit();
 
     ls.toLocal(resolver).resolve("stream enqueue", result);
@@ -124,14 +124,14 @@ pub fn enqueueValue(self: *ReadableStreamDefaultController, value: js.Value) !vo
     };
 
     if (comptime IS_DEBUG) {
-        if (exec.context.local == null) {
+        if (exec.js.local == null) {
             log.fatal(.bug, "null context scope", .{ .src = "ReadableStreamDefaultController.enqueueValue", .url = exec.url.* });
-            std.debug.assert(exec.context.local != null);
+            std.debug.assert(exec.js.local != null);
         }
     }
 
     var ls: js.Local.Scope = undefined;
-    exec.context.localScope(&ls);
+    exec.js.localScope(&ls);
     defer ls.deinit();
 
     ls.toLocal(resolver).resolve("stream enqueue value", result);
@@ -152,15 +152,15 @@ pub fn close(self: *ReadableStreamDefaultController) !void {
 
     const exec = self._execution;
     if (comptime IS_DEBUG) {
-        if (exec.context.local == null) {
+        if (exec.js.local == null) {
             log.fatal(.bug, "null context scope", .{ .src = "ReadableStreamDefaultController.close", .url = exec.url.* });
-            std.debug.assert(exec.context.local != null);
+            std.debug.assert(exec.js.local != null);
         }
     }
 
     for (self._pending_reads.items) |resolver| {
         var ls: js.Local.Scope = undefined;
-        exec.context.localScope(&ls);
+        exec.js.localScope(&ls);
         defer ls.deinit();
         ls.toLocal(resolver).resolve("stream close", result);
     }
@@ -178,7 +178,7 @@ pub fn doError(self: *ReadableStreamDefaultController, err: []const u8) !void {
 
     // Reject all pending reads
     for (self._pending_reads.items) |resolver| {
-        self._execution.context.toLocal(resolver).reject("stream error", err);
+        self._execution.js.toLocal(resolver).reject("stream error", err);
     }
     self._pending_reads.clearRetainingCapacity();
 }
diff --git a/src/browser/webapi/streams/ReadableStreamDefaultReader.zig b/src/browser/webapi/streams/ReadableStreamDefaultReader.zig
index 0f0c8bf4..afbe85e4 100644
--- a/src/browser/webapi/streams/ReadableStreamDefaultReader.zig
+++ b/src/browser/webapi/streams/ReadableStreamDefaultReader.zig
@@ -58,7 +58,7 @@ pub const ReadResult = struct {
 };
 
 pub fn read(self: *ReadableStreamDefaultReader, exec: *const Execution) !js.Promise {
-    const local = exec.context.local.?;
+    const local = exec.js.local.?;
     const stream = self._stream orelse {
         return local.rejectPromise(.{ .type_error = "Reader has been released" });
     };
@@ -97,7 +97,7 @@ pub fn releaseLock(self: *ReadableStreamDefaultReader) void {
 
 pub fn cancel(self: *ReadableStreamDefaultReader, reason_: ?[]const u8, exec: *const Execution) !js.Promise {
     const stream = self._stream orelse {
-        return exec.context.local.?.rejectPromise(.{ .type_error = "Reader has been released" });
+        return exec.js.local.?.rejectPromise(.{ .type_error = "Reader has been released" });
     };
 
     self.releaseLock();
diff --git a/src/browser/webapi/streams/TransformStream.zig b/src/browser/webapi/streams/TransformStream.zig
index f46f9d7c..d807b2f5 100644
--- a/src/browser/webapi/streams/TransformStream.zig
+++ b/src/browser/webapi/streams/TransformStream.zig
@@ -94,7 +94,7 @@ pub fn transformWrite(self: *TransformStream, chunk: js.Value, exec: *const Exec
 
     if (self._controller._transform_fn) |transform_fn| {
         var ls: js.Local.Scope = undefined;
-        exec.context.localScope(&ls);
+        exec.js.localScope(&ls);
         defer ls.deinit();
 
         try ls.toLocal(transform_fn).call(void, .{ chunk, self._controller });
@@ -106,7 +106,7 @@ pub fn transformWrite(self: *TransformStream, chunk: js.Value, exec: *const Exec
 pub fn transformClose(self: *TransformStream, exec: *const Execution) !void {
     if (self._controller._flush_fn) |flush_fn| {
         var ls: js.Local.Scope = undefined;
-        exec.context.localScope(&ls);
+        exec.js.localScope(&ls);
         defer ls.deinit();
 
         try ls.toLocal(flush_fn).call(void, .{self._controller});
diff --git a/src/browser/webapi/streams/WritableStream.zig b/src/browser/webapi/streams/WritableStream.zig
index 40bdc919..ddf3da7e 100644
--- a/src/browser/webapi/streams/WritableStream.zig
+++ b/src/browser/webapi/streams/WritableStream.zig
@@ -111,7 +111,7 @@ pub fn writeChunk(self: *WritableStream, chunk: js.Value, exec: *const Execution
 
     if (self._write_fn) |write_fn| {
         var ls: js.Local.Scope = undefined;
-        exec.context.localScope(&ls);
+        exec.js.localScope(&ls);
         defer ls.deinit();
 
         try ls.toLocal(write_fn).call(void, .{ chunk, self._controller });
@@ -129,7 +129,7 @@ pub fn closeStream(self: *WritableStream, exec: *const Execution) !void {
 
     if (self._close_fn) |close_fn| {
         var ls: js.Local.Scope = undefined;
-        exec.context.localScope(&ls);
+        exec.js.localScope(&ls);
         defer ls.deinit();
 
         try ls.toLocal(close_fn).call(void, .{self._controller});
diff --git a/src/browser/webapi/streams/WritableStreamDefaultWriter.zig b/src/browser/webapi/streams/WritableStreamDefaultWriter.zig
index be5880ae..02d78b63 100644
--- a/src/browser/webapi/streams/WritableStreamDefaultWriter.zig
+++ b/src/browser/webapi/streams/WritableStreamDefaultWriter.zig
@@ -32,7 +32,7 @@ pub fn init(stream: *WritableStream, exec: *const Execution) !*WritableStreamDef
 }
 
 pub fn write(self: *WritableStreamDefaultWriter, chunk: js.Value, exec: *const Execution) !js.Promise {
-    const local = exec.context.local.?;
+    const local = exec.js.local.?;
     const stream = self._stream orelse {
         return local.rejectPromise(.{ .type_error = "Writer has been released" });
     };
@@ -47,7 +47,7 @@ pub fn write(self: *WritableStreamDefaultWriter, chunk: js.Value, exec: *const E
 }
 
 pub fn close(self: *WritableStreamDefaultWriter, exec: *const Execution) !js.Promise {
-    const local = exec.context.local.?;
+    const local = exec.js.local.?;
     const stream = self._stream orelse {
         return local.rejectPromise(.{ .type_error = "Writer has been released" });
     };
@@ -69,7 +69,7 @@ pub fn releaseLock(self: *WritableStreamDefaultWriter) void {
 }
 
 pub fn getClosed(self: *WritableStreamDefaultWriter, exec: *const Execution) !js.Promise {
-    const local = exec.context.local.?;
+    const local = exec.js.local.?;
     const stream = self._stream orelse {
         return local.rejectPromise(.{ .type_error = "Writer has been released" });
     };
@@ -92,7 +92,7 @@ pub fn getDesiredSize(self: *const WritableStreamDefaultWriter) ?i32 {
 
 pub fn getReady(self: *WritableStreamDefaultWriter, exec: *const Execution) !js.Promise {
     _ = self;
-    return exec.context.local.?.resolvePromise(.{});
+    return exec.js.local.?.resolvePromise(.{});
 }
 
 pub const JsApi = struct {
diff --git a/src/cdp/domains/webmcp.zig b/src/cdp/domains/webmcp.zig
index eb591b12..188cfd10 100644
--- a/src/cdp/domains/webmcp.zig
+++ b/src/cdp/domains/webmcp.zig
@@ -256,7 +256,7 @@ pub fn onToolAdded(
     bc: *CDP.BrowserContext,
     event: *const Notification.ModelContextToolEvent,
 ) !void {
-    const global = event.exec.context.global;
+    const global = event.exec.js.global;
 
     var ls: js.Local.Scope = undefined;
     global.getJs().localScope(&ls);
@@ -280,7 +280,7 @@ pub fn onToolRemoved(
     bc: *CDP.BrowserContext,
     event: *const Notification.ModelContextToolEvent,
 ) !void {
-    const frame_id = switch (event.exec.context.global) {
+    const frame_id = switch (event.exec.js.global) {
         inline else => |g| g._frame_id,
     };
     try bc.cdp.sendEvent("WebMCP.toolsRemoved", .{
diff --git a/src/html5ever/lib.rs b/src/html5ever/lib.rs
index 63216a1d..ca8e74da 100644
--- a/src/html5ever/lib.rs
+++ b/src/html5ever/lib.rs
@@ -52,6 +52,8 @@ pub extern "C" fn html5ever_parse_document(
     reparent_children_callback: ReparentChildrenCallback,
     append_before_sibling_callback: AppendBeforeSiblingCallback,
     append_based_on_parent_node_callback: AppendBasedOnParentNodeCallback,
+    attach_declarative_shadow_callback: AttachDeclarativeShadowCallback,
+    allow_declarative_shadow: bool,
 ) -> () {
     if html.is_null() || len == 0 {
         return ();
@@ -78,6 +80,8 @@ pub extern "C" fn html5ever_parse_document(
         reparent_children_callback: reparent_children_callback,
         append_before_sibling_callback: append_before_sibling_callback,
         append_based_on_parent_node_callback: append_based_on_parent_node_callback,
+        attach_declarative_shadow_callback: attach_declarative_shadow_callback,
+        allow_declarative_shadow: allow_declarative_shadow,
     };
 
     let bytes = unsafe { std::slice::from_raw_parts(html, len) };
@@ -111,6 +115,8 @@ pub extern "C" fn html5ever_parse_document_with_encoding(
     reparent_children_callback: ReparentChildrenCallback,
     append_before_sibling_callback: AppendBeforeSiblingCallback,
     append_based_on_parent_node_callback: AppendBasedOnParentNodeCallback,
+    attach_declarative_shadow_callback: AttachDeclarativeShadowCallback,
+    allow_declarative_shadow: bool,
 ) -> () {
     if html.is_null() || len == 0 {
         return ();
@@ -148,6 +154,8 @@ pub extern "C" fn html5ever_parse_document_with_encoding(
         reparent_children_callback: reparent_children_callback,
         append_before_sibling_callback: append_before_sibling_callback,
         append_based_on_parent_node_callback: append_based_on_parent_node_callback,
+        attach_declarative_shadow_callback: attach_declarative_shadow_callback,
+        allow_declarative_shadow: allow_declarative_shadow,
     };
 
     // Parse directly from decoded string
@@ -472,6 +480,8 @@ pub extern "C" fn html5ever_parse_fragment(
     reparent_children_callback: ReparentChildrenCallback,
     append_before_sibling_callback: AppendBeforeSiblingCallback,
     append_based_on_parent_node_callback: AppendBasedOnParentNodeCallback,
+    attach_declarative_shadow_callback: AttachDeclarativeShadowCallback,
+    allow_declarative_shadow: bool,
 ) -> () {
     if html.is_null() || len == 0 {
         return ();
@@ -498,6 +508,8 @@ pub extern "C" fn html5ever_parse_fragment(
         reparent_children_callback: reparent_children_callback,
         append_before_sibling_callback: append_before_sibling_callback,
         append_based_on_parent_node_callback: append_based_on_parent_node_callback,
+        attach_declarative_shadow_callback: attach_declarative_shadow_callback,
+        allow_declarative_shadow: allow_declarative_shadow,
     };
 
     let bytes = unsafe { std::slice::from_raw_parts(html, len) };
@@ -587,6 +599,8 @@ pub extern "C" fn html5ever_streaming_parser_create(
     reparent_children_callback: ReparentChildrenCallback,
     append_before_sibling_callback: AppendBeforeSiblingCallback,
     append_based_on_parent_node_callback: AppendBasedOnParentNodeCallback,
+    attach_declarative_shadow_callback: AttachDeclarativeShadowCallback,
+    allow_declarative_shadow: bool,
 ) -> *mut c_void {
     let arena = Box::new(typed_arena::Arena::new());
 
@@ -615,6 +629,8 @@ pub extern "C" fn html5ever_streaming_parser_create(
         reparent_children_callback: reparent_children_callback,
         append_before_sibling_callback: append_before_sibling_callback,
         append_based_on_parent_node_callback: append_based_on_parent_node_callback,
+        attach_declarative_shadow_callback: attach_declarative_shadow_callback,
+        allow_declarative_shadow: allow_declarative_shadow,
     };
 
     // Create a parser which implements TendrilSink for streaming parsing
@@ -716,6 +732,8 @@ pub extern "C" fn xml5ever_parse_document(
     reparent_children_callback: ReparentChildrenCallback,
     append_before_sibling_callback: AppendBeforeSiblingCallback,
     append_based_on_parent_node_callback: AppendBasedOnParentNodeCallback,
+    attach_declarative_shadow_callback: AttachDeclarativeShadowCallback,
+    allow_declarative_shadow: bool,
 ) -> () {
     if xml.is_null() || len == 0 {
         return ();
@@ -742,6 +760,8 @@ pub extern "C" fn xml5ever_parse_document(
         reparent_children_callback: reparent_children_callback,
         append_before_sibling_callback: append_before_sibling_callback,
         append_based_on_parent_node_callback: append_based_on_parent_node_callback,
+        attach_declarative_shadow_callback: attach_declarative_shadow_callback,
+        allow_declarative_shadow: allow_declarative_shadow,
     };
 
     let bytes = unsafe { std::slice::from_raw_parts(xml, len) };
diff --git a/src/html5ever/sink.rs b/src/html5ever/sink.rs
index 371fd260..b47d8d96 100644
--- a/src/html5ever/sink.rs
+++ b/src/html5ever/sink.rs
@@ -62,6 +62,8 @@ pub struct Sink<'arena> {
     pub reparent_children_callback: ReparentChildrenCallback,
     pub append_before_sibling_callback: AppendBeforeSiblingCallback,
     pub append_based_on_parent_node_callback: AppendBasedOnParentNodeCallback,
+    pub attach_declarative_shadow_callback: AttachDeclarativeShadowCallback,
+    pub allow_declarative_shadow: bool,
 }
 
 impl<'arena> TreeSink for Sink<'arena> {
@@ -286,4 +288,26 @@ impl<'arena> TreeSink for Sink<'arena> {
             (self.reparent_children_callback)(self.ctx, *node, *new_parent);
         }
     }
+
+    fn allow_declarative_shadow_roots(&self, _intended_parent: &Ref) -> bool {
+        self.allow_declarative_shadow
+    }
+
+    fn attach_declarative_shadow(&self, location: &Ref, template: &Ref, attrs: &[Attribute]) -> bool {
+        // html5ever only calls this when shadowrootmode is "open" or "closed",
+        // so anything other than "open" is treated as "closed".
+        let mode_is_open = attrs
+            .iter()
+            .find(|a| a.name.local.as_ref() == "shadowrootmode")
+            .map(|a| a.value.as_ref() == "open")
+            .unwrap_or(true);
+        unsafe {
+            (self.attach_declarative_shadow_callback)(
+                self.ctx,
+                *location,
+                *template,
+                if mode_is_open { 1 } else { 0 },
+            ) != 0
+        }
+    }
 }
diff --git a/src/html5ever/types.rs b/src/html5ever/types.rs
index 48ed9c3e..13eb76a4 100644
--- a/src/html5ever/types.rs
+++ b/src/html5ever/types.rs
@@ -65,6 +65,13 @@ pub type AddAttrsIfMissingCallback = unsafe extern "C" fn(
 
 pub type GetTemplateContentsCallback = unsafe extern "C" fn(ctx: Ref, target: Ref) -> Ref;
 
+pub type AttachDeclarativeShadowCallback = unsafe extern "C" fn(
+    ctx: Ref,
+    host: Ref,
+    template: Ref,
+    mode_is_open: u8,
+) -> u8;
+
 pub type RemoveFromParentCallback = unsafe extern "C" fn(ctx: Ref, target: Ref) -> ();
 
 pub type ReparentChildrenCallback = unsafe extern "C" fn(ctx: Ref, node: Ref, new_parent: Ref) -> ();
diff --git a/src/main_legacy_test.zig b/src/main_legacy_test.zig
deleted file mode 100644
index bd77b5fa..00000000
--- a/src/main_legacy_test.zig
+++ /dev/null
@@ -1,281 +0,0 @@
-const std = @import("std");
-const lp = @import("lightpanda");
-
-const Allocator = std.mem.Allocator;
-
-// used in custom panic handler
-var current_test: ?[]const u8 = null;
-
-pub fn main() !void {
-    var gpa: std.heap.DebugAllocator(.{}) = .init;
-    defer _ = gpa.deinit();
-
-    const allocator = gpa.allocator();
-
-    var args = try std.process.argsWithAllocator(allocator);
-    defer args.deinit();
-    _ = args.next(); // executable name
-
-    var filter: ?[]const u8 = null;
-    if (args.next()) |n| {
-        filter = n;
-    }
-
-    var http_server = try TestHTTPServer.init();
-    defer http_server.deinit();
-
-    {
-        var wg: std.Thread.WaitGroup = .{};
-        wg.startMany(1);
-        var thrd = try std.Thread.spawn(.{}, TestHTTPServer.run, .{ &http_server, &wg });
-        thrd.detach();
-        wg.wait();
-    }
-    lp.log.opts.level = .warn;
-    const config = try lp.Config.init(allocator, "legacy-test", .{ .serve = .{
-        .insecure_disable_tls_host_verification = true,
-        .user_agent_suffix = "internal-tester",
-    } });
-    defer config.deinit(allocator);
-
-    var app = try lp.App.init(allocator, &config);
-    defer app.deinit();
-
-    var test_arena = std.heap.ArenaAllocator.init(allocator);
-    defer test_arena.deinit();
-
-    var browser: lp.Browser = undefined;
-    try browser.init(app, .{}, null);
-    defer browser.deinit();
-
-    const notification = try lp.Notification.init(allocator);
-    defer notification.deinit();
-
-    const session = try browser.newSession(notification);
-    defer session.deinit();
-
-    var dir = try std.fs.cwd().openDir("src/browser/tests/legacy/", .{ .iterate = true, .no_follow = true });
-    defer dir.close();
-
-    var walker = try dir.walk(allocator);
-    defer walker.deinit();
-
-    while (try walker.next()) |entry| {
-        _ = test_arena.reset(.retain_capacity);
-        if (entry.kind != .file) {
-            continue;
-        }
-
-        if (!std.mem.endsWith(u8, entry.basename, ".html")) {
-            continue;
-        }
-
-        if (std.mem.endsWith(u8, entry.basename, ".skip.html")) {
-            continue;
-        }
-
-        if (filter) |f| {
-            if (std.mem.indexOf(u8, entry.path, f) == null) {
-                continue;
-            }
-        }
-        std.debug.print("\n===={s}====\n", .{entry.path});
-        current_test = entry.path;
-        run(test_arena.allocator(), entry.path, session) catch |err| {
-            std.debug.print("Failure: {s} - {any}\n", .{ entry.path, err });
-        };
-    }
-}
-
-pub fn run(allocator: Allocator, file: []const u8, session: *lp.Session) !void {
-    const url = try std.fmt.allocPrintSentinel(allocator, "http://localhost:9589/{s}", .{file}, 0);
-
-    const frame = try session.createPage();
-    defer session.removePage();
-
-    var ls: lp.js.Local.Scope = undefined;
-    frame.js.localScope(&ls);
-    defer ls.deinit();
-
-    var try_catch: lp.js.TryCatch = undefined;
-    try_catch.init(&ls.local);
-    defer try_catch.deinit();
-
-    try frame.navigate(url, .{});
-    var runner = try session.runner(.{});
-    try runner.wait(false, .{ .ms = 2000 });
-
-    ls.local.eval("testing.assertOk()", "testing.assertOk()") catch |err| {
-        const caught = try_catch.caughtOrError(allocator, err);
-        std.debug.print("{s}: test failure\nError: {f}\n", .{ file, caught });
-        return err;
-    };
-}
-
-const TestHTTPServer = struct {
-    shutdown: bool,
-    dir: std.fs.Dir,
-    listener: ?std.net.Server,
-
-    pub fn init() !TestHTTPServer {
-        return .{
-            .dir = try std.fs.cwd().openDir("src/browser/tests/legacy/", .{}),
-            .shutdown = true,
-            .listener = null,
-        };
-    }
-
-    pub fn deinit(self: *TestHTTPServer) void {
-        self.shutdown = true;
-        if (self.listener) |*listener| {
-            listener.deinit();
-        }
-        self.dir.close();
-    }
-
-    pub fn run(self: *TestHTTPServer, wg: *std.Thread.WaitGroup) !void {
-        const address = try std.net.Address.parseIp("127.0.0.1", 9589);
-
-        self.listener = try address.listen(.{ .reuse_address = true });
-        var listener = &self.listener.?;
-
-        wg.finish();
-
-        while (true) {
-            const conn = listener.accept() catch |err| {
-                if (self.shutdown) {
-                    return;
-                }
-                return err;
-            };
-            const thrd = try std.Thread.spawn(.{}, handleConnection, .{ self, conn });
-            thrd.detach();
-        }
-    }
-
-    fn handleConnection(self: *TestHTTPServer, conn: std.net.Server.Connection) !void {
-        defer conn.stream.close();
-
-        var req_buf: [2048]u8 = undefined;
-        var conn_reader = conn.stream.reader(&req_buf);
-        var conn_writer = conn.stream.writer(&req_buf);
-
-        var http_server = std.http.Server.init(conn_reader.interface(), &conn_writer.interface);
-
-        while (true) {
-            var req = http_server.receiveHead() catch |err| switch (err) {
-                error.ReadFailed => continue,
-                error.HttpConnectionClosing => continue,
-                else => {
-                    std.debug.print("Test HTTP Server error: {}\n", .{err});
-                    return err;
-                },
-            };
-
-            self.handler(&req) catch |err| {
-                std.debug.print("test http error '{s}': {}\n", .{ req.head.target, err });
-                try req.respond("server error", .{ .status = .internal_server_error });
-                return;
-            };
-        }
-    }
-
-    fn handler(server: *TestHTTPServer, req: *std.http.Server.Request) !void {
-        const path = req.head.target;
-
-        if (std.mem.eql(u8, path, "/xhr")) {
-            return req.respond("1234567890" ** 10, .{
-                .extra_headers = &.{
-                    .{ .name = "Content-Type", .value = "text/html; charset=utf-8" },
-                },
-            });
-        }
-
-        if (std.mem.eql(u8, path, "/xhr/json")) {
-            return req.respond("{\"over\":\"9000!!!\"}", .{
-                .extra_headers = &.{
-                    .{ .name = "Content-Type", .value = "application/json" },
-                },
-            });
-        }
-
-        // strip out leading '/' to make the path relative
-        const file = try server.dir.openFile(path[1..], .{});
-        defer file.close();
-
-        const stat = try file.stat();
-        var send_buffer: [4096]u8 = undefined;
-
-        var res = try req.respondStreaming(&send_buffer, .{
-            .content_length = stat.size,
-            .respond_options = .{
-                .extra_headers = &.{
-                    .{ .name = "content-type", .value = getContentType(path) },
-                },
-            },
-        });
-
-        var read_buffer: [4096]u8 = undefined;
-        var reader = file.reader(&read_buffer);
-        _ = try res.writer.sendFileAll(&reader, .unlimited);
-        try res.writer.flush();
-        try res.end();
-    }
-
-    pub fn sendFile(req: *std.http.Server.Request, file_path: []const u8) !void {
-        var file = std.fs.cwd().openFile(file_path, .{}) catch |err| switch (err) {
-            error.FileNotFound => return req.respond("server error", .{ .status = .not_found }),
-            else => return err,
-        };
-        defer file.close();
-
-        const stat = try file.stat();
-        var send_buffer: [4096]u8 = undefined;
-
-        var res = try req.respondStreaming(&send_buffer, .{
-            .content_length = stat.size,
-            .respond_options = .{
-                .extra_headers = &.{
-                    .{ .name = "content-type", .value = getContentType(file_path) },
-                },
-            },
-        });
-
-        var read_buffer: [4096]u8 = undefined;
-        var reader = file.reader(&read_buffer);
-        _ = try res.writer.sendFileAll(&reader, .unlimited);
-        try res.writer.flush();
-        try res.end();
-    }
-
-    fn getContentType(file_path: []const u8) []const u8 {
-        if (std.mem.endsWith(u8, file_path, ".js")) {
-            return "application/json";
-        }
-
-        if (std.mem.endsWith(u8, file_path, ".html")) {
-            return "text/html";
-        }
-
-        if (std.mem.endsWith(u8, file_path, ".htm")) {
-            return "text/html";
-        }
-
-        if (std.mem.endsWith(u8, file_path, ".xml")) {
-            // some wpt tests do this
-            return "text/xml";
-        }
-
-        std.debug.print("TestHTTPServer asked to serve an unknown file type: {s}\n", .{file_path});
-        return "text/html";
-    }
-};
-
-pub const panic = std.debug.FullPanic(struct {
-    pub fn panicFn(msg: []const u8, first_trace_addr: ?usize) noreturn {
-        if (current_test) |ct| {
-            std.debug.print("===panic running: {s}===\n", .{ct});
-        }
-        std.debug.defaultPanic(msg, first_trace_addr);
-    }
-}.panicFn);
diff --git a/src/testing.zig b/src/testing.zig
index f89741fe..97e86d98 100644
--- a/src/testing.zig
+++ b/src/testing.zig
@@ -654,6 +654,15 @@ fn testHTTPHandler(req: *std.http.Server.Request) !void {
         });
     }
 
+    if (std.mem.eql(u8, path, "/src/browser/tests/401")) {
+        return req.respond("No", .{
+            .status = .unauthorized,
+            .extra_headers = &.{
+                .{ .name = "Content-Type", .value = "text/plain" },
+            },
+        });
+    }
+
     if (std.mem.eql(u8, path, "/404.js")) {
         // Valid JS body served with a 404 status. Used to assert that
         // ScriptManager does NOT execute the body of a failed script