Clear the initialized HTML shell before returning a shallow Document clone.
This removes the unexpected doctype/root and allows callers to append a new
document element. Deep clones still copy the source children.
Cover omitted/false/undefined deep arguments, rootless and custom-root HTML,
doctype-only documents, XHTML/XML controls, and preserved source identity.
All 273 shared browser assertions pass; 15 upstream cases retain all 1442
passing subtests.
Validation: cargo fmt --all; workspace/all-targets/all-features Clippy with
-D warnings; cargo nextest run --no-fail-fast (19464 passed, 13 skipped).
Resolve the default element namespace from internal Document metadata instead
of the current root element. Initialize native and detached MIME state together
and preserve it when cloning, without reading overwritten public properties.
Cover parser MIME types, root replacement, shallow/deep clones, explicit
namespaces and getter overrides with 689 shared browser/Rust assertions.
Document-createElement-namespace.html now passes all 51 subtests; all 13
related upstream cases pass (1438 subtests).
Validation: cargo fmt --all; workspace/all-targets/all-features Clippy with
-D warnings; cargo nextest run --no-fail-fast (19463 passed, 13 skipped).
Prepare connected script candidates after DOM mutation borrows are released
and execute child inline classics before the inserting DOM call returns.
Reuse the child realm runner for CSP, error reporting and execution cleanup;
remove the obsolete queued DynamicClassic work and preserve currentScript
on the execution Document across nested scripts and adoption.
Cover initial about:blank, srcdoc, reentrant fragments, script errors,
Shadow DOM, retirement and microtask order. Move three location WPT cases
to passed and the newly observable window.open referrer failure to failed.
Validation: cargo fmt --all; full workspace clippy with all targets and
features and -D warnings; cargo nextest run --no-fail-fast (19457 passed,
13 skipped). 35 related WPT cases show no previously passing regression;
104 timing/CSP checks pass against Chromium. The running-script shadow
movement probe follows the HTML currentScript algorithm and differs from
Chromium 145; both official Shadow DOM WPT cases pass.
Keep strict Element receiver checks and bind ShadowRoot.onslotchange through
its generated native brand check. Deduplicate replayed helpers, modules and
identical visibility regressions.
Invalidate style observations only when StyleViewport changes, and update the
visual-state generation independently so CDP presentation changes still emit
screencast frames. Align the Grid regression's CSSOM and capture viewports
without changing its value or layout-count assertions. Format the merged
parser and layout code.
Validation: cargo fmt --all; strict all-feature, all-target workspace Clippy;
cargo nextest run --no-fail-fast; workspace Moli build; 665 Python tests;
80 CSP WPT cases retain exactly the same results as before the rebase.
Add catch(callback) with native receiver and callback bindings. Forward source
values and completion, then convert the catcher's return value into one recovery
subscription after a source error. Recovery errors go directly downstream.
Replace the traced upstream observer when recovery starts so pending Promises
retain the replacement producer without retaining the exhausted source and
catcher. Reuse the existing signal-owned cancellation algorithms.
Cover Window/Worker conversion, error identity, shared subscriptions, reentrant
cancellation, teardown ordering, realms and GC. Verify all nine upstream catch
subtests in both realms and add those cases to the pass catalogue.
Cancel the previous inner before mapping each source value, convert mapper
results through the native Observable path, and wait for active inner
completion after the source completes. Preserve the draft's shared controller
reference under reentrant mapper, conversion and teardown callbacks.
Trace each live inner and release replaced observers without persistent roots
outside the existing signal stores. Finish Window and Worker dependent abort
dispatch after IteratorClose failures, then propagate the first exception.
Cover Window and Worker conversion, switching, cancellation, cross-realm
receivers and callbacks, GC, and reentrant synchronous completion. Verify 61
related WPT cases: 576/592 to 590/592 subtests, no regressions. Add switchMap
and finally Window/Worker cases to the verified pass catalogue.
Queue source values until each mapped inner subscription completes, preserving
mapper indices, synchronous completion order, sharing and callback realms.
Trace the producer graph in V8 and release exhausted sources and queued values.
Finish shared abort algorithms before rethrowing the first IteratorClose
failure so cancellation always reaches both source and inner producers.
Cover Window/worker behavior, reentrancy, cancellation, realms and GC lifetimes.
Build WindowProperties into the native template inheritance chain before
context creation so Window.prototype and EventTarget.prototype can keep
immutable prototypes while remaining extensible. Link Window's interface
constructor to EventTarget as well.
Preserve WindowProperties visibility and exotic mutation rules through
native interceptors, including inherited accessors, different receivers,
numeric names and symbols. Remove the post-bootstrap Proxy insertion.
Cover main and child realms with 186 regression assertions, verify
cross-origin navigation and promote the passing immutable-prototype WPT.
Build dedicated, shared and service worker globals from the native
EventTarget template before context creation. Preserve immutable global
prototype chains and explicitly link the Web IDL interface constructors.
Cover all three worker kinds with the same regression fixture, including
inherited when(), event delivery, cancellation, global error reporting,
receiver branding and replacement of the public EventTarget constructor.
Promote the passing worker inspect and immutable-prototype WPT cases.
Convert inspector callbacks through the shared observer conversion boundary and
invoke them before source notifications. Remove the abort hook on producer
termination, report consumer-abort callback errors in their own realm, and trace
pending subscriptions without retaining abandoned callbacks.
Cover Window/Worker behavior, conversion order, reentrancy, cleanup errors,
callback realms and garbage collection. Fix 27 WPT subtests, including the two
takeUntil-toArray crashtests; worker-global when exposure remains a separate fix.
Convert notifier inputs using the native Observable conversion path, subscribe
to the notifier first, and share downstream cancellation across both inputs.
Notifier next/error completes downstream; notifier completion leaves the source
running and releases the exhausted notifier graph.
Cover receiver and conversion semantics, sharing, reentrancy, cleanup errors,
cross-realm results, Window/Worker behavior and garbage collection. Add the
three passing takeUntil WPT cases, fixing 26 subtests without regressions.
Reuse lazy native transform subscriptions for take/drop, preserving shared
counts, reentrant notification ordering, cancellation and early completion.
Keep each subscription's unsigned 64-bit count in a traced BigInt slot.
Fix unsigned-long-long conversion losing low bits for negative values by
applying the sign wrap in u64 after converting the magnitude. Add count,
conversion, Window/worker, realm, iterator-close and GC regression coverage.
Validation: fmt, all-target/all-feature workspace clippy, 172 targeted tests,
full nextest (19,297 passed; 13 skipped), 194 runtime checks, 40 realm checks,
and 43 WPT cases improving from 441/469 to 467/469 without regressions.
Share native transform observers and callback indices across Window and worker
bindings. Trace live upstream chains without rooting abandoned subscriptions,
and release observer state after cancellation and pre-aborted subscriptions.
Preserve callback errors and terminal notifications when iterator closing fails,
finish teardown before propagating explicit cancellation errors, and cover
sharing, reentrancy, cross-realm calls, native lifetimes and mutable globals.
Validation: fmt, workspace clippy with all targets/features, full nextest
(19,292 passed; 13 skipped), 201 Window/worker fixture checks, 40 realm checks,
and 39 WPT cases improving from 416/443 to 441/443 subtests without regressions.
Resolve predicate consumers on the first deciding value and cancel only
their own observer. Reuse traced WebIDL callbacks and native Promise state,
with boolean predicate conversion and reentrant settlement protection.
Cover shared subscriptions, conversion order, exception identity, worker
execution, callback/Promise realms, and callback lifetime after cancellation.
The focused WPT set improves from 364/418 to 416/418 subtests; eight complete
cases are added to the passing catalogue.
Validation: cargo fmt --all; all-targets/all-features workspace clippy with
-D warnings; CLI build; 160 focused tests; full nextest (19,287 passed,
13 skipped); 302 semantic checks in Window and worker; 48 realm checks.
Implement native callback-driven Promise consumers for Window and workers,
using traced WebIDL callbacks and shared cancellation/settlement helpers.
Preserve exception identity, raw reducer values, reentrant notification
ordering, callback realms, and independent subscriptions.
Add conversion, cancellation, cross-realm, GC, and worker coverage. Record
five newly passing WPT cases: the audited suites improve from 330/372 to
364/372 subtests, with EventTarget regressions remaining 150/150.
Validation: cargo fmt --all; workspace all-targets/all-features clippy with
-D warnings; CLI build; 156 focused tests; full nextest (19,283 passed,
13 skipped). The supplemental fixture passes 132 checks in both globals.
Add completion-based Promise operators in Window and workers, preserving
raw values, shared subscriptions and direct AbortSignal ordering. Reuse
the native Promise observer lifetime and settlement logic with first.
Cover receiver conversion, callee realms, thenable reentrancy, inherited
array setters and value reachability. Related WPTs improve from 302/326
to 324/326; EventTarget regressions remain 150/150.
Add Observable.first in Window and workers through the shared WebIDL
receiver and Promise adapters. Native observers use internal subscription
and AbortSignal dependency graphs, preserving shared producers and
reentrant Promise resolution without consulting public JS methods.
Cover thenable reentrancy, abort/teardown order, iterable closing,
callee realms, and observer reachability. Related WPTs improve from
290/304 to 302/304; EventTarget regressions remain 150/150.
Implement Observable.from for Window and workers with native input brands,
per-subscription iterator records, Promise reactions and async-from-sync
adaptation. Preserve getter timing, exception identities and cancellation.
Keep private iterator abort algorithms weak in the existing signal stores,
and propagate synchronous iterator close errors through native cancellation.
Cover shared Window/worker semantics, callee realms and abandoned iterator GC.
The two official from variants improve from 2/48 to 46/48 each. Retain the
next-getter timing discrepancy and the unimplemented first() dependency as
failures; the existing Observable, AbortSignal and EventTarget cases pass.
Implement EventTarget.when for Window and worker targets using native Observable subscriptions and the existing event listener and AbortSignal routes. Preserve capture/passive conversion, weak targets, native receiver brands and exact Window identity across navigation.
Cover multicast cancellation and restart, DOM propagation, public method tampering, cross-realm receivers, garbage collection and Window replacement. Add four verified WPT cases: 348/348 relevant subtests pass against Chromium. Workspace fmt, clippy and nextest pass (19267 tests, 13 skipped).
Replace partial XML trees with a single parsererror root in the namespace
specified by HTML's DOMParser algorithm. Keep diagnostics as text and retain
the requested content type and document metadata. XHR parsing continues to
return no document on XML errors.
Replace Chromium-specific error-wrapper assertions with coverage for empty,
malformed and namespace-invalid input, prologues, doctypes, cross-realm
documents, serialization and valid author-created parsererror elements.
Validation: workspace fmt and strict all-feature Clippy; full nextest
19258 passed, 13 skipped; 22 WPT cases / 344 subtests; 1776 JS assertions.
Use the query root's current owner-document mode for ASCII class matching,
including cached collections after adoption. Standards and limited-quirks
documents retain case-sensitive matching.
Reuse native live collections for detached class queries so class changes,
tree mutations and cross-realm method calls use the current DOM. Cover
HTML, SVG, MathML, XML, whitespace and non-ASCII class names.
Validation: workspace fmt and strict all-feature Clippy; full nextest
19258 passed, 13 skipped; 37 WPT cases / 76 subtests; 813 JS assertions.
Register branded MediaSource objects alongside Blob entries, preserving native
identity, creator keys and URL lifetimes. Capture the entry kind in parsed URLs
and reject MediaSource fetches with a network error.
Cover identity retention through wrapper GC and isolate teardown, revocation,
cross-realm receivers and worker consumers. Add the passing MediaSource WPT
to the catalogue.
Refresh the sorted, combined header pairs after each callback while keeping
the iteration index. Deletions, updates and additions made by script now
affect subsequent visits as required by WebIDL pair iteration.
Cover mutations, Set-Cookie entries, reentrancy, author iterator overrides,
callback Proxies and abrupt completion in Window and Worker contexts. Extend
the callback realm regression to append and visit a header from an iframe.
Keep normalized fields in their original order and combine them for public
iteration and header consumers. Read inherited Request headers from private
slots so mode changes preserve safe fields and do not invoke author getters.
Preserve the lists through Headers mutation, Request/Response clone and Cache
round trips, with shared Window/Worker regressions for duplicates, empty values,
public projections, script overrides and body clones.
Check the combined header value before each append, both during Request/fetch
initialization and Headers.append. Reject an unsafe addition without losing
previously accepted fields, and apply the MIME parser to Content-Type parameters.
Add shared Window/Worker regression coverage for length boundaries, duplicate
fields, content types, cloning, guard overrides and Headers mutations.
Resolve single ranges against captured Blob bytes for Window and Worker Fetch
and XHR, including partial response headers and integrity verification. Reject
malformed or unsatisfiable ranges and normalize author headers before CORS
preflight and context overrides so repeated ranges cannot lose earlier values
or skip preflight.
Cover byte boundaries, cloned and revoked URL entries, empty and binary bodies,
request guards, synchronous XHR, and partial-body integrity. Add the two passing
Blob range WPT cases to the verified catalogue.
Preserve integrity through Window and worker fetch continuations and wait for
complete response bytes before applying the shared SRI validator. Cover local,
network, intercepted, and Service Worker responses, retaining null-body state
and abort reasons.
Add regressions for digest selection, body completion, and null versus empty
responses; preserve non-ASCII whitespace in integrity metadata parsing.
Always expose Content-Length from the Blob's byte size and Content-Type
from its type, including empty values. Fetch and XHR use the same builder
for fresh and captured Blob URL entries.
Cover binary and Unicode payloads, empty types, File and slice responses,
cloned requests, and URL revocation in Window and Worker tests.
Reject shared and resizable BufferSource bodies and validate receivers
through the existing WebIDL brand checks. Convert arguments before checking
send state or discarding GET/HEAD bodies, preserving coercion exceptions.
Read method and synchronization state after conversion so reentrant open()
and send() calls take effect. Defer native body extraction until conversion
and state checks finish, avoiding buffer copies for GET and HEAD.
Cover Window and Worker conversion ordering and real HTTP reentrancy.
Validation: cargo fmt --all; strict workspace/all-target/all-feature clippy;
full nextest (19236 passed, 13 skipped). Official Fetch/XHR comparison gains
2 passing cases and 28 subtests with no other changes across 154 cases.
Window, Dedicated and Shared Worker probes match Chrome on 4872 checks
and 57 actual HTTP requests.
Remove the per-document 32-request quota that rejected otherwise valid
synchronous XHR sends. Keep the existing script watchdog and page
cancellation, with regressions for repeated requests across objects and
script turns, plus recovery after terminating an infinite request loop.
Validation: cargo fmt --all; strict workspace/all-target/all-feature clippy;
full nextest (19233 passed, 13 skipped). The 154-case official Fetch/XHR
comparison gains one passing case and two subtests without regressions.
Window and both worker probes match Chrome on 6720 checks and 960 POSTs.
Forward Window and Worker Fetch referrer values into the transport without
changing the request origin, cookie initiator, or network partition.
Derived preflight requests inherit referrer state and policies while keeping
other metadata, including integrity, separate.
Cover real Window and Worker requests, buffered and streaming preflights,
referrer overrides, sanitization, and request identity preservation.
Use the existing Request guard selection for Window and Worker fetch headers,
including Request inputs with overridden headers. Preserve inherited headers
when no override is supplied and retain the no-cors guard.
Cover forbidden headers, method override values, all initializer forms,
conversion exceptions, and unmodified inputs in both native fetch paths.
Finalize pending final headers when curl completes a streaming transfer
without an empty header separator. Apply the existing cookie, cache, and
client-hint policy before the owner publishes or retries the response.
Track header finalization separately from response start, preserving
redirects and deferred 304 responses. Keep failed and cancelled transfers
on their existing error paths and cover the behavior with raw TCP tests.
Project the response header list once for all delivery paths, reusing
Headers response guards and normalization. Hide both cookie headers,
combine repeated values, and use XHR legacy uppercase-byte sorting.
Preserve the original response head for MIME processing and network
metadata; cover delivery states, credential modes, and request reuse.
Encode request ByteStrings without UTF-8 expansion and decode response
fields byte-for-byte, trimming only HTTP OWS. Keep curl header storage
alive with the transfer handler, including redirects and error paths.
Share parsing with the request/response journal and proxy CONNECT
recorder; cover all transport modes, raw wire bytes, and disk cache.
Serialize the final response MIME record instead of applying Blob
constructor normalization. Fall back to text/xml when response MIME
extraction fails and preserve valid parameter values and casing.
Extend shared Fetch MIME extraction to return the parsed record, including
charset inheritance across repeated Content-Type values. Cover response
headers, overrides, and asynchronous Window and synchronous/asynchronous
Worker responses while preserving Blob constructor normalization.
Install WorkerGlobalScope.indexedDB through the native WebIDL receiver
binding and keep SameObject identity in the existing lazy realm cache.
Author properties no longer replace or discard the native factory.
Cover Dedicated, Shared, Service, and opaque-origin worker bootstraps,
illegal receivers, readonly assignment, author shadows, and lazy storage.
Record the newly passing dedicated-worker IndexedDB IDL WPT.
Set put/add length to 1 and count/openCursor/openKeyCursor length to 0
through the existing ObjectStore and Index bindings. Align the existing
descriptor test with Web IDL and record the verified Window idlharness pass.
The official Window and Worker IDL suites resolve 16 failing subtests;
Window now passes all 207 assertions.
Validation: cargo fmt --all; strict workspace clippy; cargo nextest run
--no-fail-fast (19209 passed, 13 skipped). No new regressions in 442 WPTs.
Carry IndexedDbName through factories, backend state, request queues and
connection notifications so unpaired surrogates stay distinct from U+FFFD.
Preserve the legacy JSON map for Unicode names and persist other names as
UTF-16 code units alongside it.
Cover records, versions, rollback, deletion, cross-realm calls and worker
notifications with a shared browser fixture, plus persistence and queue tests.
Validation: cargo fmt --all; strict workspace clippy; cargo nextest run
--no-fail-fast (19209 passed, 13 skipped).
Expose name and version as readonly prototype accessors with the existing
WebIDL receiver checks. Keep connection values in private slots so upgrade
rollback cannot overwrite author descriptors or fail on frozen databases.
Refresh only store metadata when committing a transaction, preserving
author-defined name/version properties.
Cover successful and aborted upgrades, closed connection snapshots,
protected properties and cross-realm receivers in Window, child Window
and Worker. Update the legacy assertion for own database properties.
ldm0