Exercise name validation, admitted reads and writes, value and key cursors, reused names, cross-realm aliases, and explicit or constraint-driven upgrade aborts in Window, child and Worker contexts.
Keep the raw Page rejection on its streaming entry point while the server
holds the body, without racing a 100ms response-header budget.
Move the body-specific deadline case to prepared streaming headers and the
real body materializer. Retain the 100ms budget and typed body phase, and
assert transfer cancellation and channel release.
Capture the loader's browser cookie scope on the retained Service Worker
request before a synthetic redirect advances its SameSite restrictions.
Reuse the transport binding to preserve frame partition keys and Storage
Access settings without applying the network-only policy early.
Add a lightweight initial-blank popup regression with a direct network
control, a synthetic SW redirect, and server-side Cookie/Referer assertions.
Bind the request retained by the CORS redirect loop to the loader's cookie
scope before dispatching single-hop transport copies. Reuse the transport
binding so frame partition keys and Storage Access settings stay intact.
Preserve the selected referrer before Cookie origin adaptation, including
an absent referrer. Keep this in Request::follow_redirect and remove the
navigation-only duplicate.
Add live-server regressions for inherited-origin iframe fetch and sync/async
XHR, plus a multi-hop referrer test with a permissive response policy.
Persist the Fetch timing-allow flag, propagate it through pending body completion, and restore it when building readable and opaque cached Response objects. Cover disk round trips and Window/Worker Cache API delivery with TAO and no-TAO controls.
Retain response type and timing authorization through Response materialization, clone, SW settlement, and direct Worker Fetch completion. Report delivered body bytes without a client network transfer, preserve forwarded CORS restrictions, and avoid re-filtering synthetic Default responses by their request URL.
Publish one terminal entry in the Fetch relevant global before cancellation drops request state. Cover Window and Worker aborts before headers and during streaming, pre-aborted signals, borrowed iframe Fetch, and late completions.
Populate initiatorUrl for fresh same-origin parser script responses while retaining redaction for cached, foreign and unknown initiators. Add a shared browser fixture verifying Fetch source identity and separate parent/iframe timelines against Chromium.
Retain request-time script attribution and publish Fetch entries at buffered or streaming body completion. Apply CORS and Timing-Allow-Origin visibility independently, and cover network failures, async provenance, lazy publication and cache states.
Allow startup and scheduling margin in the existing navigation-grace regression by using a one-second fetch deadline with a five-second outer bound. Preserve the entered-decider assertion, ten-second grace, exact timeout reporting and subsequent owner-usability check.
Source-commit: bb39206697
Run the existing child input-stream readiness regression after the initial load callback has returned. This exercises a fully loaded Document rather than an in-load document.open operation that resumes the current load.
Source-commit: 36456eeea3
Extend redirect-sibling coverage to main documents, shared intermediate
sheets and a policy delivered between the alias and direct requests.
Verify complete independent CSSOM paths, cycle termination, cascade and
request counts with the existing collector implementation.
Exercise linked and inline child stylesheet graphs in both sibling source
orders. Verify independent CSSOM children, owner links, final cascade, and
separate no-store responses with request-driven synchronization.
Allow an alias redirect under a CSP path allowlist while rejecting the direct
sibling request to its destination. Assert its violation and empty imported
sheet so response aliasing cannot bypass request-specific admission.
Use the stylesheet owner's Document policy for the shared inline check and run
it when child parser style contents are complete. Reject blocked owners before
registering import work or acquiring a load-delay token, keeping rejected CSS
out of both CSSOM and the cascade.
Queue child violations through the existing exact Window task target instead
of executing author code during parser admission. Reuse the same owner-aware
policy path for declarative CSS modules.
Cover missing, incorrect and accepted nonces, meta policy, report-only policy,
plain styles, child event attribution, and parser/frame-load completion.
Prepare linked and inline requests at parser admission, then read the current
delivered Document policy for each newly discovered import. Each request keeps
its own policy through redirects, so later meta policies constrain new imports
without retroactively rejecting requests that were already admitted.
Reuse the existing meta policy registry and import collector. Register the
request and final URL of every completed sheet before expanding its imports,
and skip graph installation and repeated CSSOM refresh for links without
imports.
Cover dynamic and parser-delivered meta policies, same- and cross-origin
roots, inline imports, blocked data imports, and nested redirect cycles.
Retain the original root resource URL alongside the response parser base when
installing live import graphs, so a redirected link cannot import its root
response again through the original URL.
Capture the exact child Document's CSP for parser stylesheet graphs. Check
network and data imports before loading, apply policy to redirect targets, and
validate cached or Service Worker redirect chains for the current consumer.
Queue violations through the existing exact-Document Page task path and target
the child Document. Refused imports still settle parser and load blockers.
Use inherited native origins for local Documents' CSP self checks, independently
of their live base URL. Cover redirected cycles, linked and inline import graphs,
enforced/meta/report-only policies, redirect targets, data imports and srcdoc.
Reject integrity-failed parser stylesheet responses in child Documents before preparing or installing an owner CSSStyleSheet. Complete the failed load and release its blocker through the existing terminal path.
Add eight end-to-end URL iframe/srcdoc cases covering initial and cached integrity rejection, matching hashes, CSSOM and computed style, dependent import suppression, and parser/DCL/iframe-load progress.
The regression reproduced the empty-sheet bug at the previous PR head. Validation at 32 build jobs, test threads and Tokio workers: cargo fmt --all; cargo clippy --workspace --all-targets --all-features -- -D warnings; cargo nextest run --no-fail-fast.
Summary [ 146.212s] 22163 tests run: 22163 passed (9 slow), 20 skipped
Support type: text through the shared module map, Window, child Documents and workers. Export UTF-8 decoded strings without executing their contents, preserve typed-module identity, and carry text request metadata through network, preload and Service Worker loaders. Regressions cover static/dynamic import sharing, BOM and invalid UTF-8, CORS, integrity, worker environments and unsupported-type rejection.
Extracted from development commit a6de018613.
Base: main (62e527cd34).
Validation (32 build jobs and test threads): cargo fmt --all; cargo clippy --workspace --all-targets --all-features -- -D warnings; cargo nextest run --no-fail-fast.
Summary [ 146.817s] 22203 tests run: 22203 passed (9 slow), 20 skipped
Generate a fresh browser WebSocket UUID per server and random 128-bit page
and tab target IDs for network CDP owners. Keep discovery URLs and protocol
target IDs consistent, and make clients discover endpoints instead of
relying on fixed paths.
Cover endpoint rotation, guessed and foreign ID rejection, and target
lifecycle behavior.
Co-authored-by: neosun100 <neosun100@users.noreply.github.com>
Release the parser-owned blocking stylesheet only after the runtime stylesheet load handler has applied its DOM marker. Use the existing fixture event gate and a dedicated signal route to establish the renderer/parser snapshot ordering explicitly, preserving the marker and event-order assertions without relying on two relative network delays.
Extracted from development commit f51d7c2c5e141b0926e262a35c3d21ff6cb79450.
Base: main (b30f39c580).
Validation (32 build jobs and test threads): cargo fmt --all; cargo clippy --workspace --all-targets --all-features -- -D warnings; cargo nextest run --no-fail-fast.
Summary [ 147.438s] 22169 tests run: 22169 passed (9 slow), 20 skipped
Warm the renderer before starting the short deadline and assert the lifecycle decider actually enters its successor-navigation grace path. Preserve the original 100 ms request timeout, 10-second grace and owner-recovery bounds.
Extracted from development commit 739748a5d14a9cfd0c5aff913146a238d97030c9.
Base: main (b30f39c580).
Validation (32 build jobs and test threads): cargo fmt --all; cargo clippy --workspace --all-targets --all-features -- -D warnings; cargo nextest run --no-fail-fast.
Summary [ 147.288s] 22169 tests run: 22169 passed (9 slow), 20 skipped
Wait for the destination traversal state and the background session load notification before inspecting document contents. A best-effort stability result or navigation acknowledgement does not establish either completion boundary.
Run independent source and direction matrices in separate Runtime commands while preserving all 660 checks per realm and the existing 30-second command limit. Report the failing realm and matrix in timeout errors.
The existing from_cache flag collapses fresh local responses and revalidated 304 responses into the same state, producing incorrect Resource Timing transferSize.
Carry explicit cache state through buffered and streamed fetches, navigation, subresource snapshots and response interception. Resource Timing reports zero transfer for local hits, validation overhead for merged 304 responses, and body bytes plus header overhead for network responses. Cover disk and memory cache state in the HTTP timing fixture and native response tests.
Read effective policies from native Document delivery state and preserve them in Fetch and both XHR transport paths. Remove obsolete subtree rescanning and response-only owner lookups.
Validation (32 build jobs / test threads, zero retries):
- `cargo fmt --all`
- `cargo clippy --workspace --all-targets --all-features -- -D warnings`
- `cargo nextest run --no-fail-fast`: Summary [ 141.923s] 21998 tests run: 21998 passed (9 slow), 19 skipped
Expose IDBRequest attributes through branded readonly prototype getters backed by native lifecycle state and traced values. Pending result/error throw InvalidStateError; cursor reuse and upgrade completion update internal state without writing author properties. Preserve the SQLite factory and owner-completion paths and their versionchange/delete event metadata. Cover pending, success, error, abort, shadowed properties and borrowed cross-realm getters.
After a successful SQLite COMMIT receipt, reserve the upgrade open-result task before transaction complete listeners can enqueue regular request results. Retain openRequest.transaction through complete dispatch and clear it after dispatch; result delivery still checks for a closed connection. Correct IDBDatabase.transaction.length to 1. Retain the Window, iframe and Worker conversion, upgrade-boundary, ordering, close and reopen regressions.
Expose IDBObjectStore and IDBIndex readonly attributes through generated branded prototype getters. Keep immutable flags, cached keyPath values and parent references in V8-traced private slots on ordinary and failed schema handles; indexNames reads the current SQLite metadata mirror. Remove obsolete public-property rewrites so author shadows and cached arrays survive schema edits and rollback. Preserve collectible wrappers and native Proxy/cross-realm behavior. Use the shared lossless SQLite schema-name model, independently of mutable rename; mutable name behavior remains a separate topic. Retain all readonly/identity/rollback assertions from the original fixture and save its full rename integration matrix for the SQLite rename work.
Carry store and index names as IndexedDbName code units through WebIDL DOMString16 conversion, transaction scopes/admission, metadata, queued operations, cursors and DOMStringList. Store labels as ordered UTF-16BE BLOBs in SQLite schema v3; migrate known v1/v2 tables transactionally while preserving stable ids, records, indexes, generators and logical usage. Reuse the database-name codec and existing SQL command FIFO. Add exact surrogate/replacement/NUL/astral name operations in Window, iframe and Worker, plus native disk restart and malformed-label migration rollback/retry tests. This prerequisite supplies the lossless name model needed by the separate index/store rename setters.
Preserve database DOMString names as IndexedDbName code units across derived WebIDL conversion, native connection FIFO, SQL service identity, IDBDatabase.name and databases() results. Store database names as UTF-16BE BLOBs in SQLite schema v2. Migrate v1 TEXT metadata inside one SQL transaction after owner/name/generation validation, keeping records, stable ids, generators and logical quota accounting. Extend the existing generation-path hash with canonical WTF-8 so legacy Unicode directory paths remain unchanged. Retain the complete original Window/iframe/Worker conversion, independent-record/version, abort, deletion and cross-agent matrix. Add real disk-profile restart plus legacy migration/failure, exact queue identity, path compatibility and quota-rollback regressions. This database-name topic is independent of object-store/index rename and readonly schema attributes.
Carry the complete live cursor mutation matrix from superseded #1341 onto SQLite, without its snapshot rescanning implementation. Cover writes during iteration, pending cursor values, forward/reverse and unique directions in Window, iframe and Worker contexts.
Run Page composite commands in the existing supervised command workflow.
Prepare preload, stop, crash and close ownership at admission; keep native
waits outside state access and complete finite commands synchronously.
Share owned navigation commit, streaming response and retirement logic with
Fetch. Preserve current, nested and background navigation reply ownership,
including accepted terminals during later waits, cancellation and ready loss.
Keep stop cleanup scoped to its original request and retain crashed Pages
before awaiting shutdown.
Remove the child-navigation Owned/Inline split, redundant world phases and
old exclusive Page completion/activation wrappers. Carry typed native errors
and use finite state operations for output, attachment and listener updates.
Keep original Native child facts routable through the unbound Document
handoff without granting business access. Preserve their exact Document tree
through adoption and use the captured owner for events and response bodies
when foreground selection changes.
Validate controlled renderer-held peer progress and recovery, successor
navigation ownership, stale world attachments, full workspace checks, source
CLI compatibility, Playwright, Puppeteer and parallel targeted stress. Replace an old stylesheet fixture clock check with
a script-released CSS gate while preserving the parser/DOM ordering checks.
ldm0
