Share a strict XML fragment parser across Range.createContextualFragment,
innerHTML, outerHTML and insertAdjacentHTML. Carry native in-scope namespace
bindings without inherited DTD entities, preserve XML node kinds and UTF-16
TrustedHTML inputs, and keep parsed scripts inert after adoption.
Validate the complete fragment before replacing existing children and expose
syntax failures as DOMExceptions in the callee realm. Keep setHTMLUnsafe on
its HTML parser path. Cover native Proxies, ShadowRoot and template contexts,
cross-realm calls, mutation atomicity and malformed namespace declarations.
Read the stored start boundary and native node document instead of public
Node properties. Use parent elements for Text, CDATA and Comment contexts
and create an HTML body for the specified fallback cases.
Remove the script-visible detached DOM fallback and preserve the Range
receiver realm when wrapping the fragment. Cover property overrides,
windowless and parsed documents, cross-realm calls, conversion ordering,
and registered native Range proxies.
Use the shared runtime script loader for native JS tree mutations regardless
of compatibility wrapper state. Test connectivity against the script's DOM
document, keeping parser-owned insertion on its separate deferred path.
Preserve early preparation bailouts, consume disabled and legacy-mismatched
scripts, and prepare completed windowless document.write scripts without
executing them. Resolve currentScript from the document execution stack even
when a live document has acquired compatibility metadata.
Cover nine tree operations across Window, iframe and popup owners, adoption,
DOMParser nodes, inert documents, fragments, templates and native Proxy aliases.
Use owner-aware native Node references and derived Web IDL arguments for
appendChild, insertBefore, replaceChild and removeChild. Windowless nodes
inherit the canonical owner-realm methods instead of legacy forwarders.
Preserve live delegate script preparation, original argument identities and
author properties during native adoption and subsequent tree access. Remove
unused private bridge routes and avoid rebinding public properties for native views.
Cover cross-realm errors, registered native proxies, atomic rejection,
mutation records, XPath invalidation and deep native subtree identity.
Update two owned snapshot-era tests against independent Chromium evidence.
Validation: cargo fmt --all; cargo clippy --workspace --all-targets
--all-features -- -D warnings; cargo nextest run --no-fail-fast
(23093 passed, 17 existing skipped; 32-way execution, no automatic retries).
Expose Document.fullscreen and Document/ShadowRoot.fullscreenElement through
the existing native receiver bindings, including LegacyLenientSetter behavior.
Use the shared returns_promise adapter for requestFullscreen and exitFullscreen
so receiver and argument errors reject callee-realm Promises. Convert options
with WebIdlArgs before acquiring native runtime references.
Cover 1361 Chromium-verified binding cases and registered native aliases while
retaining the existing unsupported-platform and fullscreenerror event behavior.
Create Text, Comment, CDATASection, ProcessingInstruction and DocumentFragment
objects directly on their owner realm's intrinsic interface prototype. Remove
their compatibility prototype layer and instance Symbol.toStringTag property.
Keep conversion in the binding realm and allocate native state in the owner's
context, including borrowed cross-realm Document methods.
Add an 880-case Chromium-verified matrix covering prototypes, constructor
replacement, cloning, tree operations and UTF-16 CharacterData.
Retain exact bootstrap/template boundary assertions at the reduced eager set
and verify first native wrapper creation materializes only owner-realm
CharacterData intrinsics. Preserve managed identities after public constructor
replacement in the node matrix as well.
Use generated WebIDL receiver checks for all result members and expose the
required snapshotItem length. Convert its index before checking the result
kind, preserving throwing and reentrant numeric conversions.
Resolve private result slots through the registered native backing for reads
and writes so aliases share scalar values, iterator cursors and mutation
invalidation. Keep author and revoked proxies outside native brands.
Cover all result kinds in live/windowless HTML/XML documents across realms,
including native aliases and unchanged snapshots after document mutations.
Use generated Element receivers and typed Attr/Element arguments before DOM
algorithm early returns. Preserve UTF-16 text and the original argument
identity in adjacent insertion.
Call Attr mutation helpers directly instead of forwarding through global
bridge methods. Share private Attr caches and ownership across registered
native proxies while rejecting author proxies through existing brands.
Cover two realms and live/windowless HTML/XML documents, conversion order,
replacement/removal, native proxy identity and lone surrogates.
Keep main's pinned rust-url IDNA patch while retaining the local URL fork's
file-host and path-segment fixes. Resolve URL, cookie and renderer consumers
to one shared IDNA package.
Use generated receiver checks for ShadowRoot members and Text.assignedSlot,
and expose enumerable ShadowRoot and slot operations. Share stylesheet
caches through the native backing identity and private slots so registered
native proxies remain usable without invoking author traps.
Cover borrowed bindings, callee-realm TypeErrors, forged/revoked/author
proxies, conversion ordering and genuine roots across live, windowless and
XML documents. Exercise registered native proxies in both realms.
Adapt document projections, popup activation, worker policy iteration and
navigation snapshots to the shared ContentSecurityPolicy type. Retain meta
policy provenance and reporting rules, and keep mutable creator lifecycle
state in the renderer. Place iframe source-list subsumption beside the
shared checks and preserve its existing regression coverage.
Port the upstream browser-response-headers feature, build adapter and C shim into the bundled libcurl. Keep the existing TLS EOF behavior and native connection timing while exposing the framing and header semantics required by main.
Use owned parser errors and typed math payloads, keep the 128-level numeric parsing limit and preserve RangeError classification. Pin the native font shorthand port on Stylo 0.22 instead of adding callback exceptions.
Use native receiver guards for Element and DocumentFragment mixin members,
including DocumentFragment.getElementById. Let detached wrappers and
ShadowRoot inherit canonical methods instead of reinstalling unguarded
forwarders with different metadata and identities.
Resolve registered Node proxies through their native backing object while
preserving pre-branding factory reads. Keep detached mutation synchronization
and create querySelectorAll results in the receiver realm without changing
the realm of selector exceptions. Mirror adoption delegates on native Proxy
backings while retaining canonical detached-tree identities.
Cover owner interfaces, cross-realm borrowing, conversion ordering, native
proxies, forged receivers, static/live collections and ShadowRoot inheritance.
Keep one copy of the image and Trusted Types regressions, native Document
charset setter and MessagePort test registration. Retain the stronger
policy regression and reuse the shared setter when initializing parsed
Document metadata. Avoid setting the child Document charset twice.
A srcdoc response supplies Unicode markup and is parsed as UTF-8 even
when the parent Document has a legacy charset. Match Chromium 152 and
keep the existing GBK mutation, cloning and per-Document isolation checks.
Expose detail through the native CustomEvent prototype declaration and
validate receivers with the shared interface brand. Keep arbitrary payload
values in the private event backing without projecting or copying them.
Convert inherited EventInit and raw CustomEventInit members through the
shared dictionary derive before initializing state. Preserve exceptions,
getter order, empty dictionary defaults and legacy initialization semantics.
Cover cross-realm descriptors, abrupt conversions, author and registered
native Proxies, windowless Documents and author-modified prototypes.
Keep record values in private slots and expose the nine readonly attributes
through branded prototype getters. Preserve snapshot identity across realms,
shadow properties, registered native Proxies, and retained records.
Create delivery arguments in the callback function's relevant realm so
MutationRecord wrappers and arrays use the correct prototypes.
Create a new callee-intrinsic Promise capability for every Web IDL Promise
conversion, including native Promise inputs. Resolve it with the input so
then lookup, asynchronous then calls and rejections follow V8's algorithm.
Cover realm and object identity, author-replaced public Promise constructors,
throwing then getters, revoked Proxies, scalar inputs, required arguments
and per-entry record conversion order. Require all 378 existing Payment
checks to pass instead of expecting the 16 native-Promise wrapping gaps.
Cancel same-stack form removal after requestSubmit for every respondWith
input, while retaining responses captured during submit dispatch or already
handed to asynchronous response processing. Track submission phases through
a native microtask continuation instead of inspecting Promise state.
Cover scalar, fulfilled and pending native Promise, and thenable responses,
manual and automatic submission, and late resolution after cancellation.
Keep the existing form unmount and original WebMCP WPT assertions intact.
Keep a lifecycle resident already bootstrapped for a foreign document.open
operation's exact target Document. Its later close action resumes that driver
instead of retiring it or clearing the target Document's queued work.
Cover open-before-owner-bootstrap followed by a separate close, including
exact admission ownership and reactivation of the parked resident.
Resolve existing ancestor targets through the native navigation model before
formdata can replace the source Document, retaining main's sandbox admission
checks alongside queued and cancellable form submission.
Run the inherited sandbox matrices through the Page task executor. Preserve
all cases and permission assertions, and cover same-origin POST interception
as supported by the Navigation API and verified in Chromium 152.
Retain the exact open/close action made by another Page and wake its lifecycle owner. Coalesce consecutive replacements without letting an unrelated action consume an older admission.
Resolve event callbacks through their own Context runtime binding so lifecycle listeners from other Page hosts are invoked and report exceptions in the correct Window.
Cover real HTTP popup replacement from root, iframe, popup and self, later close and repeated open/close, plus stale admission and coalescing authority.
Validation: cargo fmt --all; full workspace all-targets/all-features clippy -D warnings; cargo nextest run --no-fail-fast (22,989 passed, 17 existing skips, 32 threads, zero retries).
Retain the native entry Document instead of a host-local node handle, then
read its URL through native ownership after removal callbacks. Reuse the
canonical wrapper in its realm without reading author URL properties.
Apply the same entry reference to root, child and lightweight popup streams,
retaining strict origin checks and fragment handling for the same Document.
Retain creation-time policy snapshots by Document identity for local history
restoration, independently of about:blank origin and Window authority.
Initialize each new Document with the resolved policy before inherited meta
CSP delivery; preserve fresh navigation and later creator/target meta behavior.
Carry source lifecycle through shared history seeds, native requests, and
private activation state. Project from using the committed Document origin
so initial, inherited, cross-origin, and opaque sources stay distinct.
Record child Document origins at commit and retain the traversal visibility
boundary. Cover 19 real HTTP scenarios and the current upstream initial
about:blank WPT on both HTTP and HTTPS.
Capture the associated private state when synchronizing child history, so
readonly attributes and author shadows cannot erase or replace activation.
Restore its entry by identity even after same-document history changes.
Cover normal, shadowed and frozen objects and recreate their structured
state after source-isolate teardown using real HTTP child Documents.
Retain inherited requirements and the embedding origin at navigation admission.
Accept responses through Allow-CSP-From or source-list subsumption, preserving
nonce privacy, explicit/default port syntax and the policy origin for local URLs.
Commit blocked responses as opaque error Documents through the existing owner
lifecycle. Preserve WindowProxy identity and real Network facts while masking
public response timing. Restore local-scheme history with its original policy,
and share installed request-policy snapshots without changing bypass semantics.
Validation: cargo fmt --all; workspace all-targets/all-features clippy with
-D warnings; 22,952 nextest passes with 32 threads and zero retries (17 existing
skips). All 321 unchanged original WPT subtests pass (+80); 51 controlled cases
match Chromium 152. Original CSP fixture files and existing passed test IDs
remain unchanged.
Validate iframe CSP attribute transport syntax and retain the policy with
the admitted navigation target. Preserve it through deferred commits, owner
refreshes, history seed rollback and form/Location navigation rather than
reading mutable owner attributes when the fetch eventually starts.
Set one authoritative Sec-Required-CSP value on the child navigation request,
remove stale/forged duplicates without changing other raw header fields,
and preserve redirect propagation. Keep DOMString reflection unchanged and
reject CRLF injection, reporting directives and oversized attribute values.
Carry pending attribute navigation as a typed snapshot instead of a boolean
and thread the complete native navigation record through bootstrap/load.
Cover header safety, authoritative field replacement and admission-time
policy retention using real child navigation response terminals.
Use the shared WebIdlArgs dictionary converter for VideoColorSpaceInit and
map its generated snapshot writes onto the existing native private slots.
Constructor and native VideoFrame color producers now share one typed schema
without separate enum label tables or nullable-value assembly.
Keep constructor identity in the existing native constructor adapter and
native producer branding in the interface declaration. Preserve codec
configuration snapshot order and the separate toJSON property order, using
the container-level data_properties declaration for ordinary JSON results.
Carry the real network snapshot through ignored child navigation outcomes.
Report accepted frame-owner 204/205 fetches when timing is allowed, without
replacing the active Document, advancing history or dispatching load. Keep
downloads, unsupported MIME types and failed-TAO no-commit responses out of
the Resource Timing buffer.
Reuse one native frame-owner timing record for committed and ignored loads,
keep null-body representation metadata empty, and preserve historical Network
facts without letting stale completions affect replacement owners. Cover
204/205 status, TAO, Document identity, history and stale-owner delivery using
real response terminals.
Keep queued child navigation bootstrap, initiating URL and initiator kind in
one native record. Preserve frame-owner provenance when an already loaded
iframe uses the shared history/navigation machinery, without reporting child
Location or history navigations as parent resource fetches.
Route null-namespace src writes through the same iframe navigation helper and
retain the original UTF-16 attribute units while parsing the network URL.
Cover repeated URLs, cross-origin TAO, nested owner realms, load reentrancy,
Location navigation and lone surrogates in 58 fixture scenarios.
Retain selected socket and TLS observations through libcurl connection reuse,
HTTP/2 multiplexing and transfer retirement using the Rust monotonic clock.
Keep final-hop fetch time separate from physical connection creation, including
redirect preflights, and project through the existing branded resource slots
and native data-property JSON declarations.
Carry native timing into synchronous XHR and child-document resources while
preserving CORS/TAO filtering, lazy realm delivery and cache provenance.
Retire completed head-only responses without aborting reusable connections;
continue cancelling unfinished preflight and redirect bodies immediately.
Cover physical connection reuse, proxy TLS ordering, shared DNS, native JSON
snapshots, lazy main/child realms and held redirect preflights.
Carry shared DNS start/completion through the curl scheduler, preserving the
resolver clock across owner delivery, queue retirement and active completion.
Record TLS setup and request-preparation callbacks on each transfer's own
progress token; preserve curl-rust's default TLS certificate initialization.
Capture unrounded curl statistics once at terminal completion and reuse them
for logging. Expose partial typed observations to buffered, raw and HTML
consumers, keeping unavailable data distinct from native zero and from the
Web Resource Timing projection.
Cover DNS provenance, cache/redirect isolation, delayed consumption, HTTP/2
multiplexing and proxy tunnel ordering.
Ignore directives containing non-whitespace controls, DEL or non-ASCII
characters. Reserve the first directive name even when its value is ignored,
so later duplicates cannot replace it or bypass a valid default-src fallback.
Cover header/meta parsing, independent directives, reporting, Trusted Types
sinks and worker string/Wasm compilation. Keep source-token boundary checks
separate from invalid directive handling.
Throw inactive-owner and unavailable-context InvalidStateError in the
open method's realm, as the existing WebIDL binding requires. Keep the
XHR owner's native base URL and query encoding lookup after argument
conversion without switching exception construction to the caller realm.
Use the production-shaped multithreaded resource executor while LocalSet retains the V8 caller thread. Preserve all 192 cross-realm and ownership checks and the existing JavaScript timeout.