Is Ladybird Rust Yet?

Is Rust Profitable Yet?
Last updated on 08:00AM on November 07, 2026 (TZ: UTC+0000)

Individual commit stats

LibWeb: Look for a page’s meta charset past its first 1024 bytes

LibGfx+Compositor: Replace Gfx::Path with SkPath

Compositor: Make the polygon of a plane clip directly in Skia

LibGfx+LibCompositing+Compositor: Move cap and join styles out of Path

LibWeb: Run structuredClone() in Rust

LibWeb: Run serialization steps of Rust interfaces in the current realm

LibWeb: Mark window messageerror events as trusted

LibWeb: Keep the MessagePort transport with MessagePort

LibWeb: Frame MessagePort transport messages in Rust

LibWeb: Own transfer payloads and attachments in Rust

LibIPC: Make descriptors from Mach file ports close-on-exec

LibWeb: Run window postMessage algorithms in Rust

LibWeb: Keep MessagePort transfer records in Rust

LibWeb: Keep serializable interface metadata in Rust

LibWeb: Dispatch Rust serializable objects directly

LibWeb: Serialize transfers into Rust message records

LibWeb: Read transfer data holders in Rust

LibWeb: Write transfer data holders in Rust

LibWeb: Dispatch transfers in Rust

LibWeb: Remove dead transfer helpers

Tests: Build transfer data holders with IPC::Encoder

LibWeb: Process SVG script elements with the HTML script algorithms

LibWeb: Start the speculative parser while an SVG script blocks parsing

LibWeb: Do not run scripts in `use` element shadow trees

LibWeb: Set the script text of scripts that the XML parser inserts

LibWeb: Only trust script text that the HTML parser inserted

LibWeb+Meta: Move script element processing into a shared base class

LibWeb: Keep the XML parser's open elements on a stack

LibWeb: Parse XMLHttpRequest XML responses with scripting disabled

LibWeb: Implement WebGLContextEvent in Rust

LibWeb: Implement PerformanceServerTiming in Rust

LibJS: Trace the keys and values of a HashMap in Rust

LibHTTP+LibWebCommon: Share the HTTP lexing helpers in Rust

AK: Add GenericLexer to the Rust crate

Tests/LibWeb: Remove TestStyleValueEquality

Tests/LibCrypto: Remove the ML-DSA seed key generation test

Tests/LibCrypto: Trim the hash and HMAC tests

Tests/LibCrypto: Trim the key derivation test vectors

Tests/LibCrypto: Trim the elliptic curve test vectors

Tests/LibCrypto: Trim the AES test vectors

Tests/AK: Test Atomic with one integer and one pointer type

Tests/LibWeb: Remove tests of trivial helpers

Tests/LibWeb: Remove tests that WPT already covers

Tests/LibWeb: Remove TestDownloadReader

Tests/LibWebView: Remove TestTabPerformanceMonitor

Tests/LibWebView: Remove TestWebCompatReportPage

Tests/LibWebView: Remove TestViewDestruction

Tests/LibWebView: Remove TestCompositorInputRouting

LibWebView: Apply incremental changes to the accessibility tree

LibWeb: Keep accessible names between accessibility-tree builds

Internals: Dump the accessibility node data the UI process receives

LibWeb: Read accessible character offsets from layout’s glyph runs

LibWeb: Keep characters after a soft hyphen in place in text rects

LibWeb: Port storage shelves, buckets, bottles and mirrors to Rust

AK: Hash and debug-format Utf16String in Rust

LibWeb: Obtain storage keys in Rust given a settings object

LibWeb: Implement StorageManager in Rust

LibWeb: Queue global tasks from Rust on a global object

LibWeb: Implement Storage and StorageEvent in Rust

LibURL+LibWeb: Expose the URL of a Document to Rust

Meta+LibWeb: Support named properties in the Rust bindings

LibWeb: Create Rust wrappers with their interface's own prototype

LibWeb: Remove Rust exports that no C++ code calls

LibWeb: Name the longhands of a shorthand descriptor

LibWeb: Reject CSSStyleSheet.replace() before reading the owner node

LibWeb: Lowercase the canonical unit of a Typed OM sum value

Tests/LibWeb: Cover sum values of frequency units

LibWeb: Do not reify an empty list as a transform list

LibWeb: Stop recursing on cycles in CSSUnparsedValue

LibWeb: Only treat a transform as 2D when its Z scale is 1

LibWeb: Mark events fired from Rust as trusted

LibWeb+Meta: Define isTrusted on events implemented in Rust

LibWeb: Stop crashing on non-numeric transform arguments

LibWeb: Remove redundant helpers from the CSS Rust code

LibWeb: Intern CSS property accessor names only once

LibWeb: Remove unused CSS Typed OM entry points

LibWeb: Use NB: for comments that are not spec text

LibWeb: Release strings that the Rust CSSOM hands to C++

LibWeb: Use Utf16String for text in the Rust CSSOM

LibWeb: Implement FontFaceSet in Rust

LibWeb+Meta: Implement the CSS namespace in Rust

LibWeb: Use the Rust CSS serializers from C++

Meta: Remove the generated CSS property range checks

LibWeb: Build CSS Typed OM style values in Rust

LibWeb: Implement VisualViewport in Rust

LibWeb: Merge RustCSSDescriptors into CSSDescriptors

LibWeb+Meta: Implement CSSStyleDeclaration bindings in Rust

LibWeb: Build the value of a CSSOM shorthand in Rust

LibWeb: Set and remove CSS declarations in Rust

LibWeb+Meta: Implement CSSStyleProperties bindings in Rust

LibWeb: Resolve the values of styles without a box in Rust

LibWeb: Resolve the values of laid out boxes in Rust

LibWeb: Resolve color, shadow and filter values in Rust

LibWeb: Serialize CSS declaration blocks in Rust

LibWeb: Implement CSSFontFeatureValuesMap in Rust

LibWeb+Meta: Implement Highlight and its registry in Rust

LibWeb: Implement StylePropertyMap and its read-only base in Rust

Meta: Support pair iteration over values that hold cells

LibWeb: Implement FontFaceSetLoadEvent in Rust

Meta: Convert dictionaries that inherit and hold cells in Rust

LibWeb: Implement Screen and ScreenOrientation in Rust

Meta: Support [SecureContext] attributes in the Rust bindings

LibWeb: Implement MediaQueryList in Rust

Meta: Support callback interface types in the Rust bindings

LibWeb: Implement three CSS descriptor interfaces in Rust

Meta: Let Rust descriptor interfaces inherit CSSStyleDeclaration

LibWeb: Implement the CSSOM style sheet interfaces in Rust

LibWeb: Implement the CSSOM rule interfaces in Rust

Meta: Support PutForwards and FrozenArray in the Rust bindings

LibWeb: Implement three CSS event interfaces in Rust

LibWeb: Implement the CSS Typed OM in Rust

Meta: Support more of Web IDL in the Rust bindings

LibWeb: Implement MediaList in Rust

Meta: Support CSSOMString in the Rust bindings

LibGfx+LibWeb: Store glyph placements apart from glyphs

LibGfx+LibWeb: Read and write glyph positions through GlyphBuffer

LibGfx+LibWeb: Keep shaped glyphs in GlyphBuffer everywhere

LibWeb: Rebase glyph cluster starts when splitting text items

LibHTTP+LibWebView+RequestServer: Open no cache without a site

RequestServer: Confine the sandbox to the disk cache directory

LibWeb: Don’t give a pseudo-element list item a marker it can’t show

LibWeb: Implement FormData in Rust

Meta: Support FormData in the Rust bindings

Meta: Pass the macOS deployment target to Cargo

Everywhere: Use ak::math over the float methods of Rust's std

LibJS: Compute the Math functions with ak::math

AK: Add a Rust math module backed by LLVM libc

Meta: Add a clang plugin that rejects the C library's math functions

Everywhere: Use AK/Math.h over the C library's math functions

AK: Compute math functions with LLVM libc

Meta: Add a vcpkg port for the math functions of LLVM libc

LibGfx: Remove GlyphRun

Meta: Check that cargo-sources.json matches Cargo.lock

Meta: Regenerate cargo-sources.json for the Flatpak build

LibWebRTC+WebRTCClient: Add a Rust WebRTC helper process

RequestServer+LibRequests: Look up hosts for others that connect

LibIPC: Let Rust transports tell how many messages wait to be sent

LibSandbox: Let IPC shut its sockets down

LibSandbox: Add a seccomp group for UDP-only networking

LibSandbox: Let macOS helpers ask to use UDP and nothing else

LibSandbox: Add a seccomp group for epoll

LibIPC: Let Rust helpers take their transport from a Mach server

LibMedia+Meta: Add an FFmpeg audio encoder, with libopus for Opus

LibWeb: Let C++ set up a WritableStream and read a desired size

Tests/LibWeb: Test AudioWorklet sample rates and processor errors

Tests/LibWeb: Test re-exporting imported WebAssembly functions

LibWeb+WebContent: Wake waiting media requests when focus comes back

LibWeb: Only require the audio device a page asks for exactly

LibWeb: Keep media stream sources alive while their track is live

LibWeb: Expose MediaStreamTrack.clone()

Meta: Remove the narrow FFI parameter lint

LibWeb: Update :focus-within as a shadow root attaches to its host

LibWeb: Test :focus-within of a host as its shadow root attaches

LibWeb: Sample hidden animations for a read below display:none

LibWeb: Test reading animation samples below a hidden element

LibWeb: Don't take a table's box record for a table's style

LibWeb: Rebuild the parent when content makes an element an image

LibWeb: Rebuild from a ::first-letter owner what holds its letter

LibWeb: Don't lay out only boundaries around a replaced root

Tests/LibWeb: Test a copy right after a display change

LibWeb: Don't detach an out-of-flow table-internal box in place

LibWeb: Don't detach a legend's box in place

LibWeb: Rebuild a table when a cell's span changes

LibWeb: Rebuild an input's box when its type changes

LibWeb: Don't replay resolved anchor insets after a style change

LibWeb: Rebuild where an absolutely positioned box changes its level

LibWeb: Don't make a list item of a box in button layout

LibWeb: Rebuild an element's box when its appearance changes

LibWeb: Find animated custom property cycles as substitution reads

LibWeb: Let a navigation go on past an older queued javascript: URL

LibWeb: Don't animate a child no slot takes

LibWeb: Stop CSS animations below a hidden slot

LibWeb: Read a query's selector facts in one walk of its arena

LibMedia: Count codec configurations toward SourceBuffer quotas

LibMedia: Cap metadata strings and codec configurations by size

LibMedia: Wait for every byte of a stream read before allocating it

LibMedia+MediaServer: Cap decodeAudioData output at 512 MiB

LibMedia+LibMediaCodecs: Refuse sample rates outside 3000 to 768000 Hz

LibMediaCodecs: Keep the liveness floor of frame buffers allocated

LibMediaCodecs: Refuse video frames past the size limits before decoding

LibWeb: Hold BroadcastChannel messages as Rust records

LibWeb: Share SharedArrayBuffer storage within a process from Rust

LibWeb: Implement BroadcastChannel in Rust

LibWeb: Represent C++ global objects in Rust

LibWeb: Drop the unused VM from Wrappable::relevant_realm()

LibWeb: Let Rust event targets watch their event listeners

LibWeb: Move the Rust storage key out of IndexedDB

Meta: Check for narrow parameters in Rust functions C++ calls

LibWeb: Pass an animation effect's slot across FFI in 32 bits

LibURL: Pass a port across FFI in 32 bits

LibWeb: Leave layout up to date on a read below an undisplayed element

LibWeb: Settle style updates before a tree build demands a record

LibWeb: Give the grid and grid-template shorthands a valid initial value

LibWeb: Draw random base values nested in grid tracks and anchors

LibWeb: Wait for as many fonts as a demand's inherited chain asks for

LibWeb: Count animated custom property moves in the stabilization bound

RequestServer: Share one certificate store between macOS connections

LibWeb: Replace the differential style engine

LibWeb: Install styles on the render side and run its clock there

LibWeb: Restyle only what a style update's inputs can reach

LibWeb: Style a document in breadth-first passes over a thread pool

LibWeb: Index a document's rules and match their selector components

LibWeb: Give the style engine its own projection of the DOM

LibWeb: Keep parsed style data compact and shared

LibGfx: Let loads fill pending faces into frozen font cascades

Documentation: Describe the style engine that runs on the render side

LibJS: Throw when toBase64() or toHex() would overflow a string

Tests: Import the WPT notification permission and non-secure tests

LibWebView+Base: Let the user turn site notification prompts off

UI/Qt+LibWebView: Ask for notifications with Allow and Never allow

LibWebView+WebContent: Show a notification only for an allowed document

LibWeb: Implement Notification.requestPermission()

LibWebView: Close notifications the platform hasn’t acknowledged yet

LibWebView: Keep notification text and icons within what a daemon takes

test-web: Reset a view’s notification state between tests

LibWebView: Harden the notification manager against a misbehaving page

LibWeb: Keep a notification alive, and withdraw it, while its icon loads

Tests: Import the WPT notification tag test

LibWeb: Bound only the fetch of a notification’s icon, not its decode

LibWebView: Add a Freedesktop notification backend

LibWebView: Add a macOS notification backend

UI/Qt: Focus the tab a clicked notification came from

LibWeb: Fetch a notification’s icon before showing it

Tests: Cover notification tag replacement and the per-origin cap

test-web+LibWeb: Drive and observe shown notifications from tests

LibWebView+WebContent: Show web notifications through a platform backend

LibWeb: Run the notification show, click, and close steps

LibWeb: Finish the notification create steps

LibWeb: Implement Notification.permission over the permission store

LibWebCommon+LibWebView+UI/Qt: Add notifications to the permission store

LibJS: Find a cell's class through its block

LibGC: Let foreign allocators tag the blocks they allocate

LibCompositing: Remove the C++ encoder of the WebGL command stream

Everywhere: Carry Latin-1 strings as one byte per code unit

Everywhere: Handle Latin-1 Utf16String storage in every reader

AK+Everywhere: Prepare one-byte Utf16String storage for Latin-1

LibJS: Fill in the Rust heap region base before creating a heap

LibGC: Add compressed Member and NonnullMember cell field types

LibJS: Compress native function realms and for-in key snapshot cells

LibJS: Compress the halves of rope strings and substring sources

LibJS: Compress the realm and prototype of shapes and accessor functions

LibJS: Store the shape of every object compressed

LibJS: Compress the outer pointers and shapes of environments

LibJS: Compress the call path pointers of ECMAScript functions

LibJS/Flap: Add a compressed cell pointer field representation

LibJS: Compress the pointers of promise, proxy and RegExp cells

LibJS: Compress runtime-only pointers in shapes, accessors and arrays

LibJS: Add compressed Member and NullableMember cell field types

LibGC: Scan both halves of each word for compressed cell pointers

LibGC: Keep both ends of the heap region uncommitted

LibGC+LibJS: Shrink the heap region to 32 GiB on every target

LibGC+LibWeb: Add a heap census to internals

LibWeb: Break ASCII text at whitespace without a line segmenter

LibWeb: Lay out auto-height abspos flex and grid boxes once

LibWeb: Generate flex items once for both content inline sizes

LibWeb: Keep ancestor intrinsic sizes when an abspos box changes

LibWeb: Scan grid items for occupancy only in auto-fit tracks

LibWeb: Resolve grid areas from track offsets

LibWeb: Skip replaced content facts for boxes without them

LibWeb: Compute flex item containing block constraints once

LibWeb: Look up flex items by index instead of scanning

LibWeb: Make MessagePort's transfer steps infallible

LibWeb: Close a MessagePort's transport on a message it can't decode

LibWeb+LibWebCommon: Remove the big integers of transfer data holders

LibWeb: Remove the unused operations of UniversalGlobalScopeMixin

LibWeb: Serialize IndexedDB values with the Rust serializer

LibJS+LibWeb: Read structured serialization records in Rust

LibJS+LibWeb: Write structured serialization records in Rust

LibWeb: Test structured serialization through its entry points

LibWeb: Keep structured serialization memory in Rust

LibWeb: Remove the C++ serialization steps of platform objects

LibWeb: Serialize CryptoKeys from Rust

LibWeb: Serialize the pixels and color spaces of images from Rust

LibWeb: Implement FileList in Rust

Meta: Give a Rust interface with an indexed getter an @@iterator

LibWeb: Let Rust deserialization steps return the object they create

LibWeb: Serialize DOMExceptions from Rust

LibWeb: Clone stream chunks with the Rust serializer

LibWeb: Implement MessagePort and MessageChannel in Rust

Meta: Resolve Rust overloads by a sequence argument

Meta: Convert a Rust dictionary that holds a sequence of cells

Meta: Let a Rust event handler attribute name its setter

LibWeb: Create MessageEvents and add event listeners from Rust

LibJS: Root a cell for as long as a value lives

LibWeb: Lend IPC transports to Rust

LibWeb: Let Rust transfer steps write and read records and handles

LibWeb: Own structured serialization transfer records from Rust

LibWeb: Update MessagePort step comments to the spec

Tests/LibWeb: Free the execution context a simple realm leaks

LibWeb: Never block blob URLs as mixed content

Tests/LibWeb: Start a blob worker from a sandboxed iframe

LibWeb: Check execCommand’s insertHTML value for Trusted Types first

LibWeb: Inherit currentcolor text shadows with absolute lengths

LibWeb: Throw a DataCloneError for a buffer longer than its maximum

LibWeb: Throw a DataCloneError for a record that names a missing object

LibWeb: Throw a DataCloneError for an object with internal slots

LibJS: Tell whether an object has internal slots of its own

LibWeb: Implement structured serialization in Rust

LibJS: Expose the objects that structured cloning reads to Rust

LibWeb: Serialize an Error named InternalError as an Error

LibWeb: Update structured serialization step comments to the spec

LibCrypto: Remove unused BigFraction

LibCore: Fix use-after-free in ArgsParser enum options

LibGfx: Reject BMPs with an unrepresentable height

LibWebView: Link unit and headless tests into one executable

LibWebCommon: Link unit tests into one executable

LibWeb: Link unit tests into one executable

LibUnicode: Link unit tests into one executable

LibURL: Link unit tests into one executable

LibTextCodec: Link unit tests into one executable

LibTLS: Link unit tests into one executable

LibSandbox: Link unit tests into one executable

LibMedia: Link unit tests into one executable

LibIPC: Link unit tests into one executable

LibHTTP: Link unit tests into one executable

LibGfx: Link unit tests into one executable

LibGC: Link unit tests into one executable

LibDevTools: Link unit tests into one executable

LibDatabase: Link unit tests into one executable

LibDNS: Link unit tests into one executable

LibCrypto: Link unit tests into one executable

LibCore: Link unit tests into one executable

LibCompress: Link unit tests into one executable

LibCompositing: Link unit tests into one executable

LibAudio: Link unit tests into one executable

RequestServer: Link unit tests into one executable

Compositor: Link unit tests into one executable

AudioServer: Link unit tests into one executable

AK: Link unit tests into one executable

LibTest: Run combined source suites in isolated processes

LibWeb: Drop the guards against reads nested inside a layout pass

LibWeb: Assert that the layout arena is Sync

LibWeb: Keep the paint state of the layout arena plain

LibWeb: Memoize live absolute rects in the view that reads them

LibWeb: Keep the image map and unique node id columns plain

LibWeb: Keep paint records, stacking entries and fragment links plain

LibWeb: Keep the scrollable overflow state of the arena plain

LibWeb: Keep the side data of paintable rows plain

LibWeb: Push paint damage through a mutable layout arena

LibWeb: Let a shared layout arena reach only the style engine's reads

LibWeb: Assert that the plain tables of the layout arena are Sync

LibWeb: Write the shape of layout nodes through a mutable arena

LibWeb: Keep the unpublished facts of layout nodes plain

LibWeb: Keep the layout arena's trace and SVG paint resources plain

LibWeb: Keep the layout arena's style node tables plain

LibWeb: Keep the layout arena's update marks and overflow queue plain

LibWeb: Keep the layout arena's per-slot style columns plain

LibWeb: Keep the layout arena's pending lists and dirty marks plain

LibWeb: Keep the layout arena's bound rows and owed lists plain

LibWeb: Install styles and stamp rows through a mutable layout arena

LibWeb: Keep the layout arena's paint fact tables and image tables plain

LibWeb: Keep the layout arena's document facts and counters plain

LibWeb: Keep the chunks and grapheme segmenters of text in scratch

LibWeb: Record the layout trace of a pass in the layout stage's scratch

LibWeb: Keep the layout run caches in the layout stage's scratch

LibWeb: Stop tracking fragment cache epoch changes during a layout pass

LibWeb: Begin a layout pass once its stage is prepared

LibWeb: Prepare the arena for a layout stage before borrowing it

LibWeb: Keep three layout arena fields that only &mut writes plain

LibWeb: Always queue what the host hears of box presence

LibWeb: Assert that no job reaches its own document's state again

LibWeb: Report connect-src violations of worker imports in the owner

LibWeb: Report a stopped fetch to WebDriver BiDi as an error

LibWeb: Make FetchParams reference-counted instead of GC-allocated

LibGC: Share the stack scrub that GC tests use before a collection

LibWeb: Keep a fetch's shared state in a fetch control block

LibWeb: Stop fetches without a fetch record when a document aborts

LibWeb: Finish a service worker job whose script fetch is stopped

test-web: Save downloads where the HTTP test server can report them

LibWeb: Add a fetch controller registry

LibWeb: Keep a fetch's task destination on its fetch controller

AK: Add a constructor for borrowed raw UTF-16 fly strings

AK: Implement `Debug` for Rust UTF-16 fly strings

LibWeb: Support the trusted-types-eval source expression

LibWeb: Cover Trusted Types eval source expressions

LibWeb: Apply the script policy to changed inline script text

LibWeb: Cover default policy use for inline script text

LibWeb: Activate controls from trusted keyboard input

LibWeb: Add keyboard activation coverage

LibWeb: Terminate an aborted FileReader read even if another begins

LibWeb: Implement FileReader and FileReaderSync in Rust

LibURL: Add create_with_data() to the Rust crate

Meta: Convert arguments to inherited Rust interfaces

Meta: Allow ArrayBuffer in union results of the Rust bindings

Meta+LibWeb: Support unsigned short in the Rust bindings

RequestServer: Fail over quickly from unreachable HTTP/3 alternatives

LibWeb: Size select elements to fit their widest option

LibWeb: Add test for select width with options of different widths

Meta: Hoist rust toolchain detection outside of any function

LibWeb: Resolve logical viewport units in the target axes

LibWeb: Import logical viewport writing-mode coverage

LibWeb: Resolve pseudo-element units against their origin

LibWeb: Import pseudo-element container-query coverage

LibWeb: Check box eligibility when resolving container sizes

LibWeb: Import nested query container coverage

LibWeb: Treat anchor-center as center for flex and grid items

CI: Use the baseline CPU for test262 builds

LibWeb: Mark generated CSS animation events as trusted

LibWeb: Import prefixed CSS animation event coverage

LibWeb: Dispatch legacy mousewheel listeners for wheel events

LibWeb: Import legacy mousewheel listener coverage

LibWeb: Make passive touch events uncancelable

LibWeb: Import passive touch event cancellation tests

LibWeb: Compare unresolved values by source text and component values

LibWeb: Preserve token contents when trimming unresolved values

LibWeb: Remove unused unresolved value constructor arguments

LibWeb: Normalize trailing carriage returns in CSS input

LibWeb: Implement IndexedDB in Rust

LibWeb: Let Rust interfaces inherit from EventTarget and Event

LibWeb: Move CppCell from the Rust streams to the bindings

LibJS: Expose CanonicalNumericIndexString to Rust embedders

LibJS: Expose Date and LengthOfArrayLike to Rust embedders

LibJS: Trace the value or the error that a Result holds from Rust

CI: Reinstall a Rust toolchain that lacks cargo

Meta: Build the Rust tests from a source tarball without Git

CI: Upload the release Flatpak bundles without zipping them

CI: Upload the release source tarball without zipping it

test-web: Load tests from an origin that is not potentially trustworthy

RequestServer+LibWebView: Resolve .test names to loopback in test mode

LibDNS: Let a resolver resolve names within chosen domains to loopback

LibWeb: Make fetch Request reference-counted instead of GC-allocated

LibTextCodec: Include the StringView that an Encoder holds

LibWeb: Move a fetch request's body stream to the JS Request

LibWeb: Hold a fetch request's prompt traversable by id

LibWeb: Name a fetch request's client by its address

LibWeb: Give environment settings objects an address

LibWeb: Resolve a blob request's URL entry at fetch start

LibWeb: Read a fetch's client through its snapshot

LibWeb: Introduce fetch client context snapshots

LibWeb: Account for in-flight keepalive bytes per fetch group

Tests: Read an echo request's body before responding

LibWeb: Keep the top-level origin of serialized environment settings

LibWeb+WebWorker: Serialize a stand-in with the global it was taken from

LibWeb: Report no violations for a stand-in of a remote environment

LibWebView: Persist a history entry's insecure requests policy

LibWeb: Keep the insecure requests policy on the policy container

LibWebCommon: Refuse an unknown insecure requests policy over IPC

LibWeb: Round integer animation ties toward positive infinity

LibWeb: Import WPT coverage for integer interpolation rounding

LibWeb: Expose Touch Events and dispatch touch contact lists

LibWeb: Import Touch and TouchEvent constructor coverage

LibWeb: Dispatch WebDriver touch and pen pointer actions

LibWeb: Preserve pointer input data and isolate pointer state

LibWeb: Import pointer coordinate and touch handler exposure tests

LibWeb: Cover pointer input properties and independent capture

AK: Match Rust panic callback parameter types to the FFI

LibWeb: Cover mouse pointer move and boundary event defaults

CI: Fail the macOS AX preflight on a screen-locked session

CI: Cache Rust compiles with sccache, as ccache caches C++ compiles

LibJS: Build the standalone runtime independently of LibWeb

LibWeb: Throw a TypeError for a missing WebAssembly table value

LibWeb: Keep one copy of a WebAssembly module's bytes

LibWeb: Throw a RangeError when a WebAssembly memory allocation fails

LibWeb: Reject v128 and exnref types before a WebAssembly call

LibWeb: Hold a WebAssembly Memory's buffer objects strongly

LibWasm: Remove the C ABI that only LibWeb used

LibWeb: Implement the WebAssembly JS API in Rust

LibWeb: Support namespaces and more IDL in the Rust bindings

LibJS: Expose host classes, modules and errors to Rust embedders

LibWasm: Build the engine's C ABI only for LibWasm

LibWeb: Implement the HTML Sanitizer API

LibWeb: Set the script text of scripts parsed in the fragment case

LibWeb: Only remove the body for a frameset tag if it has a parent

Tests/LibWeb: Import Sanitizer API WPT tests

LibJS+LibWasm: Keep JIT compilation available on x86-64-v2 CPUs

CI: Add a workflow that packages Distribution builds

Meta+UI: Give release builds a version

Meta+UI: Package the browser and its symbols with CPack

Meta: Configure CPack once for the whole project

Tests/LibMedia: Build TestSystemFFmpeg only with a shared libavcodec

