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.
Expose db, mode and error as readonly prototype accessors with generated
WebIDL receiver checks. Keep values in V8 private slots so completed
transactions retain their database and error without adding Rust Global roots.
Update abort errors without invoking author properties. Cover shadowing,
freezing, request error identity, lifecycle transitions and cross-realm
receivers in Window, child Window and Worker.
Convert transaction options in WebIDL order and retain the original hint in
native transaction state. Resolve bucket defaults at commit and expose a
branded readonly durability accessor across realms and lifecycle states.
Publish complete file snapshots atomically, sync strict writes, and restore
previous data after persistence errors. Release quota reservations before
completion or abort callbacks can reenter storage.
Cover conversion, receivers, queueing and callback reentry in Window, child
Window and Worker, plus persistence rollback and reopen behavior.
Store oldVersion and newVersion in private event state and expose branded
readonly prototype accessors for authored and native events. Correct the
constructor arity and convert the full inherited initialization dictionary
in WebIDL order, honoring EventInit flags for authored events.
Cover getter receivers and realms, numeric conversion and exceptions,
author property shadows, subclassing, and upgrade/blocked/delete event
metadata in Window, child Window, and Worker regression tests.
Enable generated IDBFactory receiver checks before argument conversion and
use the existing Promise rejection adapter for databases(). Keep successful
databases promises and settlement tasks in the factory owning realm so
borrowed methods do not leave cross-realm calls pending. Correct open.length.
Cover forged and Proxy receivers, conversion ordering, rejected Promise and
error realms, prototype mutation, and genuine cross-realm open/list/delete
operations in Window, child Window, and Worker regression tests.
Reject readonly clear() calls synchronously after deleted and active checks,
before allocating or queuing an IDBRequest. Preserve the called method's realm
for synchronous exceptions, entering the object store's realm only for request
creation and execution. Keep request identity and dispatch with its transaction.
Cover started and queued transactions, author property overrides, invalid
receivers, cross-realm calls, error events, commit/abort state and preservation
of record ordering, index entries and the key generator in Window and Workers.
Replace writable instance fields with branded readonly prototype getters for
object store and index metadata and parent links. Keep each handle's keyPath
array stable across schema edits and rollback, independently of its native
key path. Return fresh index name snapshots from native schema.
Remove schema writes to author-visible properties so frozen overrides cannot
interfere with index creation, renaming, deletion or upgrade rollback.
Cover Window, child and Worker receivers, cross-realm calls, forged and Proxy
receivers, exposed-array mutation, retained handles and same-name schema edits.
Keep object store identity and transaction scopes as UTF-16 names throughout
lookup, scheduling, records and persistence. Rename stores atomically during
upgrades while retaining records, indexes, key generators and cursor state;
restore original handles on abort without confusing same-name replacements.
Expose native name and objectStoreNames accessors with receiver validation.
Project name lists from native schema and scopes so author properties cannot
intercept schema changes. Enforce transaction scope and finished-state checks.
Cover Window, child and Worker behavior, cross-realm errors, rollback,
unpaired surrogates, legacy persistence and transaction lock isolation.
Replace the writable name field with native accessors using generated
receiver checks. Rename backend metadata and handles together, preserve
per-transaction identity, and restore pre-upgrade names on abort while
new indexes retain their last names. Keep conversion and exceptions in
the callee realm, including reentrant schema changes during ToString.
Preserve UTF-16 index names through conversion, lookup, sorted name lists,
deletion and persistence. Retain the legacy JSON representation for
well-formed Unicode names and store unpaired surrogate units losslessly.
Cover Window, child Window and Worker behavior with a shared fixture,
plus atomic rename/rollback and persistent storage round-trip tests.
Validation: fmt, strict workspace clippy, 19,192 nextest tests passed.
Official WPT regression suite: 296 to 302 of 304 cases passing,
30 additional passing subtests and no regressions.
Invalidate cursor scans when records change, preserving cached traversal
when the transaction revision is unchanged. Seek from native key and
primary-key boundaries after rebuilding the original range and direction.
Keep pending scans separate until success delivery so unread and cached
cursor values retain the prior record. Cover live writes, duplicate keys,
unique/reverse cursors, advance, continuePrimaryKey, multiEntry indexes,
clear/reinsert and interleaved requests in Window, child Window and Worker.
Track the cursor got-value flag independently of its visible position.
Clear it when iteration is accepted and restore it when new cursor data
is delivered, so repeated navigation and mutations fail while pending.
Apply transaction, deleted-source, direction and value-state checks before
key conversion in the order required by each method. Keep advance count
conversion and its zero check ahead of transaction validation.
Share native state checks with update/delete and cover retry after invalid
arguments, reentrant count conversion, recreated sources and error realms
in Window, child Window and Worker.
Keep cursor entries and direction in native state so mutated returned keys
and shadowed public attributes cannot redirect iteration or writes.
Materialize key, primaryKey and value lazily in the first getter realm and
cache them until cursor iteration settles.
Expose readonly prototype accessors with the shared WebIDL receiver guard
for both cursor interfaces, including methods and cross-realm TypeErrors.
Cover array, Date and binary keys, update/delete targets, property pollution,
cache lifetime, exhaustion and Window/child/Worker behavior.
Store key range bounds and open flags in private V8 snapshots. Expose
readonly prototype accessors and use native WebIDL receiver branding for
getters and includes, including cross-realm calls and author Proxies.
Queries and deletion now ignore public attribute shadows and mutations of
returned keys. Remove the redundant range marker and runtime registry.
Correct the open flag of unbounded endpoints and static method lengths.
Cover bounded, unbounded and empty queries in upgrade, running and queued
transactions, plus getter exception ordering and callee-realm errors.
Validation: cargo fmt, workspace Clippy with -D warnings, and all 19,185
nextest tests passed (13 skipped). In 242 official IndexedDB WPT cases,
passes increase from 230 to 232 with no subtest regressions.
Expose branded, readonly IDBRecord snapshots and getAllRecords on stores and
indexes in Window and Worker realms. Share collection conversion and result
materialization across immediate and queued requests, preserving native query
snapshots, count=0, options conversion order and callee-realm errors.
Deduplicate ascending index entries before reversing prevunique results so
collections and cursors select the lowest primary key for each index key.
Cover records, mutable keys, multiEntry, queued transactions, getter failures,
receiver branding and cross-realm behavior in Window, child Window and Worker.
Validation: cargo fmt --all; workspace clippy with all targets/features and
-D warnings; full nextest (19184 passed, 13 skipped). Official IndexedDB WPT
passes rise from 212 to 226 of 238 cases, adding 292 passing subtests without
regressions. Window, child Window and Worker record probes pass.
Coordinate regular transactions across connections and event loops using
native admission leases. Include pending predecessors in scope conflicts,
wake the accepting realm after commit or abort, and retire admissions when
connections or workers close. Deferred starts retain native mode and scope.
Readonly transactions no longer publish snapshots. Merge ordinary writes
only within their store scope and check quota against the merged database
so disjoint commits cannot overwrite each other or bypass quota.
Cover FIFO admission, persistent stores, quota and teardown in native tests,
and exercise transaction ordering and worker termination in Window, child
Window and Worker integration tests.
Keep converted key ranges, counts and directions in the transaction queue.
Query execution no longer reads caller-owned arrays, dates or binary buffers
again. Use one owned operation enum instead of separate Local/Global forms.
Apply the same range conversion to delete(), including synchronous read-only
validation, single conversion of key getters, and open/closed range bounds.
Keep point deletion on its direct key lookup path.
Cover blocked and started transactions, mutations and detached buffers,
getter evaluation, store/index results, preceding writes, range deletion
and rollback in Window, child and worker realms with a Chromium control.
Validation: cargo fmt --all; strict full workspace Clippy; 19,174 nextest
tests passed. The 220-case WPT matrix improves from 190 to 196 passing cases,
with 14 newly passing subtests and no regression. The 548-check fixture passes
unchanged in Moli and Chromium Window/Worker, plus Moli child-realm coverage.
Represent Number, Date, UTF-16 string, binary and compound keys separately
with IndexedDB ordering. Preserve binary snapshots and signed zero values,
reject invalid keys without coercion, and retain exceptions from key getters
through ranges, queries, writes and cursor operations.
Persist compound keys as flat tokens so deep keys survive database reopen,
while continuing to read legacy key records. Correct the key generator's
inclusive 2^53 limit and distinguish missing arguments from undefined keys.
Validation: cargo fmt --all; full workspace Clippy with all targets/features
and -D warnings; cargo nextest run --no-fail-fast. The 180-case IndexedDB WPT
comparison gains 24 passing cases and 188 passing subtests with no regression.
The same 259-check fixture passes in Chromium and Moli Window/Worker, with
Moli integration coverage for child realms and native disk reopen tests.
Validate key paths and schema options in the backend before metadata writes.
Preserve method-specific precedence for duplicates, syntax and option errors,
and use native transaction mode together with activity and deletion state.
Check receivers and required arity before conversion, consume iterable key
paths once, and read IDB dictionary members in WebIDL order. Keep synchronous
schema exceptions in the callee realm while mutating the store in its owner
realm.
Cover native metadata rejection, argument parsing and Window/iframe/Worker
behavior. Record eight newly passing official IndexedDB WPT cases.
ldm0