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.
Validate stored keys when creating a unique index and queue its failure as
an owned transaction operation. Preserve earlier request successes, abort
pending requests, and roll back upgrade metadata and data without throwing
from createIndex. Later mutations cannot erase the captured failure.
Deduplicate multiEntry keys within each record in shared key extraction so
index creation, writes, queries and cursors agree on uniqueness.
Cover Window, iframe and Worker execution, persisted upgrades, explicit
commit/abort, rollback, request event ordering and multiEntry duplicates.
The 102-case official WPT sample improves from 88 to 92 passes without
regressions; createIndex also gains two passing subtests per environment.
Reuse EventTarget listener dispatch for request, transaction and database
capture/bubble paths, ordered handler properties, listener options and callback
cleanup. Keep event parents private so author properties cannot change them.
Abort active transactions after uncanceled request errors or thrown listeners,
while preserving the original request error and giving pending requests fresh
AbortErrors. Keep committing transactions inactive, reject further commit/abort
calls, and abort committing request failures before their error notifications.
Cover event order, cancellation, listener exceptions, microtasks, explicit commit
and persisted data in Window, child and Worker regressions. Record 16 additional
complete official WPT passes.
Validation: fmt, strict workspace Clippy, and 19,159 nextest tests passed.
Official WPT sample: 54 -> 70 passes out of 78, without regressions.
Expose request attributes through branded readonly getters, including pending
result/error exceptions and cross-realm error and value identity. Keep native
state independent of author properties across cursor reuse and upgrade results.
Set done before upgradeneeded, reset aborted opens after transaction abort,
and deliver close-after-commit errors without another pending transition.
Capture deleted database versions before releasing the manager lock and emit
trusted intrinsic events with the required flags and version metadata.
Validate Window, iframe and worker behavior, property and constructor overrides,
cursor reuse, abort and close boundaries, and cross-realm getters. Record 12
new complete WPT passes; all 32 prior passes in the 50-case set remain passing.
Convert store names before the mode enum and read iterator methods once.
Use the generated receiver and required-argument checks. Reject live
upgrades, closing connections, missing stores and empty scopes before
creating or queuing transactions; reject versionchange after those checks.
Normalize transaction scopes to unique names.
Reserve the open result before upgrade-complete callbacks can enqueue
regular transaction results. Keep request.transaction until complete
returns and still check for a closed connection when delivering open.
Exercise Window, iframe and Worker through the production browser event
loop, including getter errors, pending transactions and upgrade state
boundaries. Record newly passing upstream WPT variants after verification.
Discover connections through the shared manager and deliver versionchange
notifications through each owning event loop. Acknowledge notifications after
their microtask checkpoints and retain the resulting blocked-event decision
when a later timer closes the connection.
Keep closing connections alive until accepted transactions finish, including
transactions awaiting their backend start. Abort transactions and release
connection requests when a worker exits. Keep borrowed database operations
in the connection's realm while preserving the callee's exception realm.
Count transaction requests only after an operation is accepted, so synchronous
validation errors cannot leave closing connections waiting on phantom work.
Cover Window/Worker and two-worker notifications, close-pending transactions,
cross-realm methods, worker termination, rollback and retired requesters.
Reserve every accepted request's position in a shared storage-key/name queue
before looking up the database version. Keep upgrades at the head until their
transaction and final connection-close check finish, and notify connections
created by earlier requests when each successor reaches the head.
Wake the accepting Window or worker event loop on completion, and release
retired owners only after closing their connections. Preserve per-connection
versionchange tasks and decide blocked events after their microtask
checkpoints, before a timer can close the notified connection.
Cover same/default versions, repeated open/delete, abort and VersionError,
completion-microtask close, cross-realm retirement, and bidirectional waiting
between a Window and a worker.
Give each connection its own task and microtask checkpoint, then recheck
blocking connections from the requesting realm. Retired notification realms
leave the recheck runnable, and connections closed by earlier callbacks are
skipped. Keep later same-database requests behind pending notifications.
Validation: cargo fmt --all; strict all-workspace Clippy; all 19,137 nextest
tests passed. Both official transaction-lifetime WPT variants now pass;
46-case comparison has no regressions.
Expose the requested version on provisional connections, snapshot the prior
schema, and synchronously restore database/transaction/store metadata on abort.
Track created and deleted store/index handles so replacements with the same
name are not revived. Use native transaction ownership during rollback.
Keep the open request transaction through its abort event, then queue the open
failure. Share deletion checks across store/index requests and sort IDB name
lists by UTF-16 code units.
Cover initial and existing upgrades, schema/data rollback, retained handles,
same-name replacements, author property getters, and abort event ordering.
Keep incoming main's classification for the three cases that appeared in
multiple result lists after history replay. Ensure all case lists remain sorted
and mutually exclusive.
Preserve owner interruptions during deferred script preparation and use the
current HTML stream and custom-element construction interfaces. Restore
body/window content-handler registration on the new child insertion path and
remove mutation adapters superseded by the shared parser lifecycle.
Validation: cargo fmt --all; strict all-feature workspace Clippy; cargo nextest
run --no-fail-fast (19,128 passed, 13 skipped). The nine child handler regressions
also pass in a focused run.
ldm0