Tests/LibGfx: Build TestRustCrateCopies only for shared libraries

AK+LibCore: Keep caught Rust panics out of crash reports

Meta+CI: Run the Rust GC lints in lint-ci.sh

Meta+LibJS: Reject GcRefCells around state the collector never reads

Meta: Reject untraced types that keep GC pointers in heap memory

Meta: Reject GC pointer dereferences in the Drop of what cells own

Meta+LibJS: Reject untraced fields that can hold GC pointers

Meta+LibJS: Add a rustc driver with lints for libjs_rust's GC

LibJS: Keep keys that are never symbols in a NonSymbolPropertyKey

LibJS: Build or trace the rest of what keeps cells in heap memory

LibJS+LibWeb: Keep what holds cells in heap memory within a deferral

LibJS+LibWeb: Build cells under a deferral of collections

LibJS+LibWeb: Defer collections while traced state is borrowed

LibGC+LibJS: Defer collections from Rust without a call into LibGC

LibJS: Keep state the collector never reads out of GcRefCell

LibJS: Tie what the JIT keeps cells in to the deferral that keeps them

LibJS: Say that a GcWeak holds no Gc

LibJS: Create disposable stacks with a new dispose capability

LibJS: Ask whether a cell died only of the sweep in progress

LibJS: Give weak containers no VM while they remove dead cells

LibJS: Lend the execution contexts of a paused stack trace

LibJS: Keep Values on the thread of their VM

LibJS+LibWeb: Make the bits of a Value private to libjs_rust

LibJS: Implement Trace for what owners traced field by field

LibJS: Keep arguments of JIT calls that do not fit inline in one list

LibJS: Keep the remaining temporary lists of cells in MarkedVecs

LibWeb: Return sequences of cells from Rust bindings in MarkedVecs

LibWeb: Build Rust bindings' arrays and rect lists from rooted lists

LibJS: Root the arguments of a RegExp replacer function

LibJS: Root the functions of stack traces

LibJS: Lend the attached debugger instead of sharing it

LibJS: Keep collections deferred while JIT code is installed

LibJS: Pass a DeferGc to the JIT code that relies on its caller's

LibJS: Have a bytecode cache install borrow the functions it matches

LibJS: Build executables while collections are deferred

LibJS: Root the strings that jit.exitSites creates

LibJS+LibWeb: Lend a MarkedVec's values instead of copying them out

LibJS+LibWeb: Trace lists of values only through GcRefCells

LibJS: Move DeferGc to the heap

LibJS: Remove the unused Executable::new

LibGfx: Remove the Gfx::Path queries that only LibWeb asked

LibWeb: Measure SVG geometry in Rust instead of through Gfx::Path

LibWeb: Paint a focused area's focus ring from the shape Rust built

LibWeb: Don't treat NavigateEvents created by script as trusted

LibWeb: Clear the target element when the fragment does not exist

LibWeb: Restore scroll positions after intercepted traversals

Tests/LibWeb: Import navigation API tests

Meta+UI: Write separate symbol files for Distribution builds

UI: Strip the main executable of installed macOS bundles

LibWeb: Make the C++ views of a declaration block on first use

LibWeb: Drop the custom property references memo of declaration data

LibWeb: Keep whole-number RGB colors in rgb() form when interning

LibWeb: Share the numbers of parsed colors

LibWeb: Drop the growth slack of parsed declaration blocks

LibWeb: Make inline style views only for blocks that hold images

LibWeb: Stretch MathML operators and draw large operators

LibWeb: Paint MathML fraction bars and radical symbols

LibWeb: Use the MATH table constants in MathML layout

LibGfx: Read the OpenType MATH table through HarfBuzz

Tests/LibWeb: Import WPT tests for stretchy MathML operators

LibWeb: Inline the layout style and node lookup accessors

LibWeb: Look up a style transaction's records from the last one found

LibWeb: Skip settling pseudo-elements an element cannot generate

LibWeb: Skip unstyled subtrees when looking for generated content state

LibWeb: Charge later style pass waves to their own phase clocks

LibWeb: Ask about an element's animations only where it is asserted

LibWeb: Keep shadow hosts' pseudo-element matches across transactions

LibWeb: Keep anchor names in tree order across moveBefore()

LibWeb: Test anchor and animation names across restyles and moves

LibWeb: Rebuild the inherited UI group when the color moves

LibWeb: Mark popstate and hashchange events as trusted

LibWeb: Rate limit history updates and traversals

Tests/LibWeb: Import WPT tests for history API rate limits

LibWeb: Implement Event Timing

LibWeb: Implement Paint Timing

Tests/LibWeb: Execute pointer actions in testdriver-vendor.js

LibWeb: Check the current URL of mixed content requests

LibWeb: Implement the upgrade-insecure-requests directive

Tests/LibWeb: Add tests for upgrade-insecure-requests

LibWeb+LibWebView+WebContent+WebWorker: Report worker CSP violations

Tests/LibWeb: Import CSP tests for blocked worker script requests

LibWeb: Decide the relayout of the host's style install in Rust

LibWeb: Drop the conservative style reset of animated SVG boxes

LibWeb: Share the layout-input style comparison with Rust

LibWeb+LibWebView: Give popups their creator's top-level creation URL

LibWeb+LibWebView: Make top-level data: documents non-secure contexts

LibWeb: Count AudioBuffer sample storage toward GC pressure

LibWeb: Taint canvases with video from CORS-cross-origin responses

AK+Meta: Remove debug macros whose code moved to Rust

Meta: Remove the CSS value grammar parser

test-web: Stop setting verification variables that nothing reads

LibGfx: Remove the C++ table of supported font technologies

LibWeb: Remove HTMLToken members that the Rust parser made unused

LibCompositing: Stop asking cbindgen for canvas types that are gone

LibGfx: Remove paint enum decoders that nothing calls

LibWeb: Move the newline line helpers into VisualLines

LibWeb: Arm render clock contexts with their ticks, not a callback

LibWeb: Remove leftovers of the C++ cascade in the style computer

LibWeb: Remove CSS helpers that the Rust style and layout replaced

LibWeb: Remove StyleValue accessors that nothing reads

LibWeb: Remove more StyleValue subclasses nothing reads

LibWeb: Remove the dependencies of declaration blocks

LibWeb: Remove the qualified layer names of CSS rules

LibWeb: Remove ComputedValues accessors that nothing reads

LibGfx: Remove IPC coding of transforms, matrices and color stops

LibCompositing: Remove test tree builder calls that no test makes

LibCompositing: Remove visual context queries that C++ no longer asks

LibGfx: Remove cascade text shaping and GlyphRun::slice()

LibGfx: Remove the Gfx::Path operations that nothing uses

LibWeb: Remove pre-order navigation from Layout::Node

LibWeb: Stop copying generated text into its layout node

LibWeb: Remove the find-in-page blocks of SearchableText

LibWeb: Hand CSS strings to C++ as typed pointers

LibWeb: Take the VM by reference in the Rust bindings exports

LibWeb: Take FFI out-parameters as references and AK spans

LibWeb: Hand style values to Rust as OwnedArc and ArcRef

LibWeb: Take the objects C++ lends to FFI entry points by reference

LibWeb: Pass plain-value arrays through FFI as AK spans

LibWeb: Take objects C++ hands back as OwnedRc, OwnedArc and OwnedBox

LibWeb: Mark the custom ident style value constructor unsafe

LibGfx: Remove OwnedPath and the C++ path shims

LibWeb+LibCompositing: Use the native Path in Rust

LibCompositing+Compositor: Pass clip paths to the painter as contours

LibGfx: Lay out glyph outline paths in Rust

LibWeb: Hand Rust-built paths to C++ as bytes

LibWeb: Read the bounding box of an SVG shape from Rust

LibGfx: Add a native Path to libgfx_rust

LibWeb: Don't crash when closing a byte stream mid-element

LibWeb: Don't crash when pipeTo() shuts down before a queued write

LibWeb: Implement Streams in Rust

LibWeb: Support promises, callbacks and async iterables in Rust bindings

LibWeb: Let Rust constructors return the object they create

LibJS: Expose promises, iterators and native functions to Rust

LibMedia+LibWeb: Use checked arithmetic for byte parsing

LibMedia: Don't crash on bad WebM data

LibWeb: Implement TextEncoderStream and TextDecoderStream in Rust

LibWeb: Implement CompressionStream and DecompressionStream in Rust

LibCompress: Add a Rust crate for streaming compression

LibWeb: Accept any CSS color as the value of input type=color

Tests: Import WPT tests for input type=color

LibWeb: Implement Blob and File in Rust

Meta+LibWeb: Support Blob and File in the Rust bindings

LibURL+LibWebCommon+LibWeb: Process data: URLs in Rust

LibWeb+LibWebView+WebContent: Serve the WPT tree over HTTPS in test-web

LibWeb+WebWorker: Apply the embedder policy when a worker starts

LibWeb+LibWebCommon: Inherit a blob URL entry's policy container

LibWeb+LibWebCommon: Give local workers their owner's policy container

LibWeb: Base a window's cross-origin isolated capability on its cluster

LibWeb: Remove SharedArrayBuffer from realms that are not isolated

LibWeb+LibWebCommon+LibWebView: Send agent clusters' isolation modes

LibWebCommon+LibWebView: Give agent clusters an isolation mode

LibWeb+LibWebCommon+LibWebView: Check CORP on nested navigations

LibWebView: Check a navigation response's adherence to embedder policy

LibWebView: Hold the embedder policy of each document's policy container

LibWeb: Implement the cross-origin resource policy check

LibURL: Add "schemelessly same site"

LibWebView: Obtain a response's opener and embedder policies in the UI

LibWeb+LibWebCommon: Obtain an opener policy in LibWebCommon

LibWeb+LibWebCommon: Obtain an embedder policy from a fetch response

LibWeb+LibWebCommon+LibWebView: Share Fetch's URL scheme checks

LibWeb+LibWebCommon: Move the secure contexts checks into LibWebCommon

LibWeb: Parse Document-Policy as a structured field

LibWeb: Parse Cross-Origin-Opener-Policy as a structured field

LibHTTP: Add Fetch's "get a structured field value" to header lists

LibHTTP: Add a Structured Field Values parser

LibGfx+LibCompositing: Remove unused CornerClip

LibGfx: Remove unused CornerRadii code

LibGfx: Remove unused Path line helpers

LibGfx: Remove unused matrix helpers

LibGfx: Remove unused Size::match_aspect_ratio()

LibGfx: Remove unused Rect helpers

LibGfx: Remove unused Point helpers

LibGfx: Remove unused polar color conversions

LibGfx: Remove unused SVG gradient paint styles

LibGfx: Remove unused TextAlignment helpers

LibGfx: Remove unused Matrix3x3 helpers

LibGfx+LibCompositing+Compositor: Remove Gfx::Filter

LibGfx: Move ColorFilterType into its own header

LibGfx+Compositor: Keep paths in libgfx_rust instead of Skia

LibGfx: Add a path geometry to libgfx_rust

LibCompositing+Compositor: Keep a Skia path for each retained clip path

LibGfx: Don't leave a lone move before an appended path

LibGfx+Compositor: Parse ICC profiles in the compositor

LibGfx+Compositor: Move Skia surfaces and painting helpers to compositor

LibCompositing+Compositor: Move canvas surface registry to compositor

LibGfx+LibCompositing: Split the export formats out of BitmapExport.h

LibWebCommon+LibWeb: Implement MIME Sniffing in Rust

LibWeb: Apply the offset transform of CSS Motion Path

LibWeb: Interpolate and compose the offset properties

LibWeb: Add the CSS Motion Path offset properties

Tests/LibWeb: Import CSS Motion Path tests

LibGfx: Add Path::stroke_to_fill()

LibWeb: Follow the SVG rules for which elements are focusable

LibWeb: Parse the SVG values of the pointer-events property

Tests: Import WPT tests for SVG hit testing and pointer-events

LibWeb: Remove the C++ view of computed sizes

LibWeb: Resolve calc-size() in intrinsic sizes, flex, tables and images

LibWeb: Give replaced elements their natural height for size keywords

LibWeb: Interpolate sizing keywords through calc-size()

LibWeb: Implement calc-size() for sizing properties

LibWeb: Parse the interpolate-size property

LibWeb: Ignore namespaced event handler attributes

Meta: Point the Flatpak OpenSSL at the runtime's trusted roots

LibWeb: Preserve token counts through custom property substitution

LibWeb: Cache token counts for component-value lists

LibWeb: Use a hash set to track custom properties affected by animations

LibWeb: Reuse compiled custom function data during substitution

LibWeb: Resolve custom function visibility indices once per snapshot

LibWeb: Avoid unnecessary transaction management in `parse_node`

LibWeb: Avoid unnecessary work when parsing single token syntax types

LibWeb: Parse substituted component values directly

LibWeb: Borrow function-local registration syntaxes

LibWeb: Borrow tokens in parsed CSS boolean expressions

LibWeb: Borrow custom function declaration and default tokens

LibWeb: Use component values for arbitrary substitution functions

LibWeb: Parse registered syntax from component values

LibWeb: Reuse component values when constructing unresolved values

LibWeb: Cache computed element custom property values

LibWeb: Isolate guards when computing inherited custom properties

LibURL+LibWeb: Implement URL and URLSearchParams in Rust

LibURL+LibWeb: Implement Origin in Rust

Meta+LibJS+LibWeb: Support the URL interfaces in the Rust bindings

LibURL+LibWeb: Parse and serialize urlencoded forms in Rust

LibURL: Compute the origin of a URL in Rust

LibTextCodec+LibWeb: Share one streaming decoder with TextDecoder

LibTextCodec: Remove only the sniffed BOM when decoding

LibTextCodec: Encode through a fixed-size output buffer

LibTextCodec: Add an x-user-defined encoder

LibWeb: Mark the scroll state stale where scroll offsets are stored

LibWeb: Remove filter_from_functions() and the Rust export behind it

LibWasm: Simplify the engine and the JIT

LibWasm+LibWeb: Keep WebAssembly objects and waits right

LibWasm: Harden the runtime and the JIT

LibWasm: Add an AArch64 backend to the JIT

LibWasm: Turn the JIT on by default

LibWasm: Compile SIMD, GC, atomics and exceptions in the JIT

LibWasm: Run compiled code in the runtime, tiering up hot functions

LibWasm: Add an optimizing JIT compiler

LibWasm+LibWeb: Port the interpreter, and finish GC and exceptions

Everywhere: Remove the C++ WebAssembly engine and Cranelift

LibWasm+LibWeb: Run WebAssembly on the Rust engine

LibWasm: Add a Rust WebAssembly engine with a Flap interpreter

LibGC: Align cells to at least 16 bytes

LibJS+LibWeb: Implement the geometry interfaces in Rust

LibGfx: Make the 4x4 matrix arithmetic generic over the element type

Meta+LibWeb: Support more of WebIDL in the Rust bindings

LibWebView: Keep the unwind panic test's Rust runtime private

LibWeb: Replace ASCII whitespace in the text of fillText and strokeText

LibWeb: Fix two typos in the error messages of ImageData

LibWeb: Do not serialize platform objects that are detached

LibWeb: Keep the path when the transform of a context becomes singular

LibWeb: Clear the whole bitmap when a 2D context resets

LibWeb: Taint canvases with SVG images that are CORS-cross-origin

LibWeb: Throw for WebGL texture sources that are not origin-clean

LibWeb: Find no point in a path under a matrix that is not invertible

LibWeb: Check the ImageData of putImageData() without a bitmap too

LibWeb: Condense text for maxWidth around where it starts

LibWeb: Keep the path in place when a context replaces its transform

LibWeb: Do not map the last point of a path twice in arcTo()

LibWeb: Taint 2D canvases through patterns and image bitmaps

LibCompositing+LibWeb: Implement the 2D canvas contexts in Rust

LibGfx: Give Rust the first font of a cascade and its invisible fonts

Meta: Declare in C++ the dictionaries that Rust only returns

Meta+LibWeb: Convert [LegacyNullToEmptyString] in the Rust bindings

Meta+LibWeb: Convert integers with [EnforceRange] in the Rust bindings

Meta: Set attributes of enumeration types in the Rust bindings

LibWeb: Add tests of the attributes and operations of 2D contexts

LibWeb: Implement ImageBitmap in Rust

Meta+LibWeb: Make interfaces implemented in Rust transferable

LibJS+Meta+LibWeb: Count the external memory of Rust interface objects

LibGfx: Let Rust take over a decoded image frame from C++

LibWeb: Implement ImageData in Rust

Meta: Export the classes of the wrappers of Rust interfaces

Meta+LibWeb: Make interfaces implemented in Rust serializable

Meta+LibWeb: Support [CachedAccessor] in the Rust bindings

LibWeb: Implement Path2D in Rust

LibWeb: Resolve C++ overloads with objects of Rust interfaces

Meta: Give unions numeric default values in the Rust bindings

Meta+LibWeb: Convert to unions with numbers in the Rust bindings

Meta: Convert to unions with Rust interfaces in the Rust bindings

Meta: Name the unions without a typedef in the Rust bindings

LibWeb: Implement the operations of a canvas path in Rust

LibGfx: Let Rust build on a path in place

LibWeb: Implement CanvasPattern in Rust

LibWeb: Implement TextMetrics in Rust

LibWeb: Implement CanvasGradient in Rust

Meta+LibWeb: Throw DOMExceptions from the Rust bindings

Meta+LibWeb: Convert restricted doubles in the Rust bindings

LibGfx+LibWeb: Remove CanvasCommandList

LibCompositing+LibWeb+Compositor: Move the 2D canvas to the tape

LibCompositing: Record 2D canvas commands in Rust

LibCompositing: Write and check the tape of a 2D canvas in Rust

LibCompositing+LibWeb+Compositor: Add the 2D canvas commands to the tape

LibIPC+Meta: Generate codecs for declared structs, enums and variants

Tests/LibIPC: Exchange messages with a generated Rust endpoint

Meta: Generate Rust endpoints from IPC definitions

LibIPC: Add Rust message transports

LibIPC: Add Rust codecs for the IPC wire format

LibWeb: Answer SVG geometry queries from the Rust shape builders

CI: Recover from a partially installed Rust toolchain on Windows

LibWeb: Read rule contexts through a table rather than a transmute

LibWeb: Pass WebGL extension names as AK spans

LibWeb: Pass the encoding detector and font matcher spans

LibWeb: Pass the HTML preload scanner its input as AK spans

LibWeb: Feed the Rust HTML tokenizer its input as AK spans

LibWeb: Answer discrete keyword animations with copied values

LibWeb: Count a parse's random functions through a typed reference

LibWeb: Borrow what a ParseContext names through typed fields

LibWeb: Make small render state and painting helpers safe

LibWeb: Pass content blocker strings as AK spans

LibWeb: Read SVG parser input as FfiUtf16View, and type parsed paths

LibWeb: Take objects C++ holds strongly as RcRef and ArcRef

LibWeb: Pass custom property stores as Arcs inside the style engine

LibWeb: Take style values by reference in the FFI computations

LibWeb: Make FfiMediaEnvironment a borrowed view that reads safely

LibWeb: Take more pointer parameters as references

LibWeb: Take parsed syntax handles by reference

LibWeb: Read and compare style values through their handles

LibWeb: Intern specified values from Arc references

LibWeb: Make FfiRectToViewportTransform a view that reads safely

LibWeb: Take the compositor animation effect state by reference

LibWeb: Build compositor animation test requests over borrowed keyframes

LibWeb: Reach a test host and its arena without raw pointers

LibWeb: Pay layout rounds through safe functions

LibWeb: Declare host imports that take plain values as safe

LibWeb: Take FFI out-parameters as mutable references

LibWeb: Take the WebGL context cell as a typed reference

AK: Add Rust spans that mirror a Span and a ReadonlySpan

Everywhere: Move hardware video decoding to a separate process

LibMedia+LibMediaCodecs: Skip non-reference frames before the decoder

MediaServer: Process capability requests off the main thread

LibMedia: Don't use the thread pool for playback manager source init

LibMedia+LibMediaCodecs: Let decoders wake the producer for output

LibMedia: Make the incremental stream cursors' abort flag atomic

LibMedia: Re-seek video to EOS if no output was requested

LibMedia: Build an Ogg demuxer from its navigator and drop libavformat

LibMedia: Offset resampled buffers by the processing delay

LibMedia: Build a FLAC demuxer to replace libavformat's

LibMedia: Ensure that MP3 and ADTS demuxers reproduce aborted frames

LibMedia: Make a WAV demuxer and drop it from libavformat

LibMediaCodecs: Split decoding types and registries out of LibMedia

LibMedia: Select system FFmpeg codec IDs by their names

LibMedia: Ensure that video seeks resolve with a frame at the target

LibMedia: Hold the Buffering state until data arrives

LibCompositing: Bound stroked paths by the reach of joins and caps

LibGfx: Compute the output bounds of a filter graph

LibWeb: Say what kept a layout update going when it runs out of passes

Meta: Run Rust debug assertions in sanitizer builds

LibWeb: Keep pending inputs when absorbing a newer journal

LibWeb: Check the slot generation of committed fragment link reads

Everywhere: Build Rust slices over C++ arrays without null pointers

LibWeb: Recompute an animated element when its environment moves

AK+Everywhere: Truncate Duration conversions to whole units

LibDatabase+LibWebView: Round stored times as time points

AK+LibCore+UI: Round up timeouts passed to the OS explicitly

Everywhere: Remove manual round-up from timer intervals

LibWeb: Take AK::Duration in Platform::Timer

LibCore+Everywhere: Take AK::Duration in Core::Timer

LibCore: Take AK::Duration when registering event loop timers

AK: Round time points down to whole seconds and milliseconds

LibWeb: Accept a missing second operand in numeric type operations

LibWeb: Call the style sheet compilation callbacks through a safe host

LibWeb: Take references in FFI entry points that only dereference

LibWeb: Stop marking FFI entry points unsafe when they need nothing

LibWeb: Make FfiUtf16View a borrowed view that reads safely

LibWeb: Declare the dependencies of the Rust bindings archive

LibWeb: Parse substituted values through a shared helper

LibWeb: Remove inaccurate FIXME in `resolve_function_styles`

LibWeb: Document cycle invalidation of a function's calling property

LibWeb: Hide function locals when resolving element custom properties

LibWeb: Stop substituting inherited custom property values

LibWeb: Look up custom functions in the scope being evaluated

LibWeb: Accept non-negative signed indices in `env()`

LibWeb: Validate substitution function arguments before replacement

LibWeb: Resolve tree-counting functions in style queries

LibWeb: Pass the resolution context through style query comparisons

LibWeb: Answer WebGL's vendor and version strings as the claimed engine

LibWeb: Expose what only one engine has in that engine's mode alone

LibWeb: Resolve the font shorthand's system font keywords

LibWeb: Render system-ui with the test font in layout-test mode on macOS

LibWeb: Report a 10 GiB storage quota from navigator.storage.estimate()

LibJS: Leave the Error constructor's own frame out of error stacks

LibWebView: Start new profiles on the platform's language, not “en”

LibWeb: Make navigator.platform MacIntel on macOS and Win32 on Windows

LibWebView+WebWorker: Give workers the page's User-Agent and languages

LibWeb: Trace intrinsic size and table cell measurements

AK: Capture the backtrace of a Rust panic that will abort

AK: Name backtrace frames in images whose debug info is unreadable

Meta+Tests: Check that every Rust export of LibWeb has a C++ caller

LibWeb: Remove Rust exports that nothing calls

LibWeb: Implement WebGL in Rust

Meta: Keep clippy quiet about three shapes of the Rust bindings

LibJS: Export foreign cell slots and weak references to embedders

LibWeb: Record WebGL commands in Rust

LibWeb: Generate the WebGL command vocabulary and constants in Rust

LibCompositing: Assert and report the layout of WebGL command structs

LibWeb: Give the WebGL transport a C ABI

Meta+LibWeb: Let the C++ bindings name interfaces implemented in Rust

Meta+LibWeb: Resolve operation overloads in the Rust bindings

Meta+LibWeb: Pass objects of C++ interfaces to the Rust bindings

Meta+LibJS+LibWeb: Convert views and sequences in the Rust bindings

Meta+LibWeb: Let an interface implemented in Rust inherit from another

Meta+LibWeb: Define constants and setters in the Rust bindings

Meta+LibWeb: Convert integers and plain JS values in the Rust bindings

Meta+LibJS+LibWeb: Keep one wrapper per world for Rust interface objects

Meta: Classify the members of an interface once for the Rust bindings

LibGC+LibJS: Bump-allocate the never-allocated cells of a block

LibGC: Fault in the next heap chunk on the decommit worker

LibGC: Give back a local free list to its block in O(1)

LibWeb: Let go of a pending response's callback once it has run

LibWeb: Make rule selector accessors safe, and use them in tests

LibWeb: Resolve custom property substitutions over Rust types

LibWeb: Pass animation samples between Rust functions as Rust types

LibWeb: Implement the queuing strategies in Rust

Meta+LibWeb: Convert doubles and callback results in Rust bindings

LibJS: Give a realm a slot for the data of a Rust embedder

LibWeb: Implement URLPattern in Rust

Meta+LibWeb: Resolve constructor overloads in the Rust bindings

Meta+LibJS+LibWeb: Convert unions and containers in Rust bindings

LibWeb: Implement TextDecoder in Rust

Meta+LibJS+LibWeb: Convert dictionaries and buffers in Rust bindings

Meta: Give a dictionary a representation in each language that names it

LibWeb: Implement SpeechRecognitionPhrase in Rust

Meta+LibWeb: Convert constructor arguments and floats in Rust bindings

LibWeb: Remove comments and blocks left over from unsafe removal

LibWeb: Mark style group payload comparisons as unsafe

LibWeb: Make style and layout helpers safe that only return FFI data

LibWeb: Type host callback tables as safe function pointers

LibWeb: Make exports safe that take plain-data FFI structs

LibWeb: Take null-checked pointer parameters as optional references

LibWeb: Build more style value handles without raw pointers

LibWeb: Build style groups from typed value handles and payloads

LibWeb: Take shadowed pointer parameters as references

LibWeb: Read group entries through the safe effective value lookup

LibWeb: Give ParseContext and length contexts a safe Default

LibWeb: Take FFI pointer parameters as references where possible

LibWeb: Drop unsafe from host helpers that only take a DocumentHost

LibWeb: Make FFI exports safe when their bodies need no unsafe

LibWeb: Remove Rust FFI exports that nothing calls

LibWeb: Build fresh style value handles with the safe from_arc()

LibWeb: Borrow tables and overlays through StyleRecordView references

LibWeb: Own animation value results in Rust instead of raw pointers

LibWeb: Share one helper for publishing built style group payloads

LibWeb: Dispatch style group payload operations through one macro

Tests/LibWeb: Reach the untrustworthy test origin without 0.0.0.0

Tests: Widen some screenshot tests' fuzziness to cover Windows

Tests: Use the Linux inline-border-fragmentation screenshot for Windows

Meta: Disable floating-point contraction with clang-cl

Tests: Serve the HTTP test fixture on ::1 as well

AK: Read the Windows wall clock at full precision

AK: Account for the stack guarantee in the Windows StackInfo

LibIPC+LibCore+LibWebView+UI: Carry Windows IPC over named pipes

LibWebView+Compositor+MediaServer: Let the Browser mint sibling channels

LibIPC+LibWebView+Services: Broker Windows handle transfers via Browser

test-web: Produce forward slashes in reports on Windows

test-web: Use JsonValue to serialize the test paths to results.js

Tests: Avoid root-relative links in accessibility tests

test-web: Don't continue to start tests after interruption

LibCore+UI: Destroy event loop queues before the event loops themselves

LibCore: Avoid using process exit handler data after free on Windows

LibCore: Poll Windows sockets until they would block

LibCore: Allow multiple notifiers listening to a single Windows socket

AK+LibCore+test-web: Implement pipe notifiers on Windows

test-web: Use "python" instead of "python3" on Windows

test-web: Keep the HTTP server's stdout alive while it's running

test-web: Signal the HTTP server to exit through stdin EOF

LibCore: Implement signal handlers on Windows

LibCore: Differentiate between sockets and pipes in is_socket()

LibCore: Stop shutting down sockets when they are closed on Windows

LibWasm: Use the same logic to pass fds on Windows and Unix

LibWebView: Use DupFd to pass descriptors to helpers

LibCore: Allow passing descriptors to spawned processes on Windows

LibMedia+Compositor: Send the Compositor's PID to the video connection

LibJS: Return intrinsic accessor values via out parameters on Windows

WebContent: Handle crashes on Windows

LibCompositing+LibWeb: Use out parameters for non-trivial returns

LibWeb: Implement TextEncoder in Rust

Meta+LibWeb: Add a Rust backend to the WebIDL bindings generator

LibWeb: Build the LibJS runtime into LibWeb's library

LibJS: Expose an embedding API of the Rust runtime

LibJS: Let embedders put their own values in GC cells

AK: Expose the UTF-8 encoding of well-formed UTF-16 to Rust

Tests/LibWeb: Add TextEncoder coverage

LibJS: Read instructions out of bytecode through checked views

LibJS: Name environment shape cache slots by their owner

LibJS: Make Gc::from_ref() safe by checking for the heap region

LibJS: Share the helpers that find the VM of a cell or helper call

LibJS: Upcast cells to their header instead of casting pointers

LibJS: Call LibGC's heap functions through a reference to the heap

LibJS: Form addresses with wrapping pointer arithmetic

LibJS: Declare the interpreter's dispatch tables as safe statics

LibJS: Look up the js REPL's home directory through std

LibJS: Use the getrandom and memchr crates instead of libc calls

LibJS: Take references and Gcs in the JIT's runtime entry points

LibJS: Mark value storage header reads as unsafe

LibJS: Hand out shared array buffer words as typed atomics

LibJS: Remove the unused default UTC epoch nanoseconds export

LibJS+LibUnicode: Use the Rust calendars without a C++ round trip

LibUnicode: Expose the Rust calendar conversions to Rust callers

LibJS: Abort test-js through std::process::abort()

LibJS: Hold a FlyStringSlot's string in a Cell

LibJS: Keep each class's cell kind as a CellKind

LibJS: Share one UnicodeTextMappingOutput between the unicode modules

LibJS: Declare LibGC's precondition-free queries as safe

LibJS: Own copied bytecode cache blobs without a C callback

LibJS: Use the safe executable conversions in the interpreter

LibJS: Borrow the running execution context through one accessor

LibJS: Downcast cell references through one checked helper

LibJS: Call the frontend's host functions as Rust functions

LibJS: Stop carrying compiled regexes the frontend only validates

LibJS: Dump bytecode without a C callback table

Meta: Keep frame pointers on all Unix-like platforms

LibJS: Initialize `legacy_arguments` in a JIT pass test's frame state

LibHTTP: Drop malformed rows when opening the cache index

RequestServer: Store cookies and HSTS policy of background revalidations

LibHTTP: Don't store responses with an unterminated Cache-Control string

LibHTTP: Ignore fields nominated by Connection when caching responses

LibHTTP: Discard responses still being written when clearing the cache

LibHTTP: Remove associated data along with unreadable cache entries

LibHTTP: Load persisted index rows before looking up a single entry

RequestServer: Bound the total time a request waits on a cache entry

LibHTTP+RequestServer: Release cache readers held by destroyed requests

RequestServer: Key revalidation responses by the validators they sent

LibHTTP: Retire memory cache entries replaced by non-storable responses

LibHTTP+LibWeb: Invalidate memory cache entries after unsafe requests

LibHTTP+RequestServer: Invalidate stored responses after unsafe requests

LibHTTP+RequestServer: Keep trailer fields out of stored responses

LibHTTP: Enforce the cache entry size limit while writing the body

RequestServer: Only store responses whose transfer succeeded

LibHTTP: Enforce cache size limits when a 304 updates an entry

LibHTTP: Only freshen a stored response with a 304 that matches it

LibHTTP: Don't revalidate with a request's own preconditions

LibHTTP+RequestServer: Fail revalidation when a 304 changes Vary

LibHTTP: Don't revalidate a fresh entry that has no validators

LibHTTP: Select the most recent stored response that matches a request

LibHTTP: Don't cache responses that vary on Cookie

LibHTTP: Limit Vary fields and stored variants per cache key

LibHTTP: Build Vary keys from canonical, length-framed request fields

LibHTTP: Don't abort on a stored response with a Vary wildcard

RequestServer: Stop a disconnected client's work when it goes away

RequestServer: Limit how many WebSockets clients may have open

RequestServer: Reject WebSocket IDs that name a live WebSocket

RequestServer: Only share AIA certificates that helped verify a chain

RequestServer: Keep private clients' AIA state apart from normal ones

RequestServer: Give private clients a DNS resolver of their own

RequestServer: Don't follow redirects when fetching AIA certificates

RequestServer: Stop granting the Linux sandbox all of /etc/ssl

RequestServer: Only let the sandbox read custom certificate files

LibHTTP+RequestServer: Don't search all response headers for each one

RequestServer: Only keep the header fields of the final response

LibRequests+LibWeb+RequestServer: Remove client certificate IPC

RequestServer: Reject live request IDs in all requests clients start

RequestServer: Limit the size of shared WebSocket messages we send

RequestServer: Reject unknown kinds of cache associated data

RequestServer: Don't let curl send credentials from request URLs

RequestServer: Only open WebSockets to ws(s) URLs on allowed ports

RequestServer: Reject invalid header names and values from clients

RequestServer: Reject invalid and forbidden request methods

RequestServer: Only fetch HTTP(S) URLs on ports Fetch allows

LibHTTP+LibWeb: Move is_bad_port() to LibHTTP

LibWeb: Rank scopes again once staged rule changes commit

LibWeb: Share one comparison of changed style groups

LibWeb: Say which answers defer their cascade completion

LibWeb: Sample animations before taking a direct style transaction

Tests/LibWeb: Add test for children inserted under animated parents

Tests/LibWeb: Add test for slot display changes on assigned elements

LibWeb: Collect changed cascade inputs only for cascade reuse

LibWeb: Check the shadow host's marks once for animated slots

LibWeb: Skip identical tables when diffing explicit inheritance

LibWeb: Restrict explicit inheritance updates to changed groups

LibWeb: Compute changed substituted values with partial drives

LibWeb: Keep computed styles when substituted inputs stay unchanged

LibWeb: Propagate inherited styles after animation composition

LibWeb: Reconstruct transition styles only when effects change

LibWeb: Preserve intrinsic sizes across paint-only style changes

LibWeb: Skip default payload setup for borrowed style views

LibWeb: Avoid publishing unchanged layout style records

LibWeb: Defer unchanged contextual cascade completion

LibWeb: Share inherited group swaps between equivalent records

LibWeb: Preserve inherited group changes through slot assignments

LibWeb: Apply box-type adjustments during partial style drives

LibWeb: Avoid descendant style work for unobserved slot animations

LibWeb: Partially drive inherited text changes beneath transitions

LibWeb: Partially compute base styles beneath running animations

LibWeb: Limit slot paint changes to children that explicitly inherit

LibWeb: Remove manually transferred nodes from their previous slot

LibWeb: Limit slot reassignment style work to moved elements

LibMedia+AudioServer+LibWebView: Capture through the AudioServer

LibMedia: Add a registry that shares one capture stream per device

LibMedia+AudioServer: Watch audio devices through the AudioServer

LibWeb: End capture tracks whose input device was removed

LibMedia: Watch the platform's audio devices rather than list them once

LibWeb+LibWebView+UI/Qt: Ask the user before granting a permission

AudioServer+LibWeb+MediaServer: Play headless audio via the AudioServer

WebContent+LibWebView: Play WebAudio through the AudioServer

MediaServer+LibWebView: Play audio through the AudioServer

AudioServer+LibWebView: Add the AudioServer process

LibMedia: Add a PlaybackStream backend that plays through an AudioServer

LibMedia: Add a mixer that plays shared rings on one device stream

LibMedia: Add a shared-memory audio stream ring

LibMedia: Split the SPSC audio frame ring's discipline from its storage

LibMedia: Remove PlaybackStream::total_time_played()

LibWeb: Date WebAudio's output time from the data request callback

LibMedia: Stop the stream at once on pause and seek instead of draining

LibMedia: Drive the playback clock from the audio data request callback

LibMedia: Tell the data request callback when its buffer will be heard

LibMedia: Unref a PulseAudio operation that completed with an error

LibMedia: Zero the unfilled tail of a partially filled AudioUnit buffer

LibMedia: Dispose of the AudioUnit instance when a playback stream dies

LibSandbox: Let the Audio service capture from the microphone

LibSandbox: Let the AudioDecoding service reach the component registrar

LibIPC: Call die() only once per connection

LibWebView: Give WebUI pages processes of their own

LibWebView: Let no javascript: URL result claim local file content

LibWebView: Keep history to web pages and local files

LibWebView: Quarantine downloaded files on macOS

LibFileSystem+LibWebView: Never replace a file that appears mid-download

LibWebView: Open downloads only on the user's click in about:downloads

LibWebView+UI/Qt: Keep private downloads out of other sessions' UI

LibWebView: Limit how many workers a top-level site can run

LibWebView: Fail worker starts instead of aborting the browser

LibWeb+LibWebView+WebContent: Refuse window changes no one asked for

LibWebView: Let pages use the clipboard only after the user's input

LibWebView: Trust only delivered input for launching mailto: links

LibWebView: Open popups and tabs only for input the UI delivered

LibWeb+LibWebView+WebContent: Remove the tab activation request

LibJS: Take the JIT's options from the compiler crate

LibSandbox: Allow memory protection keys in the renderer sandbox

LibJS: Test the JIT code generator against a fake runtime

LibJS: Lower calls and add the call stub to the JIT code generator

LibJS: Lower property cache probes in the JIT

LibJS: Lower values, strings, environments and allocation in the JIT

LibJS: Lower slow path calls and speculation in the JIT

LibJS: Add the core of the JIT code generator

LibJS: Add the register allocator of the JIT

LibJS: Test the JIT graph builder on hand-made snapshots

LibJS: Inline calls and builtin functions in the JIT graph builder

LibJS: Build speculated arithmetic and checks in the JIT

LibJS: Build property accesses in the JIT from lookup cache entries

LibJS: Build environment, global and allocation nodes in the JIT

LibJS: Add the graph builder's core and bytecode handling to the JIT

LibJS: Decode assembled bytecode in the JIT crate

LibJS: Mark Flap terminators that can fall through

LibJS: Move the shared Rust bytecode generator into flapc

LibJS: Add the libjs_jit crate with its small utilities

Meta: Only ignore build directories at the root of the tree

LibJS: Build a profiling variant of the interpreter

LibJS: Run interpreter frames with their executable's dispatch table

LibJS: Add read-modify-write memory updates to Flap

LibJS: Let Flap compile a profiling variant of the interpreter

LibJS: Mark loop back edges with their own jump instructions

LibJS: Show feedback slot indices in bytecode dumps

LibJS: Assign interpreter feedback slots to bytecode instructions

LibGC: Let foreign code find the context of a cell's heap

LibJS: Keep the size classes of each class in a table in the Rust heap

LibJS: Pop LibGC's local free lists inline in the Rust heap

LibJS: Add size-classed cell allocators to the Rust heap

LibGC: Expose local free lists and heap counters to foreign code

LibGC: Let foreign code allocate storage cells that never collect

LibGC: Allocate cells from per-allocator local free lists

LibWebView: Only let automation synthesize trusted input

LibWebView: Only let local file content read local files

LibWeb: Publish effect timing independently of sampled progress

LibWeb: Make effect active time computation reusable

LibWeb: Delegate animation overlay emptiness check to Rust

LibWeb: Copy animated overlay as a whole when reconstructing style

LibWeb: Sample the full effect stack when starting transitions

LibWeb: Stub the LibGfx text entry points a Rust unit test may link

LibWeb: Recover missing published styles during incremental layout

LibWeb: Wait for document collection during request teardown

LibWeb: Await committed frames in the video sink visibility test

LibWeb: Reject async wheel scrolling against stale tree structures

LibWeb: Synchronize parser tests with response gates

WebContent: Handle closes queued before a process switch

LibWeb: Synchronize document lifecycle checks in web tests

LibWeb: Force one DevTools catch-up layout round, not one per pass

LibWebView+WebContent: Hand DevTools state to every page of a tab

LibCompositing+LibWeb: Stop exposing the display list tape to C++

LibCompositing+Compositor: Answer list queries from Rust summaries

LibCompositing: Keep each display list's tape behind a Rust handle

LibCompositing+Compositor: Move DisplayListPlayer into the compositor

LibCompositing: Walk display list records in Rust during replay

LibCompositing: Copy and validate received display list tapes in Rust

LibCompositing: Generate the display list command X-macro from Rust

LibWeb: Collect a published list's resources only when they are kept

LibWeb: Carry the surface clear color without a placeholder display list

Tests: Remove C++ tests that write display list tapes

LibJS: Only give dynamic functions an arguments object if they need one

LibJS: Give binary operator slow paths the length of their instruction

LibJS: Format integral numbers without the shortest-digits algorithm

LibJS: Keep the legacy RegExp statics when RegExp.prototype.test fails

LibJS: Ask the storage directly in HasOwnProperty of ordinary objects

LibJS: Gather the pieces of small ropes without allocating

LibRegex: Merge overlapping ranges of character classes

LibWeb: Resolve getComputedStyle relative colors in Rust

LibWeb: Resolve to_color() against a style instead of a context

LibWeb: Resolve the theme color against the root element's style in Rust

LibWeb: Build the document's own style in Rust

LibWeb: Resolve compositor animation colors in Rust

LibWeb: Resolve cursor gradient stop colors in Rust

LibJS: Merge the Rust runtime crate into libjs_rust

LibJS: Describe the runtime without the C++ runtime it replaced

LibJS: Record the Rust runtime's interpreter layout for Flap

LibJS: Move the facade to the paths of the headers it replaces

LibJS: Remove the C++ runtime

Meta: Stop building the C++ LibJS runtime

Meta: Build LibJS's users on the Rust LibJS runtime by default

LibJS: Check engine classes inline and speed up short concatenation

LibJS: Count and free Rust cell storage as the C++ runtime does

LibJS: Speed up strings, execution contexts and promise jobs

LibJS: Complete the facade's API and check the cells it receives

LibJS: Add the facade's console, print(), highlighter and debugger

LibJS: Add the facade's builtin objects

LibJS: Add the facade's array buffers, typed arrays and DataView

LibJS: Add the facade's sources, scripts, modules and compilation

LibJS: Add the facade's iterators, operations and environments

LibJS: Log exceptions where the Rust runtime throws them

LibJS: Add the facade's values, VM, realms and objects

Tests: Check JS objects in ways that work with either LibJS runtime

AK: Leave out the dynamic_cast for types that have fast_is

LibGC+Meta/ClangPlugins: Support foreign cells without a vtable

LibJS+Meta: Add LIBJS_RUNTIME to build LibWeb on the Rust runtime

LibJS: Keep cache updates and blob checks out of Rust hot paths

LibJS: Support bytecode caches in the Rust runtime

LibJS+Meta: Allow the Rust LibJS runtime on Windows

LibJS: Run test262 agents in child processes of the Rust runner

LibJS: Export the builtins and operations that LibWeb uses

LibJS: Export modules and host modules through the embedding ABI

LibJS: Export scripts and compiling through the embedding ABI

LibJS: Add Rust host objects, functions and arrays

LibJS: Export objects, functions, environments and the debugger

LibJS: Offer off-thread compiling and the bytecode cache natively

LibJS: Export array buffers and typed arrays in the embedding ABI

LibJS: Export realms, the VM and host hooks in the embedding ABI

LibJS: Export values, strings, errors and execution contexts

LibJS: Generate embedding headers and reserve embedder state

Meta: Keep C++-only compile options away from C sources

LibJS: Port the debugger and the REPL of js to the Rust runtime

LibJS: Make js-rust's errors, output and exit match js

LibJS: Port the runtime test runner to the Rust runtime

LibJS: Speed up the Rust runtime's hot paths

LibGC+LibJS: Keep Rust data blocks in LibGC's primitive storage

LibJS: Format error message arguments as UTF-16 in the Rust runtime

LibJS: Check the weak pointer offset of LibGC at startup

LibJS: Port Intl's formats and plural rules to the Rust runtime

LibJS: Port Temporal to the Rust runtime

LibJS: Port the Intl foundation to the Rust runtime

LibJS: Port modules and dynamic import to the Rust runtime

LibJS: Port Date to the Rust runtime

LibJS: Port JavaScript-backed builtins to the Rust runtime

LibJS: Port iterator helpers and DisposableStack to the Rust runtime

LibJS: Port ArrayBuffer, typed arrays and Atomics to the Rust runtime

LibJS: Port the RegExp builtins to the Rust runtime

LibJS: Port Proxy objects and the Proxy constructor to the Rust runtime

LibJS: Port Map, Set and the weak collections to the Rust runtime

LibJS: Port promises, async functions and async generators to Rust

LibJS: Port eval, $262 and the js host globals to the Rust runtime

LibJS: Port generators to the Rust runtime

LibJS: Port Number, Boolean, BigInt, String, Symbol, Math and JSON

LibJS: Port Object, Function, Reflect and Array builtins to Rust

LibJS: Port js's printing, bytecode dumps and test262 error reports

LibJS: Port the call, class, literal and iterator slow paths to Rust

LibJS: Port realms, intrinsics and errors to the Rust runtime

LibJS: Port value operators and property access to the Rust runtime

LibJS: Add environments and function objects to the Rust runtime

LibJS: Add the object model to the Rust runtime

LibJS: Add strings, numbers and exceptions to the Rust runtime

Utilities+Tests/LibJS: Add js-rust and test262-runner-rust

LibJS: Add the Rust runtime's GC toolkit and frontend host functions

LibJS: Add a native compile API to the Rust frontend

LibJS: Put the Rust frontend's C++ glue behind a cpp-runtime feature

LibJS: Add the Rust runtime crate and run Flap's interpreter in it

LibJS: Report the runtime functions a Flap program calls

LibUnicode: Add C exports for the Rust LibJS runtime

AK: Expose UTF-16 string internals and AK's conversions to Rust

LibJS: Add libjs_abi for values shared by the frontend and runtimes

LibJS: Pass the VM to interpreter helpers that use VM state

LibGC: Add a C API for cells defined outside C++

Meta: Treat all rust build warnings as errors

LibWeb: Resolve build warnings in rust tests

AK: Demangle Rust symbols in stack traces

Meta: Link Rust crate initializers into static builds

Rust: Move the global allocator into a shared crate

LibGfx: Carry a color space as CICP or parametric data

LibWeb: Close style reactions over inheritance as the engine takes them

LibWeb: Build an unsettled style delta in one place

LibWeb: Act on a custom-property environment move in the style engine

LibWeb: Walk a style read's inheritance chain in the style engine

LibWeb: Run the passes of a style update in the style engine

LibWeb: Decide how to apply each style reaction in the style engine

LibWeb: Close the style reaction batch over inheritance in the engine

LibWeb: Share the style transaction preparation of both style updates

LibWeb: Measure the time of style update steps with one helper

LibWeb: Scan an element's inheritance chain once for both style reads

LibWeb: Open and close a style update with one scope object

LibWeb: Report an applied style reaction to the engine in one place

Compositor+LibWeb: Add a request to rasterize a display list

LibCompositing: Build and check self-contained resource transactions

LibWeb: Take screenshots into a shareable bitmap from the caller

LibGfx: Link Vulkan and Apple GPU frameworks to LibGfx, not LibCore

LibWeb: Stop linking against Skia

LibGfx: Forward-declare Skia types in VideoSurfaceImage.h

LibWeb: Remove unused includes of Skia-backed LibGfx headers

LibGfx: Remove unused Skia includes from YUVData.cpp

LibGfx: Remove unused Path::intersect() and Path::offset()

LibGfx: Remove the unused vector image frame API

LibWeb: Restore the boundary row for spans of UTF-16 code units

LibWeb: Intern the HTML namespace as the FlyString it is

LibWeb: Hand the style engine CSS animation names as FlyStrings

LibWeb: Make ElementDeclarationKind the style engine's own enum

LibWeb: Remove dead and duplicated code from StyleEngineInput

LibWeb: Write repeated element deltas in StyleEngineInput once

LibWeb: Name the two element guards StyleEngineInput repeats

LibWeb: Stage style input deltas with the document host

LibWeb: Work out attribute name forms on the Rust side

LibWeb: Keep the atoms a document's host interned on the Rust side

LibWeb: Hand the style engine text as views of the strings that hold it

LibWeb: Remove the unused custom property name note of StyleEngine

LibWeb: Call the style engine directly where the bridge only forwarded

LibWeb: Let the style engine find which elements use a changed font

LibWeb: Generate both pseudo-class state answers from one list

LibWeb: Stop generating CSS metadata nothing reads

LibWeb: Remove StyleValue subclasses nothing reads

LibWeb: Ask Rust what an element's generated content involves

LibWeb: Remove computed style accessors nothing reads

LibWeb: Compute transform function matrices only in Rust

LibWeb: Register the computed style groups in Rust

LibWeb: Remove the write that began a transition baseline epoch

LibWeb: Read an element's transitions without copying them

LibWeb: Start CSS transitions only provisionally

LibWeb: Decide which properties to transition in Rust

LibWeb: Order a family's faces for font matching in Rust

LibWeb: Hold an easing function as the descriptor Rust evaluates

LibWeb: Set FontFace descriptors through one path

LibWeb: Evaluate media query lists through the Rust media list

LibWeb: Remove ParsedFontFace

LibWeb: Evaluate easing functions through one Rust call

LibWeb: Read only the scroll snap strictness from C++

LibWeb: Read an SVG child's transform from layout for getBBox()

LibWeb: Resolve touch-action from its computed value

LibWeb: Keep the computed backdrop-filter list for view transitions

LibWeb: Read the URLs SVG resources name straight from the style data

LibWeb: Return only the animation names a style references

LibWeb: Keep only the images of background, mask and border-image layers

LibWeb: Let only code that presents frames reach the frame sink

LibWeb: Record wheel targets again when the viewport's overflow changes

LibWeb: Find where to scroll a text position into view in Rust

LibWeb: Classify code points for text chunking in Rust

LibWeb: Remove unused layout and paint helpers

LibWeb: Turn font-variant values into OpenType features in Rust

LibWeb: Check CSSCounterStyleRule setter values in Rust

LibWeb: Resolve @counter-style rules in Rust

LibWeb: Resolve a caret position from a point in Rust

LibWeb: Paint a focused image map area's ring like any auto outline

LibWeb: Read the viewport's wheel overflow off its own box

LibWeb: Remove unused accessors from layout nodes

Meta: Compile Rust code for the CPU that C++ code is compiled for

LibWeb: Remove unused layout and paint node helpers

LibWeb: Remove unused computed style code

LibWeb: Remove unused C++ CSS value helpers

LibWeb: Remove C++ style value code that only Rust uses

Meta+LibGfx+LibWeb: Keep the Rust crate copy entry point in debug builds

LibWeb: Mark the focus events the user agent fires as trusted

LibWeb: Don’t fire focusin at an element its focus handler left

LibWeb: Resolve calc() leaves from element facts in Rust

LibWeb: Resolve relative colors for getComputedStyle() in Rust

LibWeb: Absolutize every style value in Rust

LibWeb: Stop hiding dead Rust code behind allow(dead_code)

LibWeb: Resolve a box's margins, borders and padding through one helper

LibWeb: Clear a document host's callbacks in one call

LibWeb: Let define_id! give interned identities their InternIdentity

LibWeb: Remove the compositor context handle's video sink forwarders

LibWeb: Stop exporting Rust functions that only Rust calls

LibWeb: Define shared CSS value codes and generated tables once

LibWeb: Keep the style engine's counters in its retained state

LibWeb: Bump style engine counters through shared references

LibWeb: Remove style FFI counters that nothing reads

LibWeb: Take the document host by reference across the Rust FFI

LibWeb: Build stage thread flights through two constructors

LibWeb: Keep the run inside each formatting context

LibWeb: Let rustc find dead code in the LibWeb Rust crate

LibWeb: Remove enum variants that nothing produces

LibWeb: Compile test-only style engine helpers only in tests

LibWeb: Remove unused Rust CSS types and selector fields

LibWeb: Pass the longhand driver its inputs by reference

LibWeb: Assert that the retained style state is Sync directly

LibWeb: Stop guarding layout tree builder steps against panics

LibWeb+LibGfx: Remove unused scrollbar and gradient helpers

LibWeb: Remove the visual context's mask owner list

LibWeb: Remove unused calculation node builders

LibWeb: Remove unused render state and style engine FFI entries

Meta: Lint the LibJS headers that LibJS's users may include

Meta/ClangPlugins: Reject C++ subclasses of engine objects outside LibJS

LibJS+LibWeb: Remove LibWeb predicates from JS::Object

LibJS+LibWeb+WebContent: Read a frame's source and name through LibJS

LibWeb: Serialize maps and sets without Map and Set internals

Tests/LibWeb: Create test typed arrays through create_from_slots

LibWeb: Make WebAssembly module records host modules

LibJS+LibWeb: Make wasm errors ordinary errors with their own prototypes

LibWeb: Make exported wasm functions host functions

WebContent: Make console environment extensions a host object

LibWeb: Make async iterators host objects with companion cells

LibWeb: Make pair iterators host objects with companion cells

LibWeb: Make ObservableArray a host array with a companion cell

LibJS+LibWeb: Let interface objects share their host class allocators

LibWeb: Make interface constructors host functions

LibWeb: Make interface prototype objects host objects

LibWeb: Create wrappers as host objects without C++ wrapper classes

LibWeb: Drive Location and cross-origin maps through host objects

LibWeb: Make Window's named properties object a host object

LibWeb: Make the WindowProxy a host object with a companion cell

LibWeb: Drive platform objects through host class hooks

LibJS: Convert complete data descriptors from host hooks directly

LibWeb: Build platform objects on host objects

LibJS+LibWeb: Iterate maplike/setlike entries without Map/Set internals

LibWeb: Make iterator prototypes ordinary objects

LibWeb: Make IDL namespaces ordinary objects

LibWeb: Create legacy factory functions through InterfaceObjectMetadata

LibWeb: Create all interface prototypes through InterfacePrototypeObject

LibJS+LibWeb: Move off-thread script compilation behind a LibJS API

LibJS+LibWeb: Expose breakpoint positions through a LibJS API

LibJS+LibWeb: Compile dynamic functions through a LibJS API

LibJS+LibWeb: Hand promise jobs to the host as an opaque PromiseJob

LibJS+LibWeb: Store job callback custom data as a GC cell

LibJS+LibWeb: Store GraphLoadingState host-defined data as a GC cell

LibJS+LibWeb: Store a script's host-defined data as a GC cell

LibJS+LibWeb: Store a realm's host-defined data as a GC cell

LibJS+LibWeb: Keep DOMException's error data in an ErrorDataCell

LibWeb: Read import map keys through [[OwnPropertyKeys]]

LibJS+LibWeb: Add ordinary internal methods and use them from bindings

LibJS+LibWeb: Recognize DataViews and name typed arrays without RTTI

LibJS+LibWeb: Use public API for wasm BigInts and module environments

LibWeb: Create stream read results with create_iterator_result_object

LibJS+LibWeb: Create deserialized typed arrays through LibJS

LibJS: Add host functions, host arrays and host modules

LibJS: Add host objects driven by C host class tables

LibGC: Share the cell allocation protocol with untyped allocations

LibWeb: Declare the style engine boundary in a Rust macro table

LibWeb+LibCompositing: Keep AK::Optional out of extern "C" signatures

LibWeb: Build the layout tree through one mutable arena borrow

LibWeb: Free and clear layout rows through a mutable arena borrow

LibWeb: Remove the unexpected fragmented inline commit message

LibWeb: Drop the arena's DOM backing forwarders

LibWeb: Name the SVG resource box kinds in one place

LibWeb: Read each painted node's row once in tree walks

LibWeb: Remove unused painting recorder and border helpers

LibWeb: Stop copying child lists in table layout walks

LibWeb: Walk the rest of layout's child lists with iterators

LibWeb: Find an SVG box's first child of a kind with find()

LibWeb: Walk a layout node's children with an iterator

LibWeb: Walk a painted node's children with an iterator

LibWeb: Ask a painted row whether it is out of flow or positioned

LibWeb: Read a live layout node's facts through one row

LibWeb: Remove the layout update flag ancestor visit counter

LibWeb: Remove a fragment cache epoch bump forwarder

LibWeb: Make the layout row construction facts test-only

LibWeb: Remove the fragment builder's placed box set

LibWeb: Remove the inline formatting context type

LibWeb: Let painting use layout's SVG box kind predicates

LibWeb: Remove unused Layout::Node accessors

LibWeb: Remove four unused optional FFI structs

LibWeb: Remove the layout update timing trace

LibWeb: Classify layout node kinds in one place

LibWeb: Remove the layout read scope checks

LibWeb: Remove layout changes that no host write queues

LibWeb: Give the formatting context run cache one mode

LibWeb: Trust the container effects flag after off-thread work ends

LibWeb: Read an element's layout style without waiting on other styles

LibWeb: Only label layout trace boxes after a layout trace has begun

LibWeb: Answer focus()'s layout and style queries on the main thread

LibJS: Only take the DirectGetter fast path for platform objects

Meta: Regenerate LibWeb bindings when any generator module changes

LibWeb: Keep only the style finalization the browser runs

LibWeb: Drop the memory tier and category names nothing charges

LibWeb: Let the retained answer dispatch say a traversal reuses answers

LibWeb: Write style rules into the engine with typed ids

LibWeb: Fold the style writes kept apart for replay

LibWeb: Move an unparked random base row into the engine whole

LibWeb: Delete style memory reports nothing reads

LibWeb: Delete style engine methods and inputs nothing reads

LibWeb: Drop the document device class nothing reads

LibWeb: Drop what style replay left behind

LibWeb: Delete the longhand drive FFI types nothing uses

LibWeb: Delete the var() reads the host never tells the style engine

LibWeb: Delete style engine record and replay

LibWebView+ImageDecoder: Give each renderer an image decoder of its own

LibImageDecoderClient: Refuse malformed replies instead of crashing

ImageDecoder: Disconnect clients that initialize a transport needlessly

LibIPC: Refuse anonymous buffers that claim more than they hold

LibSandbox: Only let helpers pair sockets in the UNIX domain

LibWeb: Own each document's render state on a StyleLayout thread

LibGC: Let a thread forbid itself heap access

LibWeb: Write a host's changes to its render state where the host is

LibWeb: Let the compiler check that a render state may cross threads

LibWeb: Answer a host's questions about its render state where it is

LibWeb: Keep where a render state's arena and engine are on its host

LibWeb: Prepare a document for rendering only when it has work to do

LibWeb: Remove stale spec note from timer initialization steps

LibWeb: Check a string timer handler against Trusted Types

LibWeb: Delete the Rust side of the C++ longhand computation

LibWeb: Delete the host hooks of the custom property resolver

LibWeb: Remove the host's container query evaluation

LibWeb: Delete the host style code the C++ computation left behind

LibWeb: Delete the C++ style computation

LibWeb: Read the remaining styles without the C++ style computation

LibWeb: Stop computing pseudo-element styles in C++ from Element

LibWeb: Answer a row the engine did not settle from its record demand

LibWeb: Take what an engine environment hands down from the engine

LibWeb: Identify an inline pending shorthand from its expanded longhands

LibWeb: Reject a url() an attr-tainted value reaches in the style engine

LibWeb: Drive a record under its element's sampled custom properties

LibWeb: Resolve first records over current custom environments

LibWeb: Answer boxless reads of every supported pseudo-element kind

LibWeb: Let the style engine substitute attr() in a shorthand

LibWeb: Restyle form control shadow trees only when appearance flips

LibWeb: Ask the style engine for a row's record before C++ computes it

LibWeb: Install an engine record on an element display:none unstyled

LibWeb: Install a targeted record demand's answer like a flush row's

LibWeb: Keep a record that substitutes element-relative values its own

LibWeb: Decide a pseudo-element's container verdicts after its element

LibWeb: Stop refusing a record for the answer the node had last time

LibWeb: Retry a row after its ancestors in every namespace and scope

LibWeb: Drive a retried row in full where its flush would have

LibWeb: Transform a transition step's values like a sample's

LibWeb: Settle a row that owes a transition step over its inheritors

LibWeb: Decide a transition against an animating ancestor's base value

LibWeb: Find the @keyframes of a sheet several scopes adopt

LibWeb: Plan the animations of a reverted animation-name in the engine

LibWeb: Restyle an element-backed pseudo-element when host rules flip

LibWeb: Wait for a moving container instead of refusing gated rules

LibWeb: Drive a record in full when its winners stand for no reason

LibWeb: Note the attributes an @function parameter default reads

LibWeb: Resolve tree-counting functions in a style() query value

LibWeb: Share engine records of counter-style consumers within a scope

LibWeb: Let a slotted element wait for a slot later in the style flush

LibWeb: Read a style container settled in the same flush as installed

LibWeb: Answer a row in a display:none subtree as hidden

LibWeb: Register the style groups when a style engine is created

LibWeb: Let the style engine answer reads of every pseudo-element kind

LibWeb: Answer the pseudo-element settle wherever the engine can

LibWeb: Name each kind of record demand the style engine answers

LibWeb: Answer a read of a ::backdrop outside the top layer

LibWeb: Match a style read's element over the facts its selectors reach

LibWeb: Settle pseudo-elements that run CSS animations in the engine

LibWeb: Substitute in the style engine's record of a detached element

LibWeb: Answer a read of a boxless pseudo-element with its environment

LibWeb: Let a pseudo-element's transition declarations reach the engine

LibWeb: Settle the pseudo-elements of a host pseudo-element's element

LibWeb: Leave unread attributes out of what attr() substitutes from

LibWeb: Drive the pseudo-elements of a display:none element

LibWeb: Substitute under an element's sampled custom properties

LibWeb: Delete the declaration completeness flag from the style engine

LibWeb: Weigh a cross-scope match at its element's own context

LibWeb: Find a shadow host's :host rules in its own shadow tree

LibWeb: Resolve scoped @font-feature-values in the style engine

LibWeb: Publish element declarations with their written values

LibWeb: Compute registered custom properties that read past lengths

LibWeb: Compute non-inheriting registered custom properties in engine

Tests: Drop compositor serialization round trip unit tests

Tests: Drop compositor snap scroll unit tests that test-web covers

Tests: Drop compositor wheel latch unit tests that test-web covers

Tests: Drop the scroll chaining unit test that test-web covers

Tests: Drop the unreachable wheel scroll admission branches test

Tests: Drop the shared display list mapping lifetime test

Tests: Drop redundant scroll state unit tests

Tests: Drop display list run tests that only checked the test helper

Tests: Drop the snap metadata unit test that test-web covers

Tests: Remove the async scrolling scrollbar metadata unit tests

Tests: Remove the scroll snap selection unit tests

Meta: Account for every static and thread_local in libweb_rust

LibWeb: Let the compiler check what a layout arena shares across threads

LibWeb: Publish compositor animations through a paint pass

LibWeb: Resolve SVG paint resources between two paint passes

LibWeb: Run paint preparation as typed passes over the render state

LibWeb: Run each layout stage as a job over the render state

LibWeb: Run a style transaction as one job over the render state

LibWeb: Ask the render state the reads tests and devtools make

LibWeb: Generate the style engine's reads as style questions

LibWeb: Ask the style engine the reads the host's style code makes

LibWeb: Ask the render state the text reads that answer script

LibWeb: Ask the render state the geometry reads that answer script

LibWeb: Ask a document's render state typed questions

LibWeb: Resolve hit tests and caret positions from published rows

LibWeb: Answer scroll limits and wheel targets from published rows

LibWeb: Read a node's bound row and row facts from published rows

LibWeb: Read the rows a layout shell asks about from published rows

LibWeb: Publish a document's layout rows as an immutable snapshot

LibWeb: Send the hand-written style engine writes as style changes

LibWeb: Generate the style engine's writes as style changes

LibWeb: Keep a document's style engine in its render state

LibWeb: Send form control and container paint facts as paint changes

LibWeb: Send scroll offsets and selection as paint changes

LibWeb: Pay for a layout write the host needs before it goes on

LibWeb: Send layout facts and SVG attribute facts as layout changes

LibWeb: Queue layout marks for a document's render state as changes

LibWeb: Mint style node identities on the main thread

LibWeb: Crash the process when a waited render message panics

test-web: Let a test expect its WebContent process to crash

LibWeb: Make every wait for a document's render state spend a token

LibWeb: Keep a document's recording state beside its host

LibWeb: Hold a document's host tables in a DocumentHost

LibWeb: Name each document's render state by a document id

LibWeb: Publish a display list recording without reading the arena

LibWeb: Record a display list from its published frame alone

LibWeb: Share paint fact tables with a frame through Arc

LibWeb: Split a text node's rendered text from its layout caches

LibWeb: Publish paint damage and stacking contexts with the frame

LibWeb: Record the layout tree's shape from a published column

LibWeb: Write the layout tree's painted fields through a shape writer

LibWeb: Record from published paintable rows

LibWeb: Store paintable rows, links and side data in CowColumns

LibWeb: Compare paintable rows, links and side data by value

LibWeb: Keep the side data painting reads apart from layout's

LibWeb: Add copy-on-write columns with shared snapshots

LibWeb: Keep the display list recorder's state apart from PaintState

LibWeb: Let the display list recording read only through PaintRead

LibWeb: Stop writing SVG filter bounds while recording resource content

Tests/LibWeb: Resize a filtered SVG mask child after the first frame

LibWeb: Measure scrollable overflow before painting reads it

LibWeb: Read the shared paint queries through PaintRead

LibWeb: Name the paint side's reads of a document in a PaintRead trait

LibWeb: Hand C++ the identity or slot of a layout row, not its shell

LibWeb: Attach a tree build's image resources after layout

LibWeb: Publish the document's top layer to the style mirror

LibWeb: Apply what a tree build owes the host after the walk

LibWeb: Make a layout row's layout node only when C++ asks for it

LibWeb: Hand the document the scroll containers a build made

LibWeb: Note content-visibility:auto boxes in the arena at the build

LibWeb: Derive selection paint facts from the ::selection record

LibWeb: Publish table spans by identity

LibWeb: Read the box presence bit where DOM code only asks for a box

LibWeb: Settle scroll offset clamps after the overflow pass

LibWeb: Hold scroll offsets by identity in the layout arena

Tests/LibWeb: Read scroll offsets after rebuilding a scrolled subtree

LibWeb: Publish the visual viewport before painting

LibWeb: Publish whether a node sits in the focused text control

LibWeb: Stamp a node's unique id onto its layout rows

LibWeb: Publish a node's DOM paint facts by identity

LibWeb: Stamp pseudo-element boxes, markers and generated content

LibWeb: Stamp a first letter's rows and pseudo-element box bindings

LibWeb: Stamp an element's principal box out of its published style

LibWeb: Stamp text and viewport rows in the tree build

LibWeb: Pin a removed node's box style records by identity

LibWeb: Ask the host for a style only where the walk found none

LibWeb: Pin the tree build's style records in the arena

LibWeb: Derive the wheel event handler state where nodes are inserted

LibWeb: Clear stale layout nodes and top layer subtrees in the arena

LibWeb: Prepare detached layout subtrees in the arena

LibWeb: Keep a layout node's style pin in the arena

LibWeb: Keep a layout box's image provider and observers by slot

LibWeb: Hold a layout row's style payloads as a shared handle

LibWeb: Mint the main thread token only in entry modules

LibWeb: Gate the layout shell factory behind the main thread token

LibWeb: Keep host callback tables beside the layout arena

LibWeb: Require a main thread token for Rust host callbacks

LibWeb: Take the host callback table away from the layout pass

LibWeb: Find the root background source in the style mirror

LibWeb: Decide viewport propagation from published styles

Tests/LibWeb: Propagate viewport and canvas styles from the body

LibWeb: Remove the C++ natural size code of layout boxes

LibWeb: Publish generated image and object SVG document sizes

LibWeb+WebContent: Lay out hosted documents before dumping layout

LibWeb: Negotiate an SVG root's natural size in layout

LibWeb: Publish image and SVG image natural sizes as replaced inputs

Tests/LibWeb: Replace images and content images after first layout

LibWeb: Publish form control and video sizes as replaced inputs

Tests/LibWeb: Resize form controls and canvases after first layout

LibWeb: Publish an element's box kind in the style mirror

LibWeb: Ask an element which box it wants instead of building it

LibWeb: Read a text node's characters from the style mirror in layout

LibWeb: Publish a text node's characters in the style mirror

LibWeb: Invalidate an element's language before publishing it

LibWeb: Publish the facts a layout row is built with

LibWeb: Answer an anchor query from the arena, not from the DOM

LibWeb: Publish anchor names to the layout arena by tree scope

Tests/LibWeb: Resolve anchor() names across shadow tree scopes

LibWeb: Compute first records that declare transitions in the engine

LibWeb: Run the transition step after a style computation installs

LibWeb: Substitute compositor keyframe values in the style engine

LibWeb: Remove the host animation overlay build

LibWeb: Compose sampled animation overlays in the style engine

LibWeb: Adjust an animated overflow axis in the animation sample

LibWeb: Inherit a parent's sampled animations in engine-computed records

Tests/LibWeb: Read a child after its parent's custom property animates

LibWeb: Tell an element's own custom-property animation from inherited

LibWeb: Resolve the style drive's font through overlay-aware helpers

LibWeb: Let the engine build the length contexts a sample resolves in

LibWeb: Sample animation effects in the style engine

LibWeb: Resolve keyframe declarations from published descriptions

LibWeb: Publish animation effect descriptions to the style engine

LibWeb: Plan the CSS animations of a first record in the engine

Tests/LibWeb: Cover first records that start CSS animations

LibWeb: Resolve an animation-name in the scope of its declaration

Tests/LibWeb: Count C++ work for animation names in shadow scopes

LibWeb: Plan the CSS animations of an engine-settled record

Tests/LibWeb: Count C++ work for animations a restyle starts

LibWeb: Publish the definition each CSS animation last had applied

LibWeb: Decide in the style engine if display:none stops an animation

LibWeb: Resolve animation keyframes from a published table

Tests/LibWeb: Cover @keyframes of a shadow root adopted elsewhere

LibWeb: Settle anchor-name and list-style-type deltas in the engine

LibWeb: Compute image and counter content in style engine records

Tests/LibWeb: Count C++ computations of content and anchor-name changes

LibWeb: Assert the value shapes the style drive's font phase leaves

LibWeb: Compute any value whose inputs the style drive holds

LibWeb: Resolve container units in style engine records

Tests/LibWeb: Add container unit record tests

LibWeb: Take an unresolvable substitution as invalid in the style engine

LibWeb: Compute random-valued records in the style engine

LibWeb: Share a dashed-ident random() base across elements

LibWeb: Keep random base values in the style engine

LibWeb: Compute registered custom properties in style engine records

LibWeb: Finalize custom properties in Rust on both style paths

LibWeb: Resolve custom functions in style engine records

LibWeb: Publish @function definitions to the style engine

LibWeb: Resolve env() and mixed substitutions in the style engine

LibWeb: Resolve if() in style engine records

LibWeb: Resolve inherit() in style engine records

LibWeb: Answer @container style() conditions in the style engine

LibWeb: Evaluate substitution style queries without calling into C++

Tests/LibWeb: Count C++ computations of substitution-source readers

LibWeb: Compare a boolean style() feature against the initial value

LibGfx: Compare Unicode ranges in FontCascadeList::equals

LibWeb: Carry every font feature in the style engine's font request

Tests/LibWeb: Count font refusals and C++ work for list markers

LibWeb: Hold the document's style inputs as a plain value in the engine

Meta: Reject mutable statics in Rust crates other crates link

LibGfx+LibCompositing: Keep the Rust crates' process state in C++

LibGfx: Serve system font fallback from a process-wide memo

LibWeb: Share the stylesheet program pools across threads

LibWeb: Share the style dispatch and selector pools across threads

LibWeb: Share the layout arena's cached rows through Arc

LibWeb+LibCompositing: Count visual context tree references atomically

LibWeb: Share committed fragments and hit-test items through Arc

LibGfx: Count font, path, image frame and glyph handles atomically

LibGfx: Publish a path's lazily built SkPath with a compare-and-swap

LibWeb: Name devtools flex items by style node, not by a DOM lookup

LibSandbox: Allow macOS network helpers to verify TLS certificates

LibWeb: Publish image map area shapes on the image's paintable row

Tests/LibWeb: Hit image map areas after area, map and usemap changes

LibWeb: Answer an SVG resource box's survival from the style mirror

LibWeb: Resolve SVG resources in the tree build by identity

LibWeb: Lay out text on a path in layout

LibWeb: Lay out SVG text in layout

LibGfx: Build a path from positioned glyph runs

LibWeb: Build SVG shape geometry in layout

LibWeb: Compute an SVG box's derived values and image size in layout

LibWeb: Publish an SVG element's parsed attributes to layout

Tests/LibWeb: Update a pattern's template attributes after first paint

LibWeb: Index the elements an id names in the style mirror

LibWeb: Name the node a tree builder callback is about by identity

LibWeb: Stop passing a pseudo-element's boxes through a C++ frame

LibWeb: Delete the C++ generated content walk

LibWeb: Resolve generated content in the layout tree build

LibWeb: Compare generated content's counter styles in the layout arena

LibWeb: Resolve CSS counters sets in the layout tree build

LibWeb: Invalidate only counter style scopes that read the changed one

LibWeb: Generate counter representations in Rust per tree scope

LibWeb: Ask Rust whether a marker's text depends on the counter value

LibWeb: Port the counter style algorithms to Rust

LibWeb: Stop passing the tree build's nodes through C++ frames

LibWeb: Stop passing the tree build's boxes through a C++ frame

LibWeb: Detach a top layer element's boxes by identity

LibWeb: Walk a stale layout subtree by identity

LibWeb: Retire the principal node entry facts callback

LibWeb: Walk the flat tree by identity during layout tree construction

LibWeb: Move the pseudo-element in-place update test to the tree build

LibWeb: Move the child-list insertion reuse test into the tree build

LibWeb: Name tree build nodes by identity where the arena knows them

LibWeb: Keep layout tree update marks in the layout arena by identity

LibWeb: Read a text node's layout facts from the style mirror

LibWeb: Read element box facts from the style mirror in tree build

LibWeb: Record SVG element types and top layer state as style facts

LibWeb: Publish slots' assigned node lists to the style mirror

LibWeb: Name the document in the style mirror

LibWeb: Keep the DOM child sequence, text included, in the style mirror

LibWeb: Report SVG resource references as commit messages

LibWeb: Report top layer zone rebuilds as commit messages

LibWeb: Report layout tree rebuild requests as commit messages

LibWeb: Report an unexpected fragmented inline as a commit message

LibWeb: Report committed navigable container viewports as messages

LibWeb: Report container query size changes as commit messages

LibWeb: Journal the layout half of layout tree update marks

LibWeb: Collect paint cache invalidations in the invalidation journal

LibWeb: Collect image and video paint facts in the invalidation journal

LibWeb: Journal canvas and form control paint facts

LibWeb: Journal the DOM paint facts of elements

LibWeb: Collect repaint marks in the invalidation journal

LibWeb: Share the frame request of a document's pending repaint

Tests/LibWeb: Observe an intersection scrolled into view from a timer

LibWeb: Collect layout marks in a per-document invalidation journal

LibWeb: Let NodeIdentity key hash tables

LibWeb: Decide Fetch Metadata headers by the request’s current URL

LibWeb: Replay an entry’s initiator when fetching it again

LibWeb: Send “low-entropy” User-Agent client hints by default

LibWeb+LibWebView+WebContent: Send Sec-Fetch-Site:none for UI loads

LibWeb+LibWebCommon+LibWebView: Record who chose a navigation’s URL

LibWeb+LibWebView+WebContent: Reload interrupted loads from their source

LibWeb+LibWebView+UI: Open a page’s links in new tabs from the page

LibWeb: Take a cross-process fetch client’s referrer from its page

LibWebView: Open a headless view’s new tabs in views of its own

LibWeb: Honor rel=noreferrer when following a hyperlink

LibWeb+LibWebView: Refresh the browser versions we report

LibWeb: Stop rooting caret nodes from the hit test display list

LibWeb: Carry node identities in caret positions

Tests/LibWeb: Walk a caret through inline, bidi and shadow content

LibWeb: Walk from a hit to its event target by identity

LibWeb: Carry the hit node's identity in hit test results

LibWeb: Add NodeIdentity, a name for a DOM node that is not a pointer

LibWeb: Stop keeping DOM nodes alive from the layout node arena

LibWeb: Chain the layout nodes built for one DOM node into a ring

LibWeb: Keep whether a node has a box as bits on the node

LibWeb: Hand layout nodes to the DOM-reading dump and text hooks

LibWeb: Find element boxes in the arena during tree build

LibWeb: Find pseudo-element boxes in the arena during tree build

LibWeb: Derive a layout node's DOM-backedness from its own facts

LibWeb: Read a pseudo-element's box from the layout node arena

LibWeb: Bind pseudo-element boxes to their generators by style node

LibWeb: Reuse a principal box by the layout node its node entered with

LibWeb: Bind layout nodes to their DOM nodes by style node

LibWeb: Resolve a layout node's DOM node through its style node

LibWeb: Update the layout tree for a removal before retiring its IDs

LibWeb: Record text nodes' StyleNodeIDs on layout rows

LibWeb: Give text nodes and shadow roots entries in the style node table

LibWeb: Give style node IDs a kind bit with per-kind indices

LibWeb: Record each layout row's style node in the arena

LibWeb: Drop the document's raw pointer to its layout root

LibWeb: Let the arena answer whether layout is up to date

LibWeb: Keep Document's layout node lists as arena slot IDs

LibCompositing: Align display list commands to 8 bytes

Meta: Suppress TSan reports hidden by uninstrumented locks

LibGC: Reserve a smaller heap region under ThreadSanitizer

AK: Use the system allocator under ThreadSanitizer

Meta: Add a ThreadSanitizer build preset

LibWeb: Skip the per-node animation flush when nothing is throttled

LibWeb: Record a frame when an animation stops being pending

Tests/LibWeb: Add test for handing an animation with constant output off

LibWeb: Re-time a scroll timeline when only its axis changes

LibWeb: Describe an animation's timeline instead of creating one

LibWeb+LibWebView+WebContent: Share window environment ids with the UI

LibWeb+LibWebCommon: Give an environment's id a type of its own

LibWeb: Don't make a stand-in's document an initial about:blank

LibWeb: Keep a WebDriver node id on its node

LibWebView: Keep a sandboxed file origin's type in a session snapshot

LibWeb: Report Web Storage changes to the browser process again

LibWeb: Give an initial about:blank its embedder's top-level origin

LibWeb: Ask an arriving element's inline style block if it is empty

LibWeb: Ask an inline style block whether it is empty without its views

LibWeb: Share the default grid group for any all-initial grid

LibWeb: Publish an element's cascade winners from reused buffers

LibWeb: Search prefix step members from where the last search stopped

LibWeb: Answer that no rule is container-gated without reading the rule

LibWeb: Drop a prefix relation that still holds a departed node

LibWeb: Drop the prefix relation a rootless flush moves the tree under

LibWeb: Give compacted prefix states a new arena identity

LibWeb: Give the SVG presentation accessors the layout row they read

LibDNS: Add a DNSSEC validator

LibDNS: Add canonical form and name ordering helpers

LibDNS: Parse and serialize NSEC, NSEC3, NSEC3PARAM and TLSA records

LibDNS: Make Options::set_is_question set the QR bit the right way round

LibDNS: Put the DNSKEY flag bits where RFC 4034 defines them

LibDNS: Never block the event loop on the resolver socket

LibCore: Report socket errors as read and write readiness

LibDNS: Keep the validation policy on the pending lookup

LibDNS: Give every caller that joins a pending lookup its own promise

RequestServer: Refuse hosts that curl's resolve list would misinterpret

RequestServer: Hand curl the parsed AIA URL, not the certificate's bytes

RequestServer: Fail requests for URLs without a host instead of crashing

RequestServer: Validate DNSSEC for WebSocket and AIA lookups too

LibDNS: Age validated records from when they were received

LibDNS: Only accept answer records that respond to the question

LibDNS: Bound the cache and expire entries lazily

LibDNS: Actually retransmit repeated lookups and clean up failed sends

LibDNS: Drop the cache and pending lookups in reset_connection

LibDNS: Special-case .onion and .local names in lookup()

LibDNS+RequestServer: Only use the system resolver when no server is set

LibDNS: Validate domain names before using them

LibCrypto: Reject invalid RSA public keys before verifying signatures

LibDNS: Check RRSIG validity times and clamp validated TTLs

LibDNS: Make DomainName::to_canonical_string return a ByteString

LibDNS: Expire TTL-zero records immediately instead of never

LibDNS: Only verify RRSIGs with zone keys using protocol 3

LibDNS: Decode RSA DNSKEY components per RFC 3110 and validate the key

LibDNS: Fix leftover-RDATA check in ResourceRecord::from_raw()

LibJS: Verify compile-time binding locations on request

LibWeb+LibWebView+WebContent: Highlight view-source in WebContent

LibWeb+LibWebView: Move renderer-side compositor glue into LibWeb

LibWebSocket: Reject oversized frame lengths

MediaServer+LibWeb: Decode audio data for WebAudio in the MediaServer

MediaServer+LibMediaClient+LibWeb: Play media through the MediaServer

LibMedia: Let a host process serve PlaybackManager to another process

LibMedia: Encode the types a playback session reports over IPC

MediaServer+LibMediaClient: Add the media server process scaffolding

LibSandbox+Services: Allow the PulseAudio file operations explicitly

LibMedia: Badge PlaybackManager's video edge registry

LibWeb+LibMedia: Report all media errors through a single callback

LibMedia: Explicitly start the audio sink with the PlaybackManager

LibMedia: Skip audio sink sleeping if a wake lands after a status query

LibMedia: Wait for in-flight wake dispatches when replacing a handler

LibMedia+LibWeb: Run SourceBufferProcessor mutations as queued commands

LibWeb+LibMedia: Move SourceBufferProcessor to LibMedia

LibWeb: Don't use Bindings::AppendMode in SourceBufferProcessor

LibMedia+LibWeb+Tests: Allow incremental streams to stop fetches

LibWeb: Reset media fetch offset to zero when servers return 200

LibMedia: Ignore EOS errors returned by recieve_coded_data()

LibMedia+Tests: Loudly ignore data appended past a closed stream's EOS

LibWeb: Collapse BlockContainer into Box

Compositor: Stop linking LibWebView

LibCompositing: Move the paused debugger overlay geometry here

LibCompositing: Add the Rust crate the compositor shares with WebContent

LibWeb: Re-home the Rust items shared by recording and playback

LibWeb: Move the compositor-shared forward declarations to a header

LibWeb: Stop including the CSS enum header from the resource storage

LibWeb: Evaluate the smooth scroll easing without CSS easing functions

LibWeb: Stop depending on CSS enums in the shared scroll snap code

LibWeb: Split DragEvent and QueuedInputEvent out of InputEvent.h

LibWeb: Drop the stale LibGC include from the WebGL types header

LibWeb: Take the request in navigate to a javascript: URL

LibWeb: Align frame connection steps with iframe

LibWeb: Get an XML encoding when prescanning a byte stream fails

LibWeb: Build compositor animations in Rust

LibWeb+Compositor: Sample compositor animations in Rust

LibWeb: Record the scrollbars of nested scrollers for the compositor

LibWeb+Compositor: Stop naming compositor scrollbars after the viewport

LibWeb: Evaluate the approved javascript URL

LibWeb: Don’t run a parser-blocking script while a script is executing

UI: Run the macOS helpers with the hardened runtime

LibSandbox: Only let macOS renderers map JIT memory

LibSandbox: Narrow the network access of macOS helpers

Services: Stop guessing a build directory in macOS helper sandboxes

Services: Stop giving WebContent the profile config directory

Services: Stop granting the Darwin user cache root on macOS

LibSandbox: Stop Seatbelt from inferring syscalls on macOS

LibSandbox: Only open IOSurfaces to the macOS helpers that draw

LibSandbox: Deny IOKit properties and NVRAM to macOS helpers

LibSandbox: Stop granting preference reads to macOS helpers

LibSandbox: Stop granting /dev/dtracehelper to macOS helpers

LibSandbox: Hide host identity and system state from macOS helpers

LibSandbox: Limit metadata and existence checks to granted paths

LibSandbox: Only allow file locks on writable paths on macOS

LibSandbox: Only allow harmless fcntl commands on macOS

LibSandbox: Only allow private shared memory objects on macOS

LibSandbox: Stop granting all system operations on macOS

LibSandbox: Only allow reading known sysctls on macOS

LibSandbox: Only let macOS helpers inspect their own process

LibSandbox: Only allow Mach lookups of known services on macOS

LibSandbox: Pass the macOS sandbox configuration as a struct

AK: Allocate ref-counted objects and AK heap objects with kmalloc

LibCrypto: Reject constructed DER primitive values

LibWeb: Restrict script resource attribute namespaces

LibWeb: Allow hit testing to invalidate painting state

LibWeb: Intern selector names while parsing on workers

AK: Allow Rust UTF-16 string owners to cross threads

LibWeb: Keep the layout update's own flags on the arena

LibWeb: Run the layout update loop in Rust

LibWeb: Keep the layout tree build result in Rust

LibWeb: Register the layout pass host callbacks once per arena

LibJS: Remove dead code left over from the Rust interpreter work

LibWeb: Remove three dead computed values methods

LibWeb: Remove dead computed value types and initial values

LibWeb: Diff display list damage by run instead of by command

LibWeb: Fill per-node visual context values without a dependency order

LibXML: Apply the reserved-binding rules to DTD-defaulted namespaces

LibXML: Reject DTD-defaulted names that aren’t qualified names

LibXML: Share one report-and-stop path for adapter-detected errors

LibDevTools: Reject overflowing packet lengths

LibWeb: Ignore namespaced form action attributes

LibURL+Everywhere: Store URLs as a serialization with component offsets

AK: Let StringBuilder::join iterate collections that yield values

AK: Emit "isb" instead of "yield" for the ARM64 spin-loop hint

LibJS: Retry ArrayBuffer allocation after a GC, before failing

LibJS+LibGC+LibCore: Cage SharedArrayBuffer backing stores

LibJS+LibWeb: Actually share SharedArrayBuffer memory across agents

LibJS+LibCore: Implement Atomics.wait and Atomics.notify

LibWeb: Implement computation of the “cross-origin isolated” capability

LibWeb: Borrow a computed record's values across workers

LibWeb: Share the engine's host references by invariant

LibWeb: Share the read side with Arc, and write the bounds down

LibWeb: Hold host objects the engine never follows as handles

LibWeb: Take interior mutability off the read side

LibWeb: Make the document memory ledger shareable

LibWeb: Read Tier-3 admission from a boundary snapshot

LibWeb: Make the font resolver a host round, not engine state

LibWeb: Split retained engine state from host state

LibWeb: Parse DOMParser documents in the DOMParser's realm

LibWeb: Create default toJSON() results in the current realm

Tests/LibWeb: Import cross-realm WebIDL this value tests

LibWeb: Throw in the current realm from cross-origin location setters

LibWeb: Name the published frame for what it is in the paint recorder

LibWeb: Copy SVG mask, clip, filter and gradient output between frames

LibWeb: Add scenario tests for push-only paint recording

LibWeb: Record only the root background when the canvas area grows

LibWeb: Keep the wheel-target flag across scroll registry resets

LibWeb: Remove the per-row paint capture cache

LibWeb: Record display lists from pushed paint damage

LibWeb: Assemble display lists from retained scopes and pushed damage

LibWeb: Retain the paint-order scope tree of the published frame

LibWeb: Cross-check pushed paint damage against the cache stamps

LibWeb: Collect paint damage pushed by mutation sites

LibWeb: Report stacking-context order changes from the entry tables

LibWeb: Plan CSS paint order from prepared inputs

LibWeb: Prepare CSS paint-order inputs at commit and AVC assignment

LibWeb: Keep paint caches when only the viewport position changes

LibWeb: Separate paint-order planning from command recording

LibWeb: Track the recording inputs used by subtree metadata

LibWeb: Invalidate paint when compositor content retention changes

LibWeb: Add a benchmark for incremental display list recording

LibWeb: Borrow original winner values during engine drives

LibWeb: Remove group identity lookups and publication copies

LibWeb: Borrow unchanged longhand slots during engine drives

LibWeb: Defer winner row installation through owned effects

LibWeb: Borrow before-change answers for deferred pseudo comparison

LibWeb: Defer retained answer writes to matching boundaries

LibWeb: Key prefix answer caches by non-prefix match content

LibWeb: Prepare local-fact cohorts before prefix matching

LibWeb: Defer sparse prefix convergence writes to installation

LibWeb: Isolate ordinary prefix transition scratch and effects

LibWeb: Borrow match scratch exclusively and defer witness effects

LibWeb: Share recorded command storage with C++ display lists

LibWeb: Decide style memory admission at evaluation boundaries

LibWeb: Own FFI instrumentation counters in bridge contexts

LibWeb: Pass engine instrumentation as explicit counter sinks

LibWeb: Pass matching completion mode and traversal explicitly

LibWeb: Return selector answer exactness explicitly from batch matching

LibURL: Treat an empty opaque host as an empty host in Rust

LibURL: Distinguish opaque hosts from domains across the Rust boundary

LibURL: Return failure when host parsing an empty non-opaque input

LibURL: Allow URLPattern hostname IPv6 bracket depth to go negative

LibWeb: Only clone the event listeners that an invocation can run

LibWeb: Thread resolved timing through the animation progress chain

LibWeb: Resolve an animation effect's local time once per phase query

LibWeb: Stop recomputing the per-frame animation tick decision

LibWeb: Skip empty work during display list recording

LibWeb: Fit immutable CSS style values in 64 bytes

LibWeb: Allocate CSS string headers and code units together

LibWeb: Store single prefix dispatch roots inline

LibWeb: Share selector text and compact bound identities

LibWeb: Share immutable sibling route lookup maps

LibWeb: Share common scalar CSS values across creation paths

LibWeb: Share immutable cascade projections

LibWeb: Share equal routing range columns independently

LibWeb: Store prefix feature tests in compact rows

LibWeb: Keep large simple selector payloads out of line

LibWeb: Discard construction-only dispatch chain tails

LibWeb: Canonicalize selector dispatch topology ordering

LibWeb: Trim spare capacity from finished prefix arrays

LibWeb: Store empty selector memberships in one pointer

LibWeb: Allocate computed source slots only for resource context

LibWeb: Pack native rule identity lookups into pages

LibWeb: Share compact native rule target pages

LibWeb: Compact and share selector lookup and attachment tables

LibWeb: Pack selector dispatch lookup lists

LibWeb: Store selector entry identities in compact ranges

LibWeb: Share immutable rule record pages across documents

LibWeb: Share equal pages of rule version records across documents

LibWeb: Store one prefix path directly for each selector entry

LibWeb: Key parsed stylesheet sharing by actual context dependencies

LibWeb: Retain only ancestor tables in the ancestor dispatch cache

LibWeb: Share immutable rule declaration records

LibWeb: Share and compact immutable prefix relation tables

LibWeb: Share immutable selector routing tables

LibWeb: Share equivalent selector dispatches across documents

LibWeb: Bound retained style transaction staging capacity

AK: Route Rust allocations through kmalloc

LibGC: Tag VM allocations as application-specific 2 on macOS

LibGfx: Share mapped font data with Skia

AK: Use an application-specific VM tag for mimalloc on macOS

LibWeb: Reuse dense storage for staged paint cache updates

LibWeb: Convert recording FFI inputs to typed Rust borrows

LibWeb: Separate recording scratch from persistent paint state

LibWeb: Centralize paint cache compatibility checks

LibWeb: Derive and retain layout styles in Rust

LibWeb: Invalidate overflow when Rust receives changed styles

LibWeb: Refresh scrollable overflow behind Rust geometry queries

LibWeb: Keep scrollable overflow caches in Rust-owned storage

LibWeb: Share the partial relayout entry for SVG and abspos boxes

LibWeb: Read saved abspos inputs from committed fragment links

Tests: Create proper dependency tracking for Rust/Flap tests

LibWeb: Remove unused layout arena FFI exports

LibWeb/CSS: Remove unused inline CSS helpers

LibWeb/CSS: Remove unused ComputedValues builder methods

LibWeb/CSS: Remove unused attribute token splitting helper

LibWeb/CSS: Remove unused computed style data structs

LibWeb/CSS: Remove uncalled CSS helper functions

LibWeb/CSS: Remove unused standalone media condition evaluator

LibWeb: Remove unused CSSAnimation::cancel_from_css

LibWeb/CSS: Remove unused EasingFunction::to_style_value

LibWeb/CSS: Remove dead computed style working set methods

LibWeb/CSS: Remove unused QueryValueType and CharacterTypes headers

LibWeb: Collect scroll snap geometry in Rust

LibWeb: Split scroll snap position selection from its layout geometry

LibWeb: Remove the basic shape facade

LibWeb: Remove the unused anchor-size facade

LibWeb: Remove light-dark and contrast color facades

LibWeb: Update the Rust serialization ownership test

LibWeb: Remove unused style value facades

LibWeb: Remove empty style value facades

LibWeb: Move color function equality to Rust

LibWeb: Remove duplicate color function resolution

LibWeb: Remove the selector text FFI wrapper

LibWeb: Remove the serialized text FFI wrapper

LibWeb: Move linear easing canonicalization to Rust

LibWeb: Remove unused CSS serialization helpers

LibWeb: Finish moving color-mix resolution to Rust

LibWeb: Remove unused CSS parser error type

LibWeb: Report which style changes alter the hit-test display list

LibWeb: Drop the scroll registry from the viewport recommit in Rust

LibWeb: Invalidate the scroll state where scroll offsets are stored

LibWeb: Verify skipped scroll state refreshes on request

LibWeb: Publish the scroll state snapshot from its refresh

LibWeb: Resolve sticky offsets inside the Rust scroll state refresh

LibWeb: Let the Rust scroll state own its dirty bit

LibWeb: Drop the redundant scroll state refreshes

LibGfx: Share the shaping cache with C++ text callers

LibWeb: Test repeated canvas text across drawing state changes

LibWeb: Remove the unused C++ mask compositing conversion

LibWeb: Remove the unused C++ PaintPhase enum

LibWeb: Remove unused box overflow accessors

LibWeb: Remove unused SVG paintable predicates

Meta: Compile Rust tests as part of the default build

LibWeb: Include style-replay in default builds on POSIX systems

Meta: Allow running existing binaries without building

Documentation: Add a runnable WebDriver investigation example

RequestServer: Allow mapped resource files through the Linux sandbox

Meta: Add a reader for saved test-web results

LibWeb: Share the image paint fact payloads

LibWeb: Record display lists without host callback tables

Tests: Pin repaints after SVG paint server mutations

LibWeb: Build SVG pattern paint styles from published descriptions

LibWeb: Build SVG gradient paint styles from published descriptions

LibWeb: Publish resolved SVG filters before the visual context update

LibWeb: Resolve the SVG clip area in Rust

LibWeb: Resolve the SVG masking area in Rust

LibWeb: Relayout elements referencing a mutated mask or clipPath

LibWeb: Commit the additional SVG element transform at layout

LibWeb: Commit video paint facts

LibWeb: Resolve SVG image display lists after the recording

LibWeb: Commit replaced image paint facts

LibWeb: Draw layer image frames from Rust-owned handles

LibWeb: Commit layer image paint facts

LibWeb: Push navigable container paint facts before recording

LibWeb: Commit canvas paint facts

LibWeb: Commit form control paint facts

LibWeb: Commit ::selection styles to the layout arena

LibWeb: Derive async scroll metadata from committed arena state

LibWeb: Resolve scroll node identities in the visual context update

LibWeb: Move scroll snap axis selection into Rust

LibWeb: Derive line-break caret targets from committed lines

LibWeb: Remember the forced break node that ended each line

LibWeb: Drop the recorder's paintable DOM facts callback

LibWeb: Take SVG mask and clip content units from committed layout facts

LibWeb: Stamp blocking wheel handler containment into layout node data

LibWeb: Stamp editability into layout node data

LibWeb: Publish the recording's fonts after the walk

LibWeb: Stamp DOM inertness into layout node data

LibWeb: Take the recording trace from Rust after the recording

LibWeb: Repaint form controls on indeterminate and disabled changes

LibWeb: Read local background scroll offsets from the Rust scroll state

LibWeb: Align CSS custom function evaluation with the spec

LibWeb: Include function identity in property substitution contexts

LibWeb: Use shared guarded substitution contexts

LibWeb: Rename `VarResolutionContext` to `ASFResolutionContext`

AK: Add a Rust ScopeGuard

LibTextCodec: Use the mimalloc-backed Rust allocator

LibWeb: Remove redundant Rust style bridge

LibWeb: Borrow stylesheet rule and media list views

LibWeb: Remove duplicate collection style value owners

LibWeb: Resolve easing, shapes and gradients in Rust

LibWeb: Serialize CSS values and grid results directly in Rust

LibWeb: Consume Rust rule graphs through lazy CSSOM wrappers

LibURL: Parse borrowed native ASCII and UTF-16 input

AK: Allocate Rust data without C++ forwarding calls

LibWeb: Own CSS descriptors in Rust and expose wrappers lazily

LibWeb: Own CSS declaration blocks and mutation state in Rust

LibWeb: Parse and share downloaded stylesheets on workers

LibWeb: Own thread-shareable CSS values and selectors in Rust

LibWeb: Remove the C++ formatting context type helpers

LibWeb: Port the layout tree dump to Rust

LibWeb: Drop the unused show_computed_properties layout dump option

AK: Capture Rust panic diagnostics in crash reports

LibWebView: Expose crash reports in native overlays and settings

LibWebView: Save local helper crash reports on macOS and Linux

UI/AppKit: Report every select dropdown close to WebContent

UI/Qt: Report every select dropdown close to WebContent

LibGfx: Answer single glyph advances from the Rust shaping cache

LibGfx: Fold the retained font reference into FontEntry

LibWeb: Paint text through FontHandle and delete the borrowed font views

LibWeb: Carry fonts through layout as FontHandle values

LibGfx: Add FontHandle, an owned Rust view of a Gfx::Font

LibWeb: Key the text chunk cache on an owned font cascade list handle

LibWeb: Stop pinning font cascade lists for style records

LibWeb: Make the engine's font resolver cache own its cascade lists

LibWeb: Let the font style group own its font cascade list

LibWeb: Read the font style group through FontValues

LibWeb: Resolve per-document paint facts once per display list recording

LibWeb: Decide viewport style propagation on the Rust side

LibWeb: Recompute containing blocks inside Rust tree build and layout

LibWeb: Keep the partial relayout escape bit in the layout arena

LibWeb: Reset layout flags and overflow bookkeeping inside Rust layout

LibWeb: Reuse dispatch scratch when selecting transpose waypoints

LibWeb: Reuse parent dispatch scratch during transpose analysis

LibWeb: Merge retained match survivors when materializing patches

LibWeb: Use exact iterator lengths for live interned identities

LibWeb: Read shared-style inheritance flags only on insertion

LibWeb: Recognize shared group sets in record inheritance checks

LibWeb: Reuse the environment lookup in parent inheritance checks

LibWeb: Defer routing registry setup until an input has keys

LibWeb: Build small input routing key lists inline in one pass

LibWeb: Split full posting chunks before inserting new nodes

LibWeb: Reserve once when collecting posting candidates

LibWeb: Check dash-match boundaries before comparing prefixes

LibWeb: Return cached sibling prefix answers without republishing

LibWeb: Call the sibling prefix matcher directly

LibWeb: Read sibling sequence heads only when starting a prefix

LibWeb: Keep short descendant relation walks inline

LibWeb: Skip cascade repair for removed losing declarations

LibWeb: Keep incremental cascade repair targets inline

LibWeb: Reuse rule priorities during incremental cascade repair

LibWeb: Keep cascade winner publication target lists inline

LibWeb: Keep cascade compaction pseudo targets inline

LibWeb: Avoid sorting winners just to mark retained cascade rules

LibWeb: Skip subtree membership checks for walked query candidates

LibWeb: Keep partial style rebuild group identities inline

LibWeb: Read only property IDs when computing inherited group masks

LibWeb: Skip shared winner groups when comparing property shapes

LibWeb: Reuse saved primary facts when staging element edits

LibWeb: Reuse attribute query candidate vector storage

LibWeb: Reuse matched dispatch keys in direct rule filtering

LibWeb: Skip deduplicating single-posting query candidates

LibWeb: Reuse staged part and custom-state vector storage

LibWeb: Keep the first sibling type counter inline

LibWeb: Track positional answer capacity incrementally

LibWeb: Borrow sibling type position storage once per sequence

LibWeb: Keep simple query candidate cache probes inline

LibWeb: Compare case-sensitive attribute filter values as slices

LibWeb: Compare case-sensitive selector text as slices

LibWeb: Skip cascade sorting for single dispatch candidates

LibWeb: Check written attribute names first in optimized matching

LibWeb: Reuse the reserved empty prefix result

LibWeb: Reuse reserved empty prefix set identities

LibWeb: Reject prefix attribute value mismatches before name lookup

LibWeb: Skip hashing the implicit unlayered cascade bucket

LibWeb: Skip attachment lookup for document cascade contexts

LibWeb: Avoid duplicate attribute alias dispatch probes

LibWeb: Keep the subtree collector root worklist inline

LibWeb: Bound cascade update reservations by winner group size

LibWeb: Reuse materialized winners when comparing cascade updates

LibWeb: Keep common pseudo-state copy scratch inline

LibWeb: Match written attribute names before loading aliases

LibWeb: Append empty before-state facts directly for new elements

LibWeb: Reuse the staged row borrow throughout fact edits

LibWeb: Skip fact column growth checks for existing elements

LibWeb: Append staged attributes directly to the fact payload

LibWeb: Borrow element facts while removing selector postings

LibWeb: Read resident facts directly when removing atom references

LibWeb: Borrow staged selector facts while committing them

LibWeb: Iterate staged first-child links without copying them

LibWeb: Reduce pseudo-element cascade matching overhead

LibWeb: Reuse attribute lookups when updating style facts

LibWeb: Reuse declaration block ordering during cascade resolution

LibWeb: Track selector incidence payload bytes incrementally

LibWeb: Keep single slotted and part matching scopes inline

LibWeb: Calculate rule compaction priorities only when needed

LibWeb: Keep temporary cascade state groups inline

LibWeb: Keep small multi-key selector deduplication lists inline

LibWeb: Keep single shadow part exposure hosts inline

LibWeb: Combine sibling type counts into one position vector

LibWeb: Reuse element declaration priorities during compaction

LibWeb: Keep inherited group replacement scratch inline

LibWeb: Reuse custom property cascade ordering within each block

LibWeb: Reuse stylesheet attachments when finding cascade context

LibWeb: Drain grown selector postings without a temporary vector

LibWeb: Short-circuit custom property match scans

LibWeb: Consume feature flux entries when building the reverse index

LibWeb: Skip radix sorting already ordered dirty node batches

LibWeb: Check pseudo substitution usage without collecting states

LibWeb: Avoid retaining font families on font cache hits

LibWeb: Preserve sorted cascade winners when appending ordered keys

LibWeb: Skip copying unchanged animation name sets

LibWeb: Transfer completed selector truth out of match scratch

LibWeb: Avoid materializing initial style winner deltas

LibWeb: Stop checking cascade completeness after an incomplete rule

LibWeb: Avoid allocating duplicate cascade provenance groups

LibWeb: Lower animation and canvas filter functions on the Rust side

LibWeb: Build SVG filter graphs on the Rust side

LibGfx+LibWeb: Keep Gfx::Filter as its serialized bytes

LibWeb: Resolve only the url() part of a filter list on the C++ side

LibWeb: Lower CSS filters through the shared Rust filter codec

LibGfx: Add a Rust filter graph with the serialized filter codec

LibWeb: Remove the unused C++ property invalidation classifier

LibWeb: Pass previous paintable offsets through layout commit

LibWeb: Consolidate broad style plans against retained answers

LibWeb: Append already ordered retained match answers directly

LibWeb: Resolve incidence prefix entries outside candidate loops

LibWeb: Avoid redundant selector incidence setup

LibWeb: Select current selector incidences in place

LibWeb: Scan rules once for removed selector programs

LibWeb: Store custom property environment keys in boxed slices

LibWeb: Reserve custom property results from the known name count

LibWeb: Remove duplicate priority storage from cascade contenders

LibWeb: Narrow contender scans while resolving revert chains

LibWeb: Select ordinary cascade winners without sorting contenders

LibWeb: Skip replaced group lookups during inherited style updates

LibWeb: Load winner provenance only after finding the property

LibWeb: Reject weaker cascade additions before searching updates

LibWeb: Check cascade continuation identities without loading payloads

LibWeb: Reuse retained winners during cascade property updates

LibWeb: Use pending winner priorities during cascade updates

LibWeb: Reuse matched rules across cascade property updates

LibWeb: Defer winner lookups until cascade repair needs them

LibWeb: Reuse preceding sibling parent identity lookups

LibWeb: Reuse part host list storage when updating elements

LibWeb: Resolve sole custom property candidates without grouping

LibWeb: Serialize benchmark marker names without copying them

LibWeb: Reuse custom property cascade ceiling storage

LibWeb: Drop redundant custom property candidate order indices

LibWeb: Borrow custom property values while resolving the cascade

LibWeb: Check foldable input kinds before searching arrivals

LibWeb: Find declaration changes in sorted transaction inputs

LibWeb: Merge repaired winners with requested properties linearly

LibWeb: Reuse selector operands across scope compilation levels

LibWeb: Compile selector argument lists directly to disjunctions

LibWeb: Compile single has arguments without an alternatives buffer

LibWeb: Reuse operands while compiling part selectors

LibWeb: Reuse prefix compound and step insertion lookups

LibWeb: Allocate semantic winner groups only on interning misses

LibWeb: Reuse winner merge buffers across property groups

LibWeb: Skip preorder ranking for empty selector candidates

LibWeb: Update retained witnesses through a single lookup

LibWeb: Stream declaration inventories into dispatch storage

LibWeb: Store cached attribute and language text as boxed slices

LibWeb: Flatten routing directories without sorting keys

LibWeb: Keep selector program storage slots compact

LibWeb: Reuse shared selector bucket lookups during cleanup

LibWeb: Borrow display values during pseudo-style admission

LibWeb: Skip shared group payload walks during record comparison

LibWeb: Check cheap table metadata before comparing style values

LibWeb: Skip property shape walks for identical cascade states

LibWeb: Short-circuit identical states in cascade delta iteration

LibWeb: Retain written cascade values only when needed

LibWeb: Borrow written values when checking record sharing

LibWeb: Move staged sheet orders into the rule program

LibWeb: Reuse property lists for repeated declaration edits

LibWeb: Skip count-map borrowing for empty atom pin guards

LibWeb: Reuse global atom lookups when releasing final references

LibWeb: Use sorted atom membership during sweep cleanup

LibWeb: Skip atom sweep work when nothing is reclaimable

LibWeb: Avoid allocating a span vector for a single scope

LibWeb: Compact immutable selector dispatch metadata storage

LibWeb: Build compound operands directly in program storage

LibWeb: Stream language ranges into the selector builder

LibWeb: Reuse the lookup when releasing a style record pin

LibWeb: Compact atom pin guards and reuse release lookups

LibWeb: Reuse the inheritance dependency view buffer

LibWeb: Skip discarded dependency copies when seeding a full drive

LibWeb: Avoid recopying partial-drive inheritance dependencies

LibWeb: Compact retained custom property memo values

LibWeb: Reorder selector prefix arrays in place

LibWeb: Simplify region batch cache insertion

LibWeb: Stream winning nodes into program impact regions

LibWeb: Walk child reactions without copying child lists

LibWeb: Store immutable custom property names as boxed slices

LibWeb: Collect only unreachable computed identities for reclamation

LibWeb: Deduplicate selector dispatch alternatives in place

LibWeb: Remove duplicate hashes from cascade winner groups

LibWeb: Iterate cascade property deltas without temporary lists

LibWeb: Store immutable cascade lists as boxed slices

LibWeb: Avoid an intermediate allocation for short match answers

LibWeb: Compare cascade semantics through interned winner groups

LibWeb: Avoid redundant work when replaying retained answers

LibWeb: Short-circuit active transition property checks

LibWeb: Avoid redundant retained style-value clones

LibWeb: Look up ASCII property names without UTF-16 buffers

LibWeb: Hash inheritance-dependent values without copying or sorting

LibWeb: Reuse compiled subject dispatch keys when building scopes

LibWeb: Remove the unused single-key dispatch analysis mode

LibWeb: Avoid temporary payload vectors in computed style updates

LibWeb: Borrow parent payloads when assembling computed style records

LibWeb: Move old part and custom-state vectors when replacing them

LibWeb: Avoid copying and rescanning previous animation names

LibWeb: Borrow current sheet lists for read-only operations

LibWeb: Detect sheet attachment reorders by position

LibWeb: Restore reattached sheet routes without temporary pairs

LibWeb: Iterate selector incidence candidates directly

LibWeb: Borrow selector incidence cache entries during lookup

LibWeb: Iterate staged tree relations without temporary vectors

LibWeb: Merge retained patch rule selections in place

LibWeb: Store retained patch rule identities only once

LibWeb: Capture staged program snapshots only on the first edit

LibWeb: Consume dispatch buckets when building their directory

LibWeb: Group dispatch cascade ranks with slice chunks

LibWeb: Read prefix flags directly when rebuilding dispatch indexes

LibWeb: Build ancestor dispatch shapes directly in index order

LibWeb: Forget retired atom postings without temporary keys

LibWeb: Record evicted posting keys without temporary storage

LibWeb: Check posting admission before probing existing keys

LibWeb: Take retained prefix relations with one cache lookup

LibWeb: Stream bounded child prefixes during positional routing

LibWeb: Collect sibling route candidates without temporary origins

LibWeb: Share routing site construction

LibWeb: Skip clearing sequence index pages before rewriting them

LibWeb: Simplify lazy sibling-position index initialization

LibWeb: Reuse the retained posting lookup during planning

LibWeb: Reuse stored inherited-group identities in record assignment

LibWeb: Reuse map entries when updating pseudo computed rows

LibWeb: Share computed group payload interning

LibWeb: Share fixed metadata interning between computation paths

LibWeb: Compare inherited group payloads without identity round trips

LibWeb: Build top-down walk paths directly from sibling ordinals

LibWeb: Borrow committed sheet lists when reading scope programs

LibWeb: Check sheet attachment changes without temporary scope lists

LibWeb: Collect sheet departures once when building staging deltas

LibWeb: Skip clean staged fields when collecting updates

LibWeb: Use map entries when staging program fields

LibWeb: Invalidate sheet-dependent scopes without temporary storage

LibWeb: Retire inactive scope programs without temporary storage

LibWeb: Collect old declaration properties only for the first edit

LibWeb: Reuse computed layer ranks when checking for order changes

LibWeb: Use map entries when assigning cascade layer ranks

LibWeb: Reuse the semantic declaration bucket during interning

LibWeb: Share subtree detachment between rule removal paths

LibWeb: Sort collected sheet rules by their order ranks

LibWeb: Compute selector entry properties without temporary storage

LibWeb: Simplify element-declaration winner repair preparation

LibWeb: Reuse normalized input order when collecting arriving nodes

LibWeb: Remove redundant reservation before extending match answers

LibWeb: Simplify selector-program insertion helpers

LibWeb: Remove unused counters from indexed sibling-position lookup

LibWeb: Remove unused counters from journal memory settlement

LibWeb: Remove the duplicate intern-table emptiness test helper

LibWeb: Use map entries when registering custom-property data

LibWeb: Reuse the hash map entry when inserting feature postings

LibWeb: Compare inheritance-dependent values without temporary vectors

LibWeb: Derive the default cascade order state

LibWeb: Share content hashing across style interners

LibWeb: Remove unused counters from prefix-state helpers

LibWeb: Simplify impact-region insertion and attribution

LibWeb: Remove unused counters from program memory settlement

LibWeb: Remove the unused catalog from prefix memory accounting

LibWeb: Group sorted style entries with slice chunks

LibWeb: Release match answers without temporary storage

LibWeb: Use column operations for answer lanes and winner stamps

LibWeb: Match prefix-state cache entries directly

LibWeb: Intern non-prefix match answers directly

LibWeb: Share document atom initialization

LibWeb: Share paged column allocation during insertion

LibWeb: Advance sorted merges through their remaining slices

LibWeb: Avoid repeated lookups when inserting cascade winners

LibWeb: Store cascade order labels directly

LibWeb: Derive style catalog identities from storage lengths

LibWeb: Derive specified-value pointer keys from retained values

LibWeb: Store specified-value coverage gaps directly

LibWeb: Remove the unused layer identity from priority inputs

LibWeb: Remove redundant specified-value lookup probes

LibWeb: Use scalar ranks in the Rust style engine cascade

LibWeb: Centralize stylesheet resource base URL lookup

LibWeb: Maintain selector prefix memberships across style updates

LibWeb: Preserve rule attribution without preorder coordinates

LibWeb: Exclude inactive rules from prefix match deltas

LibWeb: Retain shared computation contexts in the style engine

LibWebView: Keep crashed clients alive while notifying views

LibWeb: Reuse unchanged pseudo styles during C++ fallback

LibWeb: Avoid redundant work when propagating inherited style inputs

LibWeb: Publish substitution usage with engine-computed records

LibWeb: Share box transformation input construction in Rust

LibWeb: Separate style record driving and pseudo publication

LibWeb: Resolve custom properties and share engine-computed records

LibWeb: Settle inherited and cold records in the style engine

LibWeb: Extend engine-computed records across style reactions

LibWeb: Compute initial style records in the style engine

LibWeb: Use native text sources and ranges for first-letter processing

LibWeb: Map rendered text queries to DOM ranges in Rust

LibWeb: Refresh rendered text directly in Rust

LibWeb: Store text chunks in the rendered text snapshot

LibWeb: Own first-letter text slices in the Rust arena

LibWeb: Own rendered text cache validity in Rust

LibWeb: Build rendered text in Rust

LibWeb: Keep rendered text and offset mapping in the Rust arena

LibWeb: Scope layout borrows and make paint mutation explicit

LibWeb: Skip command capture for empty paint phases

LibWeb: Retain inherited group identities in shared style records

LibWeb: Read generated content from its retained style value

LibWeb: Size empty inline-block boxes in their parent layout run

LibWeb: Publish initial element features in node identity order

LibWeb: Walk the containing block scroll chain in Rust

LibWeb: Decide compositor animation offscreen clipping in Rust

LibWeb: Collect content-visibility: auto boxes in Rust

LibWeb: Walk the fixed-position containing block chain in Rust

LibWeb: Map Range text rects to the viewport in Rust

LibWeb: Compute the intersection observer clip chain in Rust

LibWeb: Compute Element client rects in Rust

LibWeb: Decide the getClientRects fast path in Rust

LibWeb: Make the force-dark performance numbers reproducible

LibWeb: Test that force-dark leaves the line-box overlay alone

LibWeb: Judge borders/selections against the force-dark’ened backdrop

LibWeb+LibWebView: Add a force-dark setting to about:settings

LibWeb: Teach force-dark which images to invert (and which not to)

LibWeb: Wire force-dark through the display-list recorder

LibWeb: Keep the color-scheme “only” flag a meta tag declares

LibWeb: Add the color engine for force-dark mode

LibWeb: Drive CSS filter animations from the compositor

LibWeb: Materialize anonymous layout shells on first use

LibWeb: Key layout arena liveness on the slot instead of the shell

LibWeb: Reinherit anonymous box styles through the layout arena

LibWeb: Create anonymous layout boxes in the Rust tree builder

LibWeb: Split layout slot allocation from shell binding

LibWeb: Derive anonymous box styles from a parent style record

LibWeb: Add GC tests for layout-rooted DOM nodes

LibWeb: Root layout DOM nodes from the document instead of each shell

LibWeb: Tear down the layout tree when a document is finalized

LibWeb: Pin layout style records without rooting the document

LibWeb: Resolve a layout node's document through its arena

LibWeb: Record each layout node's DOM node in the arena

LibWeb: Fold the layout node's arena slot into the node itself

LibWeb: Add layout-tree teardown tests for deep and top-layer subtrees

LibWeb: Let the layout node arena own its C++ shells

LibWeb: Stop holding layout nodes by reference outside the arena

LibWeb: Free layout subtrees from the arena in one walk

LibWeb: Hand out NodeData references inside the layout node arena

LibWeb: Stop sharing NodeData between the arena and the node shell

LibWeb: Read layout node facts from the arena instead of the shared slot

LibWeb: Route layout node writes from the shell through the arena

LibWeb: Pass layout node construction facts into the arena allocation

LibWeb: Drop the redundant slot generation from the arena allocation

LibWeb: Drop the abort_on_panic wrappers from the FFI entry points

LibWeb: Eliminate animation overlay mirrors

LibWeb: Reuse font metrics during animation sampling

LibWeb: Diff animation overlays directly in Rust

LibWeb: Use a regular map for animation update state

LibWeb: Seed animation updates from style records

LibWeb: Read display-none state from style records

LibWeb: Keep animation sampling on overlays

LibWeb: Reuse animation preparation across samples

LibWeb: Avoid cloning unrelated animation keyframe longhands

LibWeb: Hand overlay node labels to Rust as UTF-8 bytes

LibWeb: Share the CSS filter serialization between both filter hosts

LibWeb: Return the visual context update outcome as the FFI struct

LibWeb: Reuse the visual context tree inputs when recording

LibWeb: Resolve painting dump owner labels on the Rust side

LibWeb: Let Rust pick the visual context nodes an animation can target

LibWeb: Map scroll snap area rects through CSS transforms in Rust

LibWeb: Hand mask display list registrations over with the recording

LibWeb: Let the Rust image paint recorder resolve gradients itself

LibWeb: Skip selector matching for querySelectorAll("*")

LibWeb: Build static node lists from GC::RawRef vectors

LibWeb+UI: Support pasting images into editable DOM nodes

LibWebView+UI: Change return type of clipboard accessor function

LibWeb: Allow copying HTML::SelectedFile

LibWeb: Implement modulepreload processing

LibWeb: Align module script fetching with HTML

LibWeb: Keep content sync enrollment in the node arena

LibWeb: Gate container query size changes in the commit

LibWeb: Collect eager overflow measurement roots in Rust

LibWeb: Run the scrollable overflow update inside the arena

LibWeb: Classify layout tree updates through one arena call

LibWeb: Shrink the layout shell surface

LibWeb: Answer three small paintable queries from Rust

LibWeb: Retire dead style FFI exports and the ABI anchor idiom

LibWeb: Fold the duplicated visibility expression in BoxViews

LibWeb: Answer positioning and transform queries from Rust

LibWeb: Delete dead layout and painting code

LibWeb: Delete FFI exports whose C++ callers are gone

LibWeb: Keep the scrollable overflow queue in the node arena

LibWeb: Collect partial relayout boundary roots in Rust

LibWeb: Port the saved abspos replay validity check to Rust

LibWeb: Invalidate paint caches inside the paintable clear

LibWeb: Reset intrinsic size caches through the node arena

LibWeb: Reset partial relayout flags through the existing arena walk

LibWeb: Delete the unread HasBeenWrappedInTableWrapper flag

LibWeb: Port layout update marking to Rust

LibWeb: Keep partial relayout roots in the node arena

LibWeb: Port partial relayout boundary check to Rust

LibWeb: Stamp document-element identity on layout nodes

LibWeb: Store default scroll shift anchors in the Rust layout arena

LibGfx: Delete the C++ shaping cache

LibWeb: Shape inspector overlay labels through the Rust text pipeline

LibGfx: Move the shaping cache for Rust layout callers into Rust

LibGfx: Shape text for Rust callers without materializing a GlyphRun

LibWeb+LibGfx: Stop retaining a C++ GlyphRun for paintable fragments

LibWeb: Use the libgfx DrawGlyph type through layout and painting

LibWeb: Port the stacking context dump to Rust

LibWeb: Port the display list dump to Rust

LibWeb/Painting: Bound scroll-state indices by the node count

LibWeb: Record the display list from the incremental stacking contexts

LibWeb: Maintain stacking context entry tables incrementally

LibWeb: Label layout nodes in pre-order

LibWeb: Note stacking context style changes on the affected box

LibWeb: Record stacking context facts with the visual context records

LibWeb: Delete the C++ visual context tree mirror

LibWeb: Answer every visual context tree query from Rust

LibWeb: Compute display list damage in Rust

LibWeb: Drive display list replay from Rust

LibWeb: Serialize visual context trees through Rust

LibWeb: Give the C++ visual context tree a Rust-owned handle

LibWeb: Send visual context tree filter images as display list resources

LibWeb: Serialize visual context trees to bytes in Rust

LibWeb: Port the visual context tree queries to Rust

LibWeb: Create cursor bitmap visual context trees in Rust

LibWeb: Build background tile visual context trees in Rust

LibGfx: Add shared system font catalog support

LibCore: Map anonymous buffers with MappedFile on Windows

LibWeb: Truncate calculated length-percentage used values

Tests/LibWeb: Add an end-to-end AIA certificate-fetching test

Tests/RequestServer: Add unit tests for AIA certificate parsing

RequestServer: Implement AIA fetching, for sites with broken cert chains

LibCrypto+LibTLS: Add an OpenSSL_X509 wrapper class

LibGfx: Remove the C++ BSP tree superseded by the Rust port

LibWeb: Build the depth-sorted replay plan in Rust

LibWeb: Port the depth-sorted replay plan builder to Rust

LibWeb: Answer hit-test plane depth and sorting groups from Rust

LibWeb: Resolve 3D sorting contexts on the Rust visual tree

LibGfx: Port the 3D plane BSP sorting to Rust

LibWeb: Compute the accumulated 2D scale of a visual context in Rust

LibWeb: Take the visual context tree's effective clip verdict from Rust

LibWeb: Carry url() effects filters to the visual context tree as bytes

LibWeb: Stop leaking visual context node types into unrelated headers

LibGfx: Add inverse, flatten and affine extraction to the Rust matrices

LibWeb: Make Rust the sole owner of hit-test display list structure

LibWeb: Rename hit testing 'box' fields to 'paintable'

LibWeb+Tests: Add an internals function to query the last context menu

LibWeb: Compute style record invalidation in Rust

LibWeb: Read transition and inheritance values from Rust records

LibWeb: Remove duplicate style reconstruction metadata

LibWeb: Keep style drive state in Rust

LibWeb: Handle animation inheritance from Rust records

LibWeb: Record complete style transaction inputs

LibWeb: Replace inherited style groups in Rust

LibWeb: Make computed longhand tables authoritative

LibWeb: Build computed style groups in Rust

LibWeb: Read computation inputs from Rust style records

LibWeb: Compute properties, animations, and transitions in Rust

LibWeb: Build custom property stores in Rust

LibWeb: Move longhand orchestration into Rust

LibWeb: Port SVG attribute parsing to Rust

LibWeb: Port the SVG path parser to Rust

LibWeb: Delete CSS parsing code orphaned by the Rust port

LibWeb: Validate CSS rules in Rust

LibWeb: Test CSS rule structural validation

LibWeb: Evaluate static if() conditions in Rust

LibWeb: Test if() condition callback boundaries

LibWeb: Finalize CSS declarations in Rust

LibWeb: Test devtools CSS declaration metadata

LibWeb: Parse sizes attributes in Rust

LibWeb: Test sizes attribute parsing

LibWeb: Serialize CSS supports env() features correctly

LibWeb: Evaluate CSS supports features in Rust

LibWeb: Test CSS supports feature evaluation

LibWeb: Parse page selector lists directly in Rust

LibWeb: Delete precomputed SVG path plumbing

LibWeb: Resolve CSS descriptor integers in Rust

LibWeb: Test calculated counter style descriptor integers

LibWeb: Evaluate static CSS supports features in Rust

LibWeb: Resolve CSS query feature names in Rust

LibWeb: Resolve CSS property names in Rust

LibWeb: Add CSS parser FFI counter baseline

LibWeb: Count remaining CSS parser FFI callbacks

LibWeb: Resolve custom property graphs in Rust

LibWeb: Keep post-compute adjustment in Rust

LibWeb: Apply style finalization in Rust

LibWeb: Store sampled animation values in Rust

LibWeb: Compute animation keyframe longhands in Rust

LibWeb: Compute initial document longhands in Rust

LibWeb: Batch monospace font-size recascade in Rust

LibWeb: Batch style computation preflight in Rust

LibWeb: Batch style finalization in Rust

CI: Do not update the Rust toolchain with dependabot

Meta: Update Rust toolchain to 1.98.0

LibWeb: Remove PaintableKind

LibWeb: Derive paint behavior from layout nodes

LibWeb: Remove paint tree dumping

LibWeb: Fold paint overflow into layout test dumps

LibWeb: Root the display list in an isolation frame instead of a layer

LibWeb: Carry a float rect and a clip mode in ClipData

LibWeb: Scope temporary recorder context switches in a helper

LibWeb: Rebuild the visual context tree when local clip inputs change

LibWeb: Drop the corner clip recorded around inner box shadows

LibWeb: Clip backdrop-filter to its own corner radii in the player

LibWeb: Add a clips_to_bounding_rect display list header flag

LibWeb: Give DisplayListPlayer an explicit frame interface

LibWeb: Read pointer-events from the element that was hit

LibWeb: Apply visual transforms to Range client rects

LibWeb: Pause adopted navigation bodies before population

LibRequests+UI/Qt: Keep request notifiers alive during callbacks

LibWeb: Ship display list command runs alongside the command bytes

LibWeb: Record display list command runs in the Rust builder

LibWeb: Remove the unused C++ DisplayList command builder

LibWeb: Derive sticky offsets from a Sticky spatial node

LibWeb: Remove the ScrollCompensation spatial node kind

LibWeb: Split the accumulated visual context into two trees

LibWeb: Hash layout tables with the style engine's fast hasher

LibWeb: Restore layout performance after modularization

LibWeb: Answer querySelector with one style-engine call

LibWeb: Share sibling positions across a selector query’s candidates

AK: Construct short Utf16FlyStrings directly in Rust

LibWeb: Tokenize HTML directly from UTF-16

LibWeb: Use Utf16FlyString names in the Rust HTML parser

LibWeb: Keep innerHTML input in UTF-16

LibWeb: Ensure all rust files are formatted

LibWeb: Paint CSS images through their observers' decoded image data

LibWeb: Keep layout node image observers addressable per style slot

LibWeb: Let decoded image data report a single-pixel color

LibWeb: Point image style value clients at their document resource

LibWeb: Remove the C++ layout tree mutation surface

LibWeb: Route every layout box removal through the arena

LibWeb: Build first-letter, marker and text wrapper subtrees from Rust

LibWeb: Place principal and pseudo-element boxes from the Rust builder

LibWeb: Perform table fixup and anonymous wrapper mutation in Rust

LibWeb: Move layout tree link ownership into the Rust arena

LibWeb: Narrow longhand drive C++ side effects

LibWeb: Construct retained cascade stores in Rust

LibWeb: Cache resolved fonts in the style engine

LibWeb: Give style transactions document length inputs

LibWeb: Publish resolvable inherited UI groups in Rust

LibWeb: Defer style record reclamation across updates

LibWeb: Merge reconstruction metadata in Rust

LibWeb: Skip counter environments for fixed list styles

LibWeb: Retain viewport dependencies in Rust

LibWeb: Avoid qualified names in style sharing keys

LibWeb: Avoid record views for style state probes

LibWeb: Query viewport-dependent styles in the engine

LibWeb: Order style reactions in the engine

LibWeb: Serialize CSS filters without url() in Rust

LibWeb: Move scrollbar and resizer geometry into Rust

LibWeb: Compute hit-test style facts in Rust

LibWeb: Commit SVG viewBox and percentage basis with fragments

LibGfx+LibWeb: Always trigger pending font loads

LibGfx+LibWeb: Use the first available font for metrics

LibWeb: Name the parsed prelude item payload

LibWeb: Share the CSS UTF-16 FFI marshaller

LibWeb: Reuse Rust CSS identifier checks

LibWeb: Share Rust CSS parse context construction

LibWeb: Export parsed CSS rule kinds from Rust

LibWeb: Speed up simple RGB color parsing

LibWeb: Delete the C++ canvas color parser

LibWeb: Add a Rust canvas color fast path

LibWeb: Delete the C++ CSS tokenizer prefilter

LibWeb: Filter CSS code points in the Rust tokenizer

LibWeb: Collect descriptors in Rust

LibWeb: Validate counter-style names in Rust

LibWeb: Validate @import preludes in Rust

LibWeb: Validate @function preludes in Rust

LibWeb: Validate @property rules in Rust

LibWeb: Pass syntax handles into Rust registries

LibWeb: Replace C++ syntax trees with Rust handles

LibWeb: Add shared ownership for Rust syntax trees

LibWeb: Parse query preludes in the syntax parser

LibWeb: Parse selector preludes in the syntax parser

LibWeb: Defer selector namespace validation

LibWeb: Share page selector prelude conversion

LibWeb: Name syntax prelude item kinds

LibWeb: Delegate numeric type algebra to Rust

LibWeb: Expose numeric type matching through Rust

LibWeb: Reuse the calculation numeric type in color resolution

LibWeb: Remove the keyword color fallback

LibWeb: Remove unused radial size resolution

LibWeb: Remove unused parser context checks

LibWeb: Use shared ABI types across the painting FFI

LibGfx: Make Matrix trivially copyable

LibWeb: Collect disconnected observers outside JS execution

LibWeb: Remove the unused size feature name table

LibWeb: Replace the Supports class with free functions

LibWeb: Emit media feature values as FFI PODs directly

LibWeb: Remove the C++ query expression tree

LibWeb: Evaluate container queries in Rust

LibWeb: Evaluate supports conditions in Rust

LibWeb: Evaluate media queries in Rust

LibWeb: Serialize container queries in Rust

LibWeb: Serialize supports conditions in Rust

LibWeb: Serialize media queries in Rust

LibWeb: Retain parsed query trees in Rust

LibWeb: Reject malformed env() references

Tests: Rebaseline for the Rust CSS parser

LibWeb: Delete the C++ CSS token model and syntax consumers

LibWeb: Remove CSS parser comparison gates

LibWeb: Delete the C++ substitution engine

LibWeb: Make Rust substitution resolution authoritative

LibWeb: Evaluate registered style queries natively

LibWeb: Track substitution cycles in Rust

LibWeb: Resolve custom functions in Rust

LibWeb: Resolve standalone substitution values in Rust

LibWeb: Traverse unresolved values in Rust

LibWeb: Highlight CSS from lean Rust tokens

LibWeb: Add a lean CSS syntax token FFI

LibWeb: Make Rust source value parsing authoritative

LibWeb: Retain unresolved values in Rust

LibWeb: Parse descriptors in Rust

LibWeb: Generate CSS descriptor metadata for Rust

LibWeb: Parse rule preludes in Rust

LibWeb: Delete the C++ query parser

LibWeb: Route all query parsing through Rust

LibWeb: Parse supports and container queries in Rust

LibWeb: Parse media queries in Rust

LibWeb: Add a Rust CSS query grammar

LibWeb: Cut fixed CSS value parsing overhead

LibWeb: Keep style-engine mutation helpers inlined

Tests: Update CSS parser unit tests for the Rust parser

Meta: Detect StyleBench completion instead of comparing counters

LibWeb: Parse substituted values on style workers

LibWeb: Resolve if() and custom functions in Rust

LibWeb: Resolve attr(), inherit() and env() substitution in Rust

LibWeb: Resolve registered custom property values in Rust

LibWeb: Share Rust CSS tokenizer source storage

LibWeb: Verify Rust syntax declarations against C++

LibWeb: Stop creating C++ tokens for stylesheet parsing

LibWeb: Build stylesheets and declaration blocks from Rust syntax trees

LibWeb: Consume CSS syntax in Rust

LibWeb: Remove the C++ CSS tokenizer

LibWeb: Remove the C++ CSS value parser

Meta: Add a CSS value parser microbenchmark

LibWeb: Reduce allocations in the Rust CSS value parser

LibWeb: Hand parsed component values to the Rust parser directly

LibWeb: Make the Rust CSS value parser the default

LibWeb: Parse substituted cascade values without a C++ round trip

LibWeb: Parse serialized CSS values in Rust

LibWeb: Parse CSS syntax definitions and typed values in Rust

LibWeb: Parse arbitrary substitution functions in Rust

LibWeb: Parse CSS shorthands in Rust

LibWeb: Make Rust longhand parsing authoritative

LibWeb: Parse remaining CSS longhands in Rust

LibWeb: Parse CSS counters, content, cursor and timelines in Rust

LibWeb: Parse CSS grid values in Rust

LibWeb: Parse CSS font values and descriptors in Rust

LibWeb: Parse CSS images and gradients in Rust

LibWeb: Parse CSS transforms, easing functions and filters in Rust

LibWeb: Parse CSS anchor positioning values in Rust

LibWeb: Parse CSS positions and basic shapes in Rust

LibWeb: Parse CSS colors in Rust

LibWeb: Parse CSS random() in Rust

LibWeb: Parse CSS calculations in Rust

LibWeb: Parse CSS strings, identifiers and URLs in Rust

LibWeb: Parse numeric CSS values in Rust

LibWeb: Parse CSS keywords and single-keyword display in Rust

LibWeb: Generate CSS property and keyword metadata for Rust

LibWeb: Add a Rust CSS value parser entry point with C++ fallback

LibWeb: Add shared Rust CSS component values and a token stream

LibWeb: Remove unused Layout::Node methods

LibWeb: Read paintable facts from layout nodes instead of snapshotting

LibWeb: Borrow paintable rows through arena views

LibWeb: Read box-model metrics through committed fragment links

LibWeb: House committed fragment links in the paintable arena

LibWeb: Retain the committed fragment link for every box

LibWeb: Retain SVG layout seeds as fragment links

LibWeb: Evict saved geometry with committed boxes

LibWeb: Read committed box metrics from fragments

LibJS: Transfer Rust string tables into executables

LibWeb: Transfer serialized UTF-16 string ownership

AK: Add native Rust UTF-16 string owners

LibWeb: Share UTF-16 fly string storage with Rust

AK: Add zero-churn UTF-16 ownership transfer

AK: Stabilize UTF-16 string storage layout

LibWeb: Tidy after the shell removal

LibWeb: Delete the C++ paintable shells

LibWeb: Let the Rust commit own paintable row lifecycle

LibWeb: Pass layout nodes through the paint host callbacks

LibWeb: Read committed rows by slot inside Painting

LibWeb: Tidy after the paint-state move

LibWeb: Keep SVG filter bounds in the arena side data

LibWeb: Track pending paint updates by arena slot

LibWeb: Route document paint state callers through paint_state()

LibWeb: Key the paint pipeline entry points by document

LibWeb: Move document paint state off the viewport paintable

LibWeb: Tidy the paintable header after the widget move

LibWeb: Drive chrome-widget eviction from arena row resets

LibWeb: Move chrome widgets into a slot-keyed document registry

LibWeb: Key chrome-widget geometry off layout nodes

LibWeb: Tidy the paintable header after the scroll move

LibWeb: Dispatch wheel scrolling without the paintable virtual

LibWeb: Move scroll mutation onto layout-node-keyed functions

LibWeb: Serve scroll reads from layout-node-keyed free functions

LibWeb: Move the scroll enums out of Paintable

LibWeb: Move caret paint helpers off the paintable subclasses

LibWeb: Route tool and repaint entry points through views

LibWeb: Key event handling by layout nodes instead of paintables

LibWeb: Serve SVG geometry queries from layout-node views

LibWeb: Key observer and style reads by layout nodes

LibWeb: Read CSSOM box geometry through layout-node views

LibWeb: Add layout-node-keyed views over paintable reads

LibWeb: Store arena slots in the retained hit-test items

LibWeb: Key caret positions by arena slot

LibWeb: Carry a DOM node and arena slot in hit-test results

LibWeb: Return caret owners as arena slots instead of shells

LibWeb: Delete BorderRadiiData and compute all border radii in Rust

LibWeb: Replace BordersData with a single border for outline queries

LibWeb: Delete DisplayListRecordingContext and C++ DevicePixelConverter

LibWeb: Remove dead FFI remnants of collapsed table border commit path

LibWeb: Retire the C++ paint-tree traversal API

LibWeb: Bubble wheel and key scrolling through layout containing blocks

LibWeb: Find scrollable ancestors through layout containing blocks

LibWeb: Walk layout containing blocks in intersection computation

LibWeb: Enumerate SVG paint children via the layout tree

LibWeb: Collect content-visibility boxes from the layout tree

LibWeb: Answer inline child-paintable presence from the arena

LibWeb: Fold repaint cache invalidation walks into the Rust arena

LibWeb: Clear all paint caches arena-wide on focus changes

LibWeb: Resolve event-dispatch DOM nodes in the Rust arena

LibWeb: Dump the paint tree from a flat Rust preorder export

Meta: Run Rust workspace tests in CI

LibWeb: Add missing Rust unit test FFI stubs

LibWeb: Stub C++ release callbacks in Rust unit tests

LibWeb: Fix Rust unit test compilation

LibWeb: Remove obsolete C++ selector support

LibWeb: Move selector ownership and serialization to Rust

LibWeb: Add the Rust selector parser core

LibWeb: Move the reused-subtree movement fixup into the Rust commit

LibWeb: Answer absolute-rect queries from the Rust arena memo

LibWeb: Commit box metrics through the Rust arena only

LibWeb: Never accumulate containing-block offsets for SVG paintables

LibWeb: Delete the C++ fragment and line mirror

LibWeb: Export visual lines as plain values and drop fragment pointers

LibWeb: Answer hit-test fragment questions from the arena records

LibWeb: Compute Range client rects from the Rust fragment records

LibWeb: Answer caret placement from the Rust fragment records

LibWeb: Build text render spans from the Rust fragment records

LibWeb: Apply the document selection to the arena in one aggregate call

LibWeb: Format the layout dump's fragment lines in Rust

LibWeb+LibGfx: Retain committed glyph runs in the Rust fragment records

LibWeb: Fast reject empty paint overlays

LibWeb: Cache unchanged descendant paint subtrees

LibWeb: Skip absent anchor callbacks during painting

LibWeb: Permit arena reads during hit testing

LibWeb: Store paint caches inline in the arena

LibWeb: Batch hit test item exports

LibWeb: Retain compatible paint caches across relayout

LibWeb: Invalidate absolute rect memos in constant time

LibWeb: Memoize base paint facts per recording

LibWeb: Fast reject caret-only box hit test facts

LibWeb: Use dense paint recording memo tables

LibWeb: Use retained paintable traversal facts

LibWeb: Fast reject flat 3D rendering context candidates

LibWeb: Remove dead NodeWithStyle methods

LibWeb: Recompute containing blocks inside the Rust arena

LibWeb: Move propagated text decoration cache invalidation to Rust

LibGfx: Compute GlyphRun bounds and intercepts with HarfBuzz, not Skia

LibWeb: Refill the Rust contained-boxes index in place

LibWeb: Retire the FFI surface orphaned by the overflow port

LibWeb: Move scrollable-overflow measurement into Rust

LibWeb: Derive reused-subtree movement from committed offset deltas

LibWeb: Mirror the scrollable-overflow contained-boxes index in Rust

LibWeb: Move physical overflow direction resolution into Rust

LibWeb: Share the axis-reverse predicates on the computed style view

LibWeb: Keep grid and flex layout data in Rust

LibWeb: Reset layout dirty flags inside the Rust arena

LibWeb: Limit client rect identity checks to ancestors

LibWeb: Skip no-op prefix state removal scans

LibWeb: Defer identity visual context rebuilds

LibWeb: Reduce visual context tree build overhead

LibWeb: Key paintable rows by their layout node's slot

LibWeb: Collapse the SVG paintable classes into kind dispatch

LibWeb: Collapse the stateless replaced-content paintables into kinds

LibWeb: Serve the committed SVG path from the paintable arena

LibWeb: Store SVG viewport geometry only in the paintable arena

LibWeb: Make the Rust paintable tree the only paintable tree

LibWeb: Derive paint-commit splice anchors from the layout tree

LibWeb: Resolve the image provider through ImagePaintable's layout node

LibWeb: Remove dead paintable FFI and virtuals left by the Rust port

LibWeb: Remove the superseded C++ painting implementation

LibWeb: Resolve gradients for painting in Rust

LibWeb: Record the display list and hit-test list in Rust

LibWeb: Record image paints in Rust

LibWeb: Port display list recording and hit testing to Rust

LibWeb: Use the Rust visual context tree and scroll state

LibWeb: Build the visual context tree and scroll state in Rust

LibWeb: Read paintable metrics, overflow and sticky state from the arena

LibWeb: Read paintable flags and selection from the arena

LibWeb: Serve grid and flex layout data from the Rust arena

LibWeb: Build a paintable tree in the Rust arena during layout commit

LibWeb: Compile the display list tape against the generated definitions

LibWeb: Define display list commands in Rust

LibWeb: Shape display list structs like their generated replacements

LibGfx: Expose font, path, and filter shims to Rust

LibGfx: Add Rust mirrors of the paint vocabulary types

LibWeb: Route stacking context dumps through a free function

LibWeb: Track stacking context tree validity with a viewport flag

LibWeb: Expose scrollbar paint color resolution as a query

LibWeb: Split text and caret paint resolution from recording

LibWeb: Write async scrolling metadata directly to the display list

LibWeb: Track SVG pattern references in the layout arena

LibWeb: Store indices instead of pointers in hit test items

LibWeb: Carry gradient interpolation as a Gfx type

LibWeb: Decouple SVG paint servers from display list recording

LibWeb: Rename display list tape fields to match the Rust writer

LibWeb: Avoid wrappers for simple mask values

LibWeb: Avoid allocating lists for first animation items

LibWeb: Avoid TLS when FFI counters are disabled

LibWeb: Avoid temporary wrappers for computed value lists

LibWeb: Compile replay support only into style-replay

LibWeb: Compute `border-spacing` to a two-value list

LibWeb: Compute legacy sRGB colors to one canonical `rgb()` form

LibWeb: Compute SVG stroke numbers to absolute lengths

LibWeb: Allow negative `stroke-dashoffset` values

LibWasm+WebContent+WebWorker: Route compilation through WasmCompiler

LibWebView: Manage the WebAssembly compiler as a singleton

WasmCompiler: Add an on-demand compiler service

LibWasmCompilerClient: Add a threaded compiler client

LibSandbox: Support forked helper processes

LibWasm: Use compact Cranelift compiler buffers

LibWasm: Back Cranelift batches with anonymous buffers

LibWasm: Stack compiled fault recovery contexts

LibCore: Add safe AnonymousBuffer snapshots

LibCore: Support sealable anonymous buffers

LibWeb: Check the Wasm disk cache after validation

LibWeb: Do not ignore the result of creating Wasm cache entries

LibWeb: Repair Rust style test fixtures

LibWeb: Filter Trusted Types attribute lookups

LibWeb: Skip impossible custom element definition lookups

LibWeb: Process ordinary parser text in runs

LibWeb: Reject non-custom element names early

LibWeb: Skip detached custom state invalidation

LibWeb: Avoid retaining unused parser stack attributes

LibWeb: Avoid unrelated attribute-name scans

LibWeb: Resolve image paints as data instead of recording them

LibWeb: Record nested display lists in a pre-pass before traversal

LibWebView: Add a lossless origin codec for snapshot storage

LibURL+LibIPC: Store a tuple origin's domain as a parsed host

LibWebView: Validate and install UI-process session-history snapshots

LibWebView: Drop StorageJar's hand-rolled UTF-16 conversions

LibDatabase: Bind borrowed bytes directly as a blob

LibDatabase: Bind and read optional values as SQL NULL

LibDatabase: Reject direct u64 bindings

LibWebView: Store history counters and sizes in SQLite's domain

LibDatabase: Add row-bounded statement execution and collection

LibDatabase: Add an exactly-one-row statement execution helper

LibHTTP: Make disk cache integer encoding explicit

LibDatabase: Bind and read UTF-16 text as WTF-8

LibDatabase: Add name-based parameter binding and ResultRow

AK: Make BitmapView searches respect the logical size

LibDatabase: Return ErrorOr from result callbacks

LibDatabase: Add storage-class-checked, bounded column reads

LibDatabase: Add a scoped transaction() helper

LibDatabase: Support enabling foreign keys via connection Options

LibDatabase: Read a column's length after its value, not before

Everywhere: Only write generated FFI files to Cargo's OUT_DIR

LibWeb: Generate all FFI headers with non-strict helper

LibWeb: Collapse the SVG layout box classes into Box

LibWeb: Map layout class names from the arena node kind

LibWeb: Rehome the remaining per-class layout behavior

LibWeb: Drive replaced-content sizing from the arena node kind

LibWeb: Create paintables from the arena node kind

LibWeb: Derive layout type predicates from the arena node kind

LibWeb: Reduce Rust style ownership overhead

LibWeb: Avoid StyleValue materialization during invalidation

LibWeb: Reduce Rust style transaction overhead

LibWeb: Batch style side effects and ownership releases

LibWeb: Remove remaining style computation callbacks

LibWeb: Remove the C++ longhand computation fallback

LibWeb: Resolve dynamic computed values in Rust

LibWeb: Resolve contextual calculations in Rust

LibWeb: Compute specialized longhands in Rust

LibWeb: Drive computed longhands through staged Rust entries

LibWeb: Return style transaction data without callbacks

LibWeb: Build computed value groups in Rust

LibWeb: Make StyleRecord the computed value object

LibWeb: Store computed style inputs in Rust

LibWeb: Move style value operations into Rust

LibWeb: Reuse committed paintable subtrees

LibWeb: Skip empty atomic block layout bodies

LibWeb: Add broad coverage for layout caching

LibWebView: Remove standalone history seeding

LibWebView: Restore entries through history loads

LibWebView: Match history loads by identity

LibWebView: Carry history with process-swap loads

LibWebView: Continue missing-target traversals in-place

LibWebView: Restore canceled navigations through operations

LibWebView: Reconstruct fallback traversals through operations

LibWebView: Recover crashed history through an operation

LibWebView: Continue requested traversals across process swaps

LibWeb+LibWebView: Make child history operations self-contained

LibWeb: Make changing history jobs entry-addressed

LibWeb+LibWebView: Traverse history from the UI on unhandled key events

LibWebView: Resolve browser traversal targets at their queue position

LibWebView: Start browser history traversals from the traversable

LibWeb: Restore DocumentState association on activation

LibWebView: Prevent history queue jump starvation

LibWeb: Add comprehensive layout tree update coverage

LibWeb: Resolve the relayout splice target inside the commit sink

LibWeb: Delete the read_paintable_geometry layout callback

LibWeb: Seed SVG-root partial relayout from saved committed geometry

LibWeb: Save committed SVG root geometry in an arena side table

LibWebView: Guess http for private-network addresses too

LibWebView: Guess http, not https, for loopback and localhost URLs

LibURL+LibWeb: Add and use Host::is_loopback_or_localhost()

LibWeb: Refresh anchor-name facts on retained layout nodes

LibWeb: Reject pseudo-elements in selector queries

LibWeb: Reject nested :host in :host() arguments

LibWeb: Preserve focus state while validating a new target

LibWeb: Keep decorated parents out of style sharing

LibWeb: Keep host compounds on the ordinary matching path

LibWeb: Republish directionality across slot dependencies

LibWeb: Read pending directionality facts

Compositor: Reject oversized shareable backing stores

LibWeb: Match :host alternatives inside selector-list pseudos

LibWeb: Preserve newer slot assignments during reassignment

LibWeb: Roll revert-layer back from the implicit outer layer

LibWeb: Republish auto direction after text control value changes

LibWeb: Re-resolve keyframe-borne inherit when the parent changes

LibWeb: Keep provisional transition values across animated updates

LibWeb: Survive focus moves from inside blur and focus handlers

LibWeb: Re-evaluate caret-color and accent-color on color changes

LibWeb: Do not keep typed custom property values past unregistration

LibWeb: Key custom property resolutions on the color scheme

LibWeb: Republish radio group validity when checkedness changes

LibWeb: Match :playing on the paused attribute alone

LibWeb: Re-enroll layout nodes for replaced-content facts on restyle

LibWeb: Keep animated values in layout-derived style records

LibWeb: Keep host compounds featureless when crossing the shadow root

LibWeb: Parse time strings without an ASCII-only detour

LibWeb: Stop tree-scoped name walks at detached shadow hosts

LibWeb: Charge retained prefix cache maintenance to residency

Documentation: Document the style engine

LibWeb: Switch style resolution to the new style engine

LibWeb: Add the style engine's record/replay and test suites

LibWeb: Add the style engine's flush and FFI boundary

LibWeb: Add the style engine's cascade and computed records

LibWeb: Add the style engine's matching and routing

LibWeb: Add the style engine's core data model

LibWeb: Add the style engine's selector IR and compiler

Meta: Add style measurement and profiling tools

AK: Add byte access, bulk copy, and equality to FixedBitmap

LibWeb: Emit SVG paths from shared fragment handles

LibWeb: Detect anchor-function insets with a node flag

LibWeb: Carry line data and owned layout payloads behind shared pointers

LibWeb: Carry fragments in links behind a shared pointer

LibJS: Keep GC cells in pointer wrappers

LibGC: Adapt weak pointers to sealed pointer wrappers

LibWeb: Remove NodeWithStyleAndBoxModelMetrics

LibWeb: Remove obsolete C++ available space types

CI: Recover from a partially installed Rust toolchain

CI: Select Xcode version 26.5

LibWeb: Read anchor() facts directly from Rust style values in layout

LibWeb: Drop the layout engine's `_mut` used-values accessors

LibWeb: Replace RetainedLayoutHandle with libgfx_rust OwnedPath

LibGfx: Add Rust OwnedPath wrapper for heap-allocated Gfx::Path

LibWeb: Rename rust_state to layout_state

LibWeb: Return the measured table box size on the wrapper's run result

LibWeb: Publish replaced content facts into the layout node arena

LibWebView: Do not trust the file position after truncating a download

Tests: Test downloading files

UI: Pause resumable downloads instead of canceling them on quit

UI: Add pause and resume buttons to the downloads popover

LibWebView: Show per-segment progress on about:downloads

LibWebView: Expose download pause and resume on about:downloads

LibWebView: Persist in-progress downloads across browser restarts

LibWebView: Add a store for in-progress downloads

LibWebView: Support pausing and resuming file downloads

LibWebView: Download files over multiple connections when possible

LibWebView: Add helpers for HTTP range planning

LibWebView: Track file downloads as a list of byte segments

LibWebView: Add a paused state to file downloads

LibWebView: Follow redirects when downloading a file

LibWeb: Remove per-element computed style overrides

LibWeb: Remove list item layout facts

LibWeb: Remove the FillEllipse display list command

LibWeb: Render list markers through generated content

LibWeb: Resolve relative positions during the Rust layout commit

LibWeb: Change read-only `DOMString` members to `USVString`

LibWeb: Declare the resolution types of `SubtleCrypto` promises

LibWeb: Use `undefined` rather than `void` in SVG interface IDL

LibWeb: Move the computed style accessor surface into the css module

LibWeb: Fold StyleReader into StyleValues

LibWeb: Drop the migration allowance from the computed value views

LibWeb: Carry grid track sizes as payload references, drop FfiSizeValue

LibWeb: Read gaps, SVG geometry and offsets through payload views

LibWeb: Model inset reads as a typed value instead of a decoded struct

LibWeb: Read margins and paddings straight from the surround payload

LibWeb: Read sizing properties straight from the style group payloads

LibWeb: Add lazy length-percentage views over computed style payloads

LibWeb: Store computed grid style as a Rust-native style group payload

LibWeb: Derive SVG element type facts from NodeKind

Meta: Separate Cargo builds from copied Rust outputs

LibWeb: Transfer saved abspos inputs within TreeBuilder

LibWeb: Use FfiDisplay directly for table roles

LibWeb: Hand layout a Rust-owned style container instead of a mirror

LibWeb: Mirror style group payloads into the layout node arena

LibWeb: Replace the layout size-value cache with an anchor-inset store

LibWeb: Read layout style scalars on demand from group payloads

LibWeb: Pin the layout style group indices at compile time

LibWeb: Move partial-rebuild bookkeeping from the C++ bridge into Rust

LibWeb: Trim arena-derivable fields from the descendant facts bundle

LibWeb: Compute replaced-display adjustment from the arena style mirror

LibWeb: Answer three tree-builder callbacks from the layout node arena

LibWeb: Remove dead has_auto_content_box_size virtual

LibWeb: Carry position-anchor in the surround twin, drop the residual

LibWeb: Move column width and count into the box twin

LibWeb: Move grid auto-flow to the box twin and delete the field schema

LibWeb: Move text-overflow, unicode-bidi and table-layout to box twin

LibWeb: Precompute layout font facts into a typed prefix twin

LibWeb: Read inherited text style through a typed prefix twin

LibWeb: Read border widths and styles through a typed prefix twin

LibWeb: Build anchor() inset calc wrappers in the Rust layout engine

LibWeb: Replace computed values only after the layout pass returns

LibJS: Select declarative Flap specializations

LibJS: Pass values to binary Flap slow paths

LibJS: Parse declarative Flap specializations

LibJS: Derive bytecodes from Flap handlers

LibJS: Snapshot generated Flap interpreter assembly

LibWeb: Move table grid formation fully into Rust

LibWeb: Move anonymous text run filtering to Rust

LibWeb: Read display from the box payload and drop the style snapshot

LibWeb: Convert the box style group to a Rust-native payload

LibWeb: Share the retained fly-string types across generated headers

LibWeb: Hoist computed aspect-ratio decoding into ComputedProperties

LibWeb: Move will-change into the misc reset style group

LibWeb: Delete the C++ ChunkIterator now that chunking lives in Rust

LibWeb: Chunk text in Rust and drop the text facts FFI callbacks

LibGfx+LibUnicode: Add font-cascade and segmenter shims for Rust layout

LibWeb: Move rendered text into a Rust-owned arena side table

LibWeb: Drop redundant fields from the text facts FFI snapshot

LibWeb: Drop the DOM ancestry callback from layout FC callbacks

LibWeb: Honor a zero `fit-content` argument when sizing a table

LibWeb: Compare tab advance against `0.5ch` without rounding first

LibWeb: Return slot ids instead of shells from layout FC callbacks

LibWeb: Remove the retired C++ layout engine

LibWeb: Switch layout execution to Rust

LibWeb: Add Rust layout bridge

LibWeb: Add Rust block formatting

LibWeb: Add Rust inline formatting

LibWeb: Add Rust inline line machinery

LibWeb: Add Rust SVG formatting

LibWeb: Add Rust grid formatting

LibWeb: Add Rust flex formatting

LibWeb: Add Rust table formatting

LibWeb: Add Rust formatting-context core

LibWeb: Add direct style access for Rust layout

LibWeb: Add Rust layout foundations

LibWeb: Add layout node facts

LibGfx: Add Rust wrappers for font and text layout

LibWeb: Remove redundant inline layout includes

LibWeb: Move table border arbitration into TableGrid

LibWeb: Export layout geometry seams

LibWeb: Move layout tree building into the shared libweb crate

LibWeb: Move style computation into the shared libweb crate

LibJS: Document Flap trusted-input boundaries

LibJS: Preserve names for every Flap source input

LibJS: Expose structured Flap diagnostics and reports

LibJS: Scope available loads to dominator subtrees

LibJS: Borrow immutable Flap checking context

LibJS: Report Flap parameter cleanup convergence accurately

LibJS: Cross-check Flap machine optimizations

Meta: Validate generated Flap interpreters in CI

LibJS: Price Flap layouts with the machine planner

LibJS: Add exact spill-free allocation fallback

LibJS: Share Flap machine register analysis

LibJS: Validate complete bytecode schemas

LibJS: Reject higher-order Flap inline recursion

LibJS: Split rematerializable Flap live ranges

LibJS: Intern Flap virtual registers once

LibJS: Make BytecodeDef parsing fallible

Meta: Add standalone Flap CI coverage

LibJS: Fix Flap Clippy violations

LibJS: Format Flap Rust sources

LibJS: Cache Flap machine-state dependencies

LibJS: Bound Flap inline expansion

LibJS: Forward Flap loads across linear block chains

LibJS: Express a check as a guard instruction with a side exit

LibJS: Fold a block into the only block that jumps to it

LibJS: Revisit an instruction's liveness only when a successor moves

LibJS: Point at an instruction's description instead of building it

LibJS: Let finalization take the graph's instructions

LibJS: Drop cold annotations in place when building a graph

LibJS: Group forwardable loads by the location they read

LibJS: Look up where an instruction sits instead of searching for it

LibJS: Hold live registers sparsely during allocation

LibJS: Collect block starts in a bitmap

LibJS: Rebuild successor lists once per graph cleanup

LibJS: Name an SSA value's register once, not once per use

LibJS: Build an effect set only when it moved

LibJS: Reuse Flap block labels across functions

LibJS: Stop counting unused Flap operand references

LibJS: Stop computing unused Flap loop analysis

LibJS: Invert a branch over a jump without moving the rest

LibJS: Number virtual registers as they first appear

LibJS: Ask only for the analyses a pass reads

LibJS: Find the instructions a branch absorbed in one walk

LibJS: Share a label's name and hash it once

LibJS: Hash the compiler's own tables cheaply

LibJS: Answer peephole liveness questions without rescanning

LibJS: Scope common-subexpression availability instead of copying it

LibJS: Hold effect dependencies in a sorted vector

LibJS: Compute Flap allocation successors without a graph

LibJS: Compact unreferenced Flap labels in place

LibJS: Streamline Flap control-flow graph cleanup

LibJS: Move instructions into Flap control-flow graphs

LibJS: Allocate registers over dense indices instead of names

LibJS: Reuse CFG edges during Flap optimization

LibJS: Index SSA value users before Flap lowering

LibJS: Drive constant propagation from a worklist

LibJS: Allocate unused AArch64 caller-saved registers

LibJS: Clear wide results of narrow Flap arithmetic

LibJS: Propagate constants through boxed Flap values

LibJS: Rematerialize constant Flap computations

LibJS: Conflict discarded results with live registers

LibJS: Recognize equivalent Flap memory locations

LibJS: Propagate effects in reverse postorder

LibJS: Find dominators without materializing dominator sets

LibJS: Avoid repeated graph scans in Flap

LibJS: Cache facts reused during Flap lowering

LibWeb: Read layout tree state from the Rust node arena

LibWeb: Add shared layout node storage for Rust

LibJS: Add the Flap low-level IR and machine backend

LibJS: Add Flap SSA construction and optimization

LibJS: Add the Flap high-level IR and semantic analysis

LibJS: Add the Flap front end

LibJS: Add the Flap compiler crate skeleton

LibWeb: Invalidate viewport-relative lengths nested in math functions

LibWeb: Move remaining computed style groups to Rust

LibWeb: Move computed style filtering and sizing to Rust

LibWeb: Keep longhand computation in Rust

LibWeb: Batch external calculation operations

LibWeb: Return animation and transition results directly from Rust

LibWeb: Remove obsolete C++ CSS helpers

LibWeb: Drive keyframe value preparation from Rust

LibWeb: Resolve animation property conflicts in Rust

LibWeb: Pass cascade and longhand values as Rust handles

LibWeb: Remove C++ animation value fallbacks

LibWeb: Complete per-element animation batching in Rust

LibWeb: Move complex animation interpolation to Rust

LibWeb: Evaluate keyframe intervals and transitions in Rust

LibWeb: Move remaining scalar and transform animation types to Rust

LibWeb: Retain complex style values in Rust

LibWeb: Retain miscellaneous compound style values in Rust

LibWeb: Move tagged and function animation values to Rust

LibWeb: Move compound geometry animation values to Rust

LibWeb: Establish batched Rust animation evaluation

LibWeb: Move transform interpolation to Rust

LibWeb: Retain transform and list children in Rust

LibWeb: Establish shared Rust style value handles

LibWeb: Keep text wrapper decisions in Rust

LibWeb: Keep first-letter matching in Rust

LibWeb: Keep assigned slot cleanup in Rust

LibWeb: Keep layout tree insertion in Rust

LibWeb: Keep layout tree postprocessing in Rust

LibWeb: Remove the C++ layout TreeBuilder class

LibWeb: Keep layout tree builder state in Rust

LibWeb: Keep layout tree recursion and context in Rust

LibWeb: Add a functional layout tree build API

LibWeb: Port specialized wrapper traversal to Rust

LibWeb: Hide internal layout tree builder helpers

LibWeb: Port layout tree cleanup decisions to Rust

LibWeb: Port specialized element box selection to Rust

LibWeb: Port pseudo-element construction to Rust

LibWeb: Port layout tree build orchestration to Rust

LibWeb: Move layout tree update orchestration to Rust

LibWeb: Port layout child hooks to Rust

LibWeb: Port principal descendant construction to Rust

LibWeb: Port principal box placement decisions to Rust

LibWeb: Port principal tree entry decisions to Rust

LibWeb: Port display-contents tree updates to Rust

LibWeb: Port specialized wrapper decisions to Rust

LibWeb: Port pseudo-element box decisions to Rust

LibWeb: Port layout child traversal to Rust

LibWeb: Move layout tree builder state to Rust

LibWeb: Port first-letter tree selection to Rust

LibWeb: Port layout tree insertion to Rust

LibWeb: Port table tree fixup to Rust

LibWeb: Start the Rust layout tree builder port

LibWeb: Split layout node creation phases out of TreeBuilder's walk

LibWeb: Resolve pseudo-element content once, after counters

LibWeb: Make TreeBuilder's rebuild confinement observable in tests

LibWeb: Extract self-contained helpers from TreeBuilder's walk

LibWeb: Give NodeWithStyle targeted setters for post-creation tweaks

LibWeb: Deduplicate child walks in TreeBuilder's two update paths

LibWeb: Move FfiDisplay into a shared Rust display module

LibWeb: Extract shared FFI plumbing from the Rust selector engine

LibWeb: Download hyperlinks with a `download` attribute

LibWebView+test-web: Refuse download requests in the test runner

LibWebView: Truncate temporary download filenames

LibWeb+LibWebView: Truncate suggested download filenames

LibWeb+LibWebView: Share the download filename sanitizer

LibWeb+LibWebView: Do not derive download filenames from data: URLs

LibWeb: Reapply adjustments for inherited animations

LibWeb: Adjust match-parent against animated parent styles

LibWeb: Preserve attr taint during variable substitution

LibWeb: Preserve custom property cycle invalidation

LibWeb: Flush post-compute adjustments from Rust

LibWeb: Decide input line-height clamping in Rust

LibWeb: Resolve effective color schemes in Rust

LibWeb: Adjust element styles in the Rust driver

LibWeb: Transform box types in the Rust driver

LibWeb: Compute text alignment in the Rust driver

LibWeb: Resolve effective overflow in the Rust driver

LibWeb: Return cascade value data with parsed shells

LibWeb: Mirror custom property registrations in Rust

LibWeb: Resolve custom property variables in Rust

LibWeb: Own unresolved token source text in Rust

LibWeb: Mirror custom property data in Rust

LibWeb: Cascade custom properties in Rust

LibWeb: Strengthen foreign type selector coverage

LibWeb: Match ID selectors case-insensitively in quirks mode

LibWeb: Match foreign type selectors case-sensitively

LibWeb: Remove the unused open-state parameter

LibWeb: Remove redundant selector DOM wrapper state

LibWeb: Remove the retired selector callback counter

LibWeb: Treat selector navigation as live DOM reads

LibWeb: Match remaining states through live DOM facts

LibWeb: Match media states through live DOM facts

LibWeb: Match common states through live DOM facts

LibWeb: Match language ranges in Rust

LibWeb: Match custom states through a live DOM query

LibWeb: Match direction through a live DOM fact

LibWeb: Match open popovers through live DOM facts

LibWeb: Match headings through a live DOM fact

LibWeb: Match fullscreen through a live DOM fact

LibWeb: Match focus states through live DOM facts

LibWeb: Match link states through live DOM facts

LibWeb: Match attributes through live DOM views

LibWeb: Match quirks classes through live DOM views

LibWeb: Match tag names through live DOM string views

LibWeb: Resolve selector namespaces through live accessors

LibWeb: Read selector element facts through live accessors

LibWeb: Compare selector element types through live wrappers

LibWeb: Read root selector state from the live DOM wrapper

LibWeb: Match common tag selectors through live DOM wrappers

LibWeb: Read selector identifiers through live DOM wrappers

LibWeb: Delete dead code hidden by allow(dead_code) in the style crate

LibWeb: Run the whole cascade as one bulk Rust operation per element

LibWeb: Build the background style group through the descriptors

LibWeb: Build the border style group through the descriptors

LibWeb: Build the surround style group through the descriptors

LibWeb: Build the box style group through the descriptors

LibWeb: Build the content and anchor style groups through descriptors

LibWeb: Build the inherited list style group through the descriptors

LibWeb: Build the inherited SVG style group through the descriptors

LibWeb: Build the SVG reset style group through the descriptors

LibWeb: Build the animation style group through the descriptors

LibWeb: Build the grid style group through the descriptors

LibWeb: Build the mask style group through the descriptors

LibWeb: Build the transform style group through the descriptors

LibWeb: Build the sizing style group through the descriptors

LibWeb: Build the inherited UI style group through the descriptors

LibWeb: Build the inherited text style group through the descriptors

LibWeb: Build the misc reset style group through the descriptors

LibWeb: Build the effects style group through the descriptors

LibWeb: Build the text reset style group through the descriptors

LibWeb: Build the alignment style group through the descriptors

LibWeb: Add descriptor-driven style group building to the core

LibWeb: Build the inherited table style group in Rust

LibWeb: Build the inherited box style group in Rust

LibWeb: Compute the font cluster natively and defer the rest to batches

LibWeb: Compute corner shapes and math-depth in the driver

LibWeb: Compute border widths and spacing longhands in the driver

LibWeb: Absolutize plain longhand values natively in the driver

LibWeb: Batch longhand stores that need no computation

LibWeb: Select longhand values natively in the Rust style core

LibWeb: Install a Rust-readable initial value table

Meta: Add style FFI baseline workloads

LibWeb: Count crossings of the style system's FFI boundary

LibWeb: Remove more code orphaned by the native Rust calc tree

LibWeb: Delete the C++ CalculationNode hierarchy

LibWeb: Build the Rust calculation tree natively everywhere else

LibWeb: Build the Rust calculation tree natively in typed-OM

LibWeb: Build the Rust calculation tree natively in the parser

LibWeb: Add a C++ builder over the Rust calc construction surface

LibWeb: Remove machinery orphaned by the Rust style and calc port

LibWeb: Compute remaining font longhands in the Rust core

LibWeb: Move property dependency predicates to the Rust core

LibWeb: Move position-area span-all remapping to the Rust core

LibWeb: Restore spec text comments lost in the Rust calc port

LibWeb: Resolve font property calc in the Rust compute core

LibWeb: Drop the stored C++ tree from calculated value data

LibWeb: Check anchor() containment over the Rust calc tree

LibWeb: Delete the C++ calc evaluation machinery

LibWeb: Route specified-time calc simplification through the Rust core

LibWeb: Fix four latent parity bugs in the Rust calc core

LibWeb: Delete the dead C++ calc serializer and resolve fallback

LibWeb: Absolutize calculated style values over the Rust calc tree

LibWeb: Fix round() strategy code order in the Rust calc core

LibWeb: Reify math expressions from the Rust calc tree

LibWeb: Evaluate and serialize random() through the Rust calc tree

LibWeb: Compare calculation trees structurally in Rust

LibWeb: Serialize calculations through the Rust calc tree

LibWeb: Resolve calculated values through the Rust calc tree

LibWeb: Simplify calculation trees in Rust

LibWeb: Run calculation operations over the Rust calc tree

LibWeb: Determine calculation types over the Rust calc tree

LibWeb: Port the numeric type algebra to the Rust calc module

LibWeb: Answer calc value predicates from the Rust tree

LibWeb: Build a Rust calculation tree alongside the C++ tree

LibWeb: Decide computational independence in the Rust value graph

LibWeb: Decide currentcolor dependence in the Rust value graph

LibWeb: Decide pseudo-element style bails in Rust

LibWeb: Time-travel the monospace font-size recascade in Rust

LibWeb: Read the cascaded store natively from the property driver

LibWeb: Run automatic box type transformations in Rust

LibWeb: Decide text-align adjustments in Rust

LibWeb: Resolve effective overflow values in Rust

LibWeb: Apply declaration lists to the cascade in Rust

LibWeb: Move the cascaded property store to Rust

LibWeb: Drive cascade origin ordering from Rust

LibWeb: Expand shorthands in Rust during declaration application

LibWeb: Orchestrate the longhand computation flow in Rust

LibWeb: Map logical property aliases in Rust

LibWeb: Drive the property computation loop from Rust

LibWeb: Compute border widths, corner shapes, and position-area in Rust

LibWeb: Compute font properties and line-height in Rust

LibWeb: Resolve lengths in Rust during style computation

LibWeb: Generate CSS property metadata tables for the Rust style core

LibWeb: Define inherited style group layouts in Rust

LibWeb: Hand ownership of style group payloads to Rust

LibWeb: Share style group payloads with the parent element

LibWeb: Add internals.styleGroupSharingInfo() for group introspection

LibWeb: Move reset values into shared style groups

LibWeb: Move inherited values into shared style groups

LibWeb: Add StyleStructRef, a copy-on-write style group reference

LibWeb: Add internals.computedValuesStats()

LibWeb: Move the CSS Rust code into its own crate under CSS/Rust

LibWeb: Skip inset reconstruction when no inset value is calculated

LibWeb: Intern small pixel lengths and common percentage values

LibWeb: Intern keyword, small integer and common number style values

LibWeb: Dispatch the color and iteration helpers by type tag

LibWeb: Dispatch absolutized by type tag

LibWeb: Dispatch equals by type tag

LibWeb: Dispatch serialize by type tag

LibWeb: Dispatch is_computationally_independent by type tag

LibWeb: Dispatch four style value operations by type tag

LibWeb: Materialize easing and basic shape data eagerly

LibWeb: Merge the color base data into the color variant payloads

LibWeb: Store border-radius and filter values in Rust-owned data

LibWeb: Hoist the Rust value handle into the StyleValue base class

LibWeb: Generate retained list impls in Rust with a macro

LibWeb: Share the style value pointer list marshalling helper

LibWeb: Update style value comments now that the conversion is done

LibWeb: Compare radial size components by value

LibWeb: Store image values in Rust-owned data

LibWeb: Store calculated values in Rust-owned data

LibWeb: Store basic shape values in Rust-owned data

LibWeb: Store grid track size lists in Rust-owned data

LibWeb: Store easing values in Rust-owned data

LibWeb: Store grid-template-areas values in Rust-owned data

LibWeb: Store conic and radial gradient values in Rust-owned data

LibWeb: Store linear gradient values in Rust-owned data

LibWeb: Store image-set values in Rust-owned data

LibWeb: Store color-mix values in Rust-owned data

LibWeb: Store color function values in Rust-owned data

LibWeb: Store the color style value base data in Rust

LibWeb: Store cursor values in Rust-owned data

LibWeb: Store counter style values in Rust-owned data

LibWeb: Store counter definitions and grid placements in Rust data

LibWeb: Store color-scheme and unresolved values in Rust-owned data

LibWeb: Store font source values in Rust-owned data

LibWeb: Store url() style values in Rust-owned data

LibWeb: Store radial size values in Rust-owned data

LibWeb: Store display values in Rust-owned data

LibWeb: Store tuple, transformation and shorthand values in Rust data

LibWeb: Store style value lists in Rust-owned data

LibWeb: Store four more style value types in Rust-owned data

LibWeb: Store position, shadow, content and counter values in Rust data

LibWeb: Store background, border-image and anchor values in Rust data

LibWeb: Store six more style value types in Rust-owned data

LibWeb: Store string and custom-ident values in Rust-owned data

LibWeb: Store ten more style value types in Rust-owned data

LibWeb: Store unicode-range, opacity and edge values in Rust-owned data

LibWeb: Store ratio style values in Rust-owned data

LibWeb: Store dimension style values in Rust-owned data

LibWeb: Store number and integer style values in Rust-owned data

LibWeb: Store KeywordStyleValue's data in a Rust-owned allocation

LibSandbox: Allow utimensat() in the filesystem write seccomp group

LibWeb: Add a Rust-owned style value data representation

LibUnicode: Gate Rust IDNA bindings behind a feature

LibWeb: Restore Rust :has() matching state with a guard

LibWeb: Tighten Rust selector FFI ownership

LibWeb: Document Rust selector matching

LibWeb: Generate the Rust selector matching FFI

LibWeb: Harden the Rust selector matching FFI

LibWeb: Compare interned strings in Rust selector matching callbacks

LibWeb: Cover An+B matching with step size 1 and a negative offset

LibWeb: Reject slots in ::slotted() before matching the argument

LibWeb: Characterize ::slotted() argument matching against slot elements

LibWeb: Count nth-child siblings under fragment roots

LibWeb: Widen Rust An+B matching arithmetic

LibWeb: Remove the C++ selector engine

LibWeb: Use the Rust selector matcher

LibWeb: Preserve :has() matching fast paths in Rust

LibWeb: Match borrowed DOM nodes through Rust

LibWeb: Port selector traversal to Rust

LibWeb: Compile selectors into a Rust representation

LibWeb: Add a Rust selector matching representation

LibWeb: Characterize selector matching behavior

LibWeb+WebContent+Compositor: Stream WebGL commands via shared memory

LibWeb: Split WebGL record layout and writing out of append_bytes

LibWeb: Collect partial relayout boundaries at dispatch time

LibWeb: Track partial relayout roots as generic layout boxes

LibWeb: Make formatting context factory functions static

LibWeb: Assign layout indices when layout nodes are constructed

LibWeb: Funnel post-layout-commit refreshes through one shared path

LibWeb: Propagate marks on already-dirty SVG partial relayout roots

LibWeb: Reinsert partial relayout roots at their paint tree position

LibWeb: Reassign scroll frames and text blocks after partial relayout

LibWeb: Don't use nested SVG roots as partial relayout boundaries

LibWeb: Simplify Rust HTML element insertion helper

Tests/LibWeb: Sync custom elements inner HTML tests with WPT

LibWeb: Store DOM names as UTF-16

LibWeb: Return CSS tokenizer payloads as UTF-16

LibWeb: Store XML namespace map values as UTF-16

LibWeb: Store web storage maps as UTF-16

LibWebView: Serialize history target names as UTF-8

LibWeb: Store CSS names as UTF-16

LibWeb: Avoid UTF-8 conversion for attr lookups

LibWeb: Store DOM and CSS identifiers as UTF-16

LibWeb: Store module specifiers and types as UTF-16

LibWeb: Use UTF-16 input values directly

LibWeb: Store WebCrypto algorithm names as UTF-16

LibWeb: Make explicit UTF-8 DOM attribute boundaries

LibWeb: Keep remaining HTML attribute paths as UTF-16

LibWeb: Parse CSS text from UTF-16 inputs

LibWeb: Serialize and reflect more attributes as UTF-16

LibWeb: Keep stylesheet and ARIA attributes as UTF-16

LibWeb: Take UTF-16 views in CSS parser helpers

LibWeb: Match element languages as UTF-16

LibWeb: Expose DOM node values as UTF-16

LibWeb: Store slot and part names as UTF-16 fly strings

LibWeb: Parse metadata attributes from UTF-16

LibWeb: Use UTF-16 SVG attribute values

LibWeb: Keep more HTML attribute consumers as UTF-16

LibWeb: Keep select item labels as UTF-16

LibWeb: Expose document colors as UTF-16

LibWeb: Format script src debug logs as UTF-16

LibWeb: Expose label htmlFor as UTF-16

LibWeb: Search CSP nonce attributes as UTF-16

LibWeb: Check supported image types as UTF-16

LibWeb: Parse legacy font sizes as UTF-16

LibWeb: Parse table alignment as UTF-16

LibWeb: Parse dimension values as UTF-16

LibWeb: Parse MathML scriptlevel as UTF-16

LibWeb: Keep DOM string-valued surfaces as UTF-16

LibWeb: Store DOMTokenList tokens as UTF-16

LibWeb: Expose reflected string attributes as UTF-16

LibWeb: Parse table border attributes as UTF-16

LibWeb: Parse input type attributes as UTF-16

LibWeb: Parse noopener link types as UTF-16

LibWeb: Match auto sizes as UTF-16

LibWeb: Parse link rel keywords as UTF-16

LibWeb: Translate preload destinations as UTF-16

LibWeb: Parse form attribute keywords as UTF-16

LibWeb: Use UTF-16 URL parsing overloads

LibWeb: Parse meta referrer content as UTF-16

LibWeb: Store TextTrack strings as UTF-16

LibWeb: Parse fetchpriority attributes as UTF-16

LibWeb: Parse referrer policy attributes as UTF-16

LibWeb: Parse table span attributes as UTF-16

LibWeb: Parse HTML numbers from Utf16View directly

LibWeb: Store CSS attr selector values as Utf16String

LibWeb: Store DOM attribute values as Utf16String

CI: Bump rust-toolchain from 1.96.0 to 1.96.1

CI: Warm up the pinned Rust toolchain in the setup action

LibJS: Ensure asmintgen works even when CARGO_TARGET_DIR is set

Meta: Accept $RUSTC_WRAPPER from env during configure

Meta: Stop compilers from spamming terminal during build

Libraries: Clean up UTF-16 source text paths

Libraries: Use UTF-16 for JS-visible runtime strings

Libraries: Parse JS strings from UTF-16

LibJS: Remove primitive string UTF-8 paths

LibJS: Store primitive strings as UTF-16

LibRegex: Compile ECMAScript patterns from UTF-16

LibJS: Use Utf16StringBuilder for JSON and Temporal strings

LibJS: Use Utf16StringBuilder for more strings

LibJS: Use Utf16StringBuilder for JS string construction

AK: Add Utf16StringBuilder formatting helpers

AK: Add Utf16StringBuilder

LibTextCodec: Use encoding_rs for legacy codecs

LibURL: Use encoding_rs for form URL encoding

Tests: Import some encoding related WPT tests

LibTextCodec: Make StreamingDecoder own decoder lookup

LibWeb/Infra: Add some missing AK includes

LibWeb: Avoid TextCodec when parsing JSON bytes

Test/LibTextCodec: Remove noisy test debug log

Tests/LibTextCodec: Do not refer to concrete encoders/decoders

LibTextCodec: Remove unused PDFDocEncoding

Meta: Bump curl to 8.20.0#2

Meta: Bump vcpkg baseline

LibJS: Remove unused C++ local variable wrapper

LibJS: Remove unused bytecode instruction stream iterator

LibJS: Move bytecode block counting to Rust

LibJS: Remove obsolete bytecode dump formatting helpers

LibJS: Move bytecode instruction dumping to Rust

LibJS: Remove unused C++ bytecode block classes

LibJS: Sync AsmInt program counter before slow paths

LibJS: Pass instruction pointers to AsmInt slow paths

LibJS: Remove AsmInt slow path stats collection

LibJS: Remove JS_BYTECODE_DEBUG

LibJS: Call AsmInt directly from run_executable

LibJS: Remove unused VM interpreter helpers

LibJS: Move final simple opcodes into AsmInt

LibJS: Split AsmInt slow paths out of Interpreter.cpp

LibJS: Move instruction bodies into AsmInt slow paths

LibJS: Remove AsmInt generic fallback dispatch

LibJS: Move property and call handlers into AsmInt

LibJS: Move control and binding handlers into AsmInt

LibJS: Move simple bytecode handlers into AsmInt

LibJS: Remove generic bytecode interpreter

LibWeb: Reduce CSS parser token memory usage

CI: Bump lint-code.yml to the 2026.06.02 image, like the rest of CI

LibWeb: Suppress false-positive LSan report during WebWorker teardown

CI: Fix recurring Rust toolchain flake in the libjs-test262 job

Meta: Remove fuzzers that primarily exercise third-party libraries

LibWeb+LibJS: Remove rust_pipeline_available

LibJS: Merge bytecode cache validation walks

LibJS: Avoid revalidating cached bytecode executables

Tests: De-flake abortsignal-timeout by dropping its wall-clock assertion

Meta: Rebuild Rust crates when the toolchain changes, not just sources

LibJS: Validate cached bytecode once before materializing

LibWeb: Route content blocker Rust allocations through mimalloc

Meta: Revert to a stable rust compiler

LibWeb/SecureContexts: Correct the 127.0.0.0/8 trustworthiness check

LibURL: Prefer Types.h typedefs over inttypes.h

LibURL: Replace WTF-8 surrogates before Rust URL parsing

CI: Avoid in-place nightly toolchain update in lint setup

LibURL: Optimize ASCII path/query parsing

LibURL: Remove C++ URL Parser implementation

LibURL: Expose rust host parsing over FFI

LibURL: Remove C++ URLPattern implementation

LibURL: Implement URLPattern in Rust

LibURL: Implement a URL parser in rust

LibUnicode/Rust: Expose IDNA to_ascii to Rust

CI: Use latest Linux build image

LibRegex: Hide the Unicode allocator override behind a feature

LibURL: Remove unused EncodeURI percent encode set

Rust: Set import granularity to Item

LibWeb: Normalize decoded HTML string parsing

LibWeb: Refresh blocker CSS after relevant class/id changes

LibWeb: Use adblock-rust in ContentBlocker

LibWeb: Add adblock-rust FFI hooks

LibWeb/Rust: Prepare build.rs for multi-config cbindgen generation

LibJS: Track shared function data ownership

LibJS: Preserve runtime caches across executable swaps

LibJS: Add executable backing state

LibJS: Reuse cached constant buffers when materializing

LibJS: Borrow bytecode cache tables when materializing

LibJS: Pre-size bytecode materialization tables

LibWeb: Populate platform mouse event data

LibJS: Pass var environment binding counts through FFI

LibJS: Use element alignment for bytecode array offsets

LibJS: Track var coordinates in var environments

LibJS: Keep cached bytecode file-backed

LibJS: Emit eager environment coordinates in bytecode

LibJS: Split dynamic environment lookups from coordinates

LibJS: Store bytecode cache indexes instead of pointers

LibRegex: Link libregex_rust before LibUnicode

LibWeb: Honor requested CSS tokenizer encoding

LibWeb: Use Rust preload scanner

LibWeb: Add Rust preload scanner

LibWeb: Treat fragment parser documents as disconnected

LibWeb: Keep deferred document.close cleanup on its parser

LibWeb: Remove the C++ HTML tree builder

LibWeb: Make the Rust HTML parser unconditional

LibWeb: Align declarative shadow root parsing

LibWeb: Complete Rust HTML tree construction

LibWeb: Wire Rust parser scripts and fragments

LibWeb: Add initial Rust HTML tree construction

LibWeb: Add Rust HTML parser host plumbing

LibWeb: Avoid unsafe tokenizer state conversion

LibWeb: Support dump tools without resource loading

Utilities: Add dump-html-tree

LibRegex: Allow lone surrogate escapes in /v mode character classes

LibJS: Return "" for empty legacy RegExp static properties

LibRegex: Reject duplicate named groups in nested alternatives

LibJS: Reject impossible bytecode cache table counts

LibJS: Borrow bytecode cache executable tables

LibJS: Borrow bytecode cache constant tables

LibJS: Align bytecode cache UTF-16 payloads

LibJS: Borrow bytecode cache UTF-16 strings

LibJS: Borrow mapped bytecode cache executable bytes

RequestServer: Send bytecode cache sidecars as files

LibRequests: Propagate body file mapping failures

LibHTTP: Report cache reader body sizes

RequestServer: Reuse disk-cache files after downloads

LibWeb: Preserve file-backed HTTP cache bodies

RequestServer: Send disk cache hits as file-backed bodies

LibCore: Add immutable byte storage for mapped ranges

LibWeb: Replace the HTML tokenizer with Rust

LibWeb: Add HTML tokenizer dump tests

LibJS: Fix var declarations in direct eval inside catch blocks

LibWasm: Store opcodes in 32 bits

LibWeb: Decouple ModuleScript from WebAssemblyModule

LibJS: Stop persisting basic_block_start_offsets on Executable

LibJS: Drop source ranges from bytecode source maps

LibJS: Deduplicate adjacent source map entries during codegen

LibJS: Materialize compiled function bytecode lazily

LibWeb: Invalidate async wheel state on listener changes

LibWeb: Allow viewport async scroll with nested scrollers

LibWeb: Reject async wheels over nested navigables

LibWeb: Add compositor debug logging

LibWebView: Route wheel bypasses over Compositor IPC

LibWeb: Scroll the viewport on the compositor thread

LibWeb: Add compositor scroll state snapshots

LibWeb: Present frames through Compositor IPC

LibWeb: Move RenderingThread into Compositor

Meta: Treat Rust warnings as errors

Meta: Extract common Rust compilation functionality to a helper

LibJS: Remove unused Rust function

LibJS: Remove unused rust_compile_program function

LibJS: Materialize decoded bytecode cache blobs

LibJS: Match bytecode cache blobs to their source

LibJS: Decode bytecode cache blobs over FFI

LibJS: Cache declaration function bytecode

LibJS: Return decoded bytecode cache blobs

LibJS: Decode bytecode cache executable records

LibJS: Persist bytecode cache declaration metadata

LibJS: Tag bytecode cache blobs with program type

LibJS: Validate bytecode cache blob records

LibJS: Serialize compiled bytecode cache blobs

LibJS: Split full off-thread script compilation

RequestServer: Expose cache sidecars over IPC

LibHTTP: Store associated data with disk cache entries

LibWeb: Compile remaining script functions in background

LibJS: Add off-thread function bytecode artifacts

LibJS: Move ScopeData into ScopeArena and reference it by ScopeId

LibJS: Intern identifier names in a per-arena string table

LibJS: Drop Cell<> wrappers from Identifier scope-analysis fields

LibJS: Move identifiers into a contiguous IdentifierArena

LibJS: Make CompiledRegex thread-safe with Arc + AtomicPtr

LibJS: Add AST arena types for identifiers, scopes, and interned strings

LibJS+LibWeb: Track Rust archive as input in static-lib merge

LibWeb: Stream Rust CSS tokenizer tokens over FFI

Tests: Add --silent mode to css-tokenizer utility

LibWeb/CSS: Avoid reconsume-then-consume dance in Rust tokenizer

LibWeb/CSS: Use a Rust enum for the internal Token type

LibWeb/CSS: Use Range for Rust Token ranged fields

LibWeb/CSS: Replace series of ifs in consume_a_token() with a match

LibWeb/CSS: Use tuples instead of U32Twin and U32Triplet

LibWeb/CSS: Rename next_code_point() to consume_code_point()

LibWeb/CSS: Port the CSS Tokenizer to Rust

LibWeb/CSS: Add missing spec comment to consume_string_token()

LibWeb/CSS: Stop using a define for the replacement character

LibJS: Range-check enum-typed bytecode fields in the validator

LibJS: Tighten the bytecode validator's argument operand bound

LibJS: Add negative tests for the bytecode validator

LibJS: Validate basic blocks, exception handlers, and source map

LibJS: Add per-field bytecode validation generated from Bytecode.def

LibJS: Add bytecode validator scaffolding driven from Bytecode.def

Devcontainer: Install rust via devcontainer feature

LibGfx: Add the mimalloc allocator shim to liblagom-gfx.so

LibJS: Build functions_to_initialize in source order

LibJS: Use natural source positions for parser-synthesized identifiers

LibJS: Replace in_property_key_context flag with explicit consume helper

LibJS: Precompile top-level IIFEs off-thread

LibWeb+LibJS: Compile fetched top-level JS off-thread

LibJS: Resolve VM constants during executable creation

LibJS: Defer function data materialization

LibJS: Track nested function ids during Rust parsing

LibJS: Preserve source positions in bytecode source maps

LibWebView: Add bookmark import/export to about:bookmarks

LibJS: Make bytecode register allocator O(1)

LibJS+LibUnicode: Use LibUnicode as appropriate for lexing JavaScript

LibRegex+LibUnicode: Migrate Unicode Rust FFI methods to LibUnicode

LibUnicode: Hide the Unicode allocator override behind a feature


-- Total Rust changes: 1012293 insertions, 328945 deletions

-- Total Non-Rust Code changes: 273234 insertions, 524760 deletions

-- Total Non-code changes: 365676 insertions, 455940 deletions

-- Total New Rust ratio: 199.9321220632552%


Lines of Code

-- Rust Adoption Rate: 57.721381789925495%


More Rust than Churn? YES (Churn: code[251526] + non-rust[90264] = 341790, Rust: 683348)