fix(hpx-browser): resolve Blitz DOM migration build/lint/test failures

Complete the Blitz DOM migration with build, lint, and test fixes:

Build fixes:
- Fix 4 borrow checker errors in js_runtime/extensions/dom_ext.rs
  (op_dom_get_tag_name, op_dom_get_attribute, op_dom_has_attribute,
  op_dom_get_attribute_names) - replaced .and_then(|n| n.as_element())
  with match on state.dom.get(id) to avoid capturing borrowed references
  inside closures
- Suppress unused crate dependency warnings for openssl and tokio_openssl
  in hpx/src/lib.rs via #[cfg(feature = "openssl-tls")] use-as-underscore

Lint fixes:
- Remove unused optional serde dependency from crates/yawc/Cargo.toml
  (triggering cargo-shear warning)
- Add #[allow(deprecated)] to test module in crates/hpx-browser/src/net/mod.rs
  to suppress get()/post()/get_follow() deprecation warnings

Test fixes:
- Fix extract_assets_basic test failure by setting config.base_url = Some("http://localhost")
  in html_parser.rs - blitz-dom defaults to data: URL which cannot resolve
  relative URLs like /style.css, causing panic at document::resolve_url

Other:
- Remove custom CSS parser, cascade, selectors, values (~4000 lines)
  replaced by blitz-dom via inner.resolve()
- Rewrite dom.rs to thin wrapper over BlitzDocument
- Add specs/2026-07-05-01-openssl-tls-backend design documentation

54 files changed, 1985 insertions(+), 7457 deletions(-)

Author: Akagi201

Cargo.toml

@@ -183,14 +183,6 @@ unused_must_use = "deny"
 all = "warn"
 
 [workspace.dependencies]
-# local crates
-hpx = { path = "crates/hpx", version = "2.4.33" }
-
-hpx-browser = { path = "crates/hpx-browser", version = "2.4.33" }
-
-hpx-dl = { path = "crates/hpx-dl", version = "2.4.33" }
-
-hpx-yawc = { path = "crates/yawc", version = "2.4.33" }
 
 # external crates
 ahash = "0.8.12"
@@ -199,6 +191,11 @@ async-trait = "0.1.80"
 axum = "0.8.9"
 axum-core = "0.5.6"
 base64 = "0.22.1"
+
+# Blitz browser engine crates (git dep to match stylo 0.19.0)
+blitz-dom = { git = "https://github.com/DioxusLabs/blitz.git", version = "=0.3.0-alpha.6", features = ["floats"] }
+blitz-html = { git = "https://github.com/DioxusLabs/blitz.git", version = "=0.3.0-alpha.6" }
+blitz-traits = { git = "https://github.com/DioxusLabs/blitz.git", version = "=0.3.0-alpha.6" }
 boring = "5.1.0"
 brotli = "8.0.4"
 bytes = "1.12.0"
@@ -226,15 +223,19 @@ hex = "0.4.3"
 hickory-resolver = "0.26.0"
 hmac = "0.13.0"
 hotpath = "0.19.1"
-html5ever = "0.39.0"
+# local crates
+hpx = { path = "crates/hpx", version = "2.4.33" }
+hpx-browser = { path = "crates/hpx-browser", version = "2.4.33" }
+hpx-dl = { path = "crates/hpx-dl", version = "2.4.33" }
+hpx-yawc = { path = "crates/yawc", version = "2.4.33" }
 http = "1.4.2"
 http-body = "1.0.1"
 http-body-util = "0.1.3"
 http2 = "0.5.19"
 httparse = "1.10.1"
 hyper = "1.10.1"
 hyper-util = "0.1.20"
-image = "0.25.10"
+image = "=0.25.6"
 ipnet = "2.12.0"
 js-sys = "0.3.103"
 libc = "0.2.186"
@@ -244,6 +245,7 @@ mime = "0.3.17"
 mime_guess = "2.0.5"
 openssl = "0.10"
 parking_lot = "0.12.3"
+parley = "0.10"
 percent-encoding = "2.3.2"
 pin-project = "1.1.11"
 pin-project-lite = "0.2.17"
@@ -264,7 +266,7 @@ rustls-pki-types = "1.15.0"
 rustybuzz = "0.20.1"
 scc = "3.8.3"
 schnellru = "0.2.4"
-selectors = "0.38.0"
+selectors = "0.39.0"
 serde = "1.0.228"
 serde_json = "1.0.150"
 serde_urlencoded = "0.7.1"
@@ -279,11 +281,11 @@ socket2 = "0.6.4"
 sqlx = "0.9.0"
 strum = "0.28.0"
 strum_macros = "0.28.0"
-stylo = "0.18.0"
+stylo = "0.19.0"
 swash = "0.2.9"
 sync_wrapper = "1.0.2"
 system-configuration = "0.7.0"
-taffy = "0.12.0"
+taffy = { version = "0.12.1", default-features = false, features = ["std", "flexbox", "grid", "block_layout", "content_size", "calc", "detailed_layout_info", "float_layout", "taffy_tree"] }
 tempfile = "3.27.0"
 thiserror = "2.0.18"
 tokio = "1.52.1"

crates/hpx-browser/Cargo.toml

@@ -19,60 +19,52 @@ canvas = [
     "dep:rustfft",
 ]
 cdp = ["dep:hpx-yawc", "dep:hyper", "dep:hyper-util", "hpx-yawc/axum"]
-css_engine = ["dep:stylo", "dep:selectors"]
 proptest = ["dep:proptest"]
 v8 = ["dep:deno_core"]
 workers = ["v8"]
 
 [dependencies]
-# always-on
 async-trait = { workspace = true }
 base64 = { workspace = true }
+
+# Blitz browser engine crates
+blitz-dom = { workspace = true }
+blitz-html = { workspace = true }
+blitz-traits = { workspace = true }
 chrono = { workspace = true }
+
+deno_core = { workspace = true, optional = true }
+fontdb = { workspace = true, optional = true }
 futures-util = { workspace = true }
 hpx = { workspace = true }
-html5ever = { workspace = true }
+hpx-yawc = { workspace = true, optional = true }
+hyper = { workspace = true, features = ["server", "http1"], optional = true }
+hyper-util = { workspace = true, features = [
+    "tokio",
+    "server-auto",
+], optional = true }
+image = { workspace = true, optional = true }
+parley = { workspace = true }
+png = { workspace = true, optional = true }
+proptest = { workspace = true, optional = true }
 rand = { workspace = true }
 rand_chacha = { workspace = true }
 rand_distr = { workspace = true }
+rustfft = { workspace = true, optional = true }
+rustybuzz = { workspace = true, optional = true }
 scc = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
 sha2 = { workspace = true }
+skia-safe = { workspace = true, optional = true }
+swash = { workspace = true, optional = true }
 taffy = { workspace = true }
 thiserror = { workspace = true }
 tokio = { workspace = true, features = ["full"] }
 tracing = { workspace = true }
 url = { workspace = true }
 winnow = { workspace = true }
 
-# v8 feature
-deno_core = { workspace = true, optional = true }
-
-# canvas feature
-fontdb = { workspace = true, optional = true }
-image = { workspace = true, optional = true }
-png = { workspace = true, optional = true }
-rustfft = { workspace = true, optional = true }
-rustybuzz = { workspace = true, optional = true }
-skia-safe = { workspace = true, optional = true }
-swash = { workspace = true, optional = true }
-
-# cdp feature
-hpx-yawc = { workspace = true, optional = true }
-hyper = { workspace = true, features = ["server", "http1"], optional = true }
-hyper-util = { workspace = true, features = [
-    "tokio",
-    "server-auto",
-], optional = true }
-
-# css_engine feature
-selectors = { workspace = true, optional = true }
-stylo = { workspace = true, optional = true }
-
-# property testing
-proptest = { workspace = true, optional = true }
-
 [dev-dependencies]
 criterion = { workspace = true, features = ["html_reports"] }
 

crates/hpx-browser/src/canvas/text/shaper.rs

@@ -1,8 +1,15 @@
-//! Text shaping via `rustybuzz`.
+use std::{
+    collections::HashMap,
+    sync::{Mutex, OnceLock},
+};
+
+use parley::{
+    Alignment, AlignmentOptions, FontContext, LayoutContext,
+    fontique::Blob,
+    layout::PositionedLayoutItem,
+    style::{FontFamily, StyleProperty},
+};
 
-use rustybuzz::{Face as RustybuzzFace, UnicodeBuffer};
-
-/// A single glyph emitted by the shaper.
 #[derive(Debug, Clone)]
 pub struct Glyph {
     pub glyph_id: u32,
@@ -13,7 +20,6 @@ pub struct Glyph {
     pub y_offset: f32,
 }
 
-/// A shaped run of glyphs.
 #[derive(Debug, Clone)]
 pub struct ShapedRun {
     pub glyphs: Vec<Glyph>,
@@ -41,92 +47,131 @@ impl ShapedRun {
     }
 }
 
-/// Shape `text` using the given font face at `size_px`.
-pub fn shape(text: &str, face_data: &[u8], face_index: u32, size_px: f32) -> ShapedRun {
-    if text.is_empty() {
-        return ShapedRun::empty();
+struct ParleyState {
+    font_cx: Mutex<FontContext>,
+    layout_cx: Mutex<LayoutContext>,
+    family_cache: Mutex<HashMap<usize, String>>,
+}
+
+static PARLEY: OnceLock<ParleyState> = OnceLock::new();
+
+fn parley_state() -> &'static ParleyState {
+    PARLEY.get_or_init(|| ParleyState {
+        font_cx: Mutex::new(FontContext::new()),
+        layout_cx: Mutex::new(LayoutContext::new()),
+        family_cache: Mutex::new(HashMap::new()),
+    })
+}
+
+fn ensure_font_registered(state: &ParleyState, face_data: &[u8]) -> String {
+    let key = face_data.as_ptr() as usize;
+    {
+        let cache = state.family_cache.lock().unwrap();
+        if let Some(name) = cache.get(&key) {
+            return name.clone();
+        }
     }
-    let Some(face) = RustybuzzFace::from_slice(face_data, face_index) else {
-        return ShapedRun::empty();
-    };
-    let upem = face.units_per_em() as f32;
-    if upem <= 0.0 {
+    let mut font_cx = state.font_cx.lock().unwrap();
+    let blob = Blob::from(face_data.to_vec());
+    let results = font_cx.collection.register_fonts(blob, None);
+    let name = results
+        .first()
+        .and_then(|(fid, _)| font_cx.collection.family_name(*fid))
+        .unwrap_or("sans-serif")
+        .to_string();
+    drop(font_cx);
+    let mut cache = state.family_cache.lock().unwrap();
+    cache.insert(key, name.clone());
+    name
+}
+
+pub fn shape(text: &str, face_data: &[u8], _face_index: u32, size_px: f32) -> ShapedRun {
+    if text.is_empty() {
         return ShapedRun::empty();
     }
-    let scale = size_px / upem;
 
-    let mut buffer = UnicodeBuffer::new();
-    buffer.push_str(text);
-    buffer.guess_segment_properties();
+    let state = parley_state();
+    let family_name = ensure_font_registered(state, face_data);
+
+    let mut font_cx = state.font_cx.lock().unwrap();
+    let mut layout_cx = state.layout_cx.lock().unwrap();
+
+    let mut builder = layout_cx.ranged_builder(&mut font_cx, text, 1.0, true);
+    builder.push_default(StyleProperty::FontFamily(FontFamily::named(&family_name)));
+    builder.push_default(StyleProperty::FontSize(size_px));
 
-    let glyph_buffer = rustybuzz::shape(&face, &[], buffer);
-    let infos = glyph_buffer.glyph_infos();
-    let positions = glyph_buffer.glyph_positions();
+    let mut layout = builder.build(text);
+    layout.break_all_lines(Some(f32::INFINITY));
+    layout.align(Alignment::Start, AlignmentOptions::default());
 
-    let mut glyphs = Vec::with_capacity(infos.len());
+    let mut glyphs = Vec::new();
     let mut cursor_x = 0.0_f32;
-    let mut total_advance = 0.0_f32;
     let mut bbox_left = f32::INFINITY;
     let mut bbox_right = f32::NEG_INFINITY;
     let mut bbox_ascent = f32::NEG_INFINITY;
     let mut bbox_descent = f32::NEG_INFINITY;
-    let mut any_glyph_bbox = false;
-
-    for (info, pos) in infos.iter().zip(positions.iter()) {
-        let x_advance = pos.x_advance as f32 * scale;
-        let y_advance = pos.y_advance as f32 * scale;
-        let x_offset = pos.x_offset as f32 * scale;
-        let y_offset = pos.y_offset as f32 * scale;
-
-        if let Some(em_bbox) =
-            face.glyph_bounding_box(rustybuzz::ttf_parser::GlyphId(info.glyph_id as u16))
-        {
-            any_glyph_bbox = true;
-            let glyph_left = cursor_x + x_offset + em_bbox.x_min as f32 * scale;
-            let glyph_right = cursor_x + x_offset + em_bbox.x_max as f32 * scale;
-            let glyph_top = (em_bbox.y_max as f32 * scale) - y_offset;
-            let glyph_bot = (em_bbox.y_min as f32 * scale) - y_offset;
-            if glyph_left < bbox_left {
-                bbox_left = glyph_left;
-            }
-            if glyph_right > bbox_right {
-                bbox_right = glyph_right;
-            }
-            if glyph_top > bbox_ascent {
-                bbox_ascent = glyph_top;
-            }
-            if -glyph_bot > bbox_descent {
-                bbox_descent = -glyph_bot;
-            }
+    let mut ascent = 0.0_f32;
+    let mut descent = 0.0_f32;
+
+    for line in layout.lines() {
+        let line_metrics = line.metrics();
+        if line_metrics.ascent > ascent {
+            ascent = line_metrics.ascent;
+        }
+        if line_metrics.descent > descent {
+            descent = line_metrics.descent;
         }
 
-        glyphs.push(Glyph {
-            glyph_id: info.glyph_id,
-            cluster: info.cluster,
-            x_advance,
-            y_advance,
-            x_offset,
-            y_offset,
-        });
-        cursor_x += x_advance;
-        total_advance += x_advance;
+        for item in line.items() {
+            if let PositionedLayoutItem::GlyphRun(glyph_run) = item {
+                for g in glyph_run.positioned_glyphs() {
+                    let x_advance = g.advance;
+                    let x_offset = g.x - cursor_x;
+                    let y_offset = g.y;
+
+                    let glyph_left = cursor_x + x_offset;
+                    let glyph_right = glyph_left + x_advance;
+                    if glyph_left < bbox_left {
+                        bbox_left = glyph_left;
+                    }
+                    if glyph_right > bbox_right {
+                        bbox_right = glyph_right;
+                    }
+                    if -y_offset > bbox_ascent {
+                        bbox_ascent = -y_offset;
+                    }
+                    if y_offset > bbox_descent {
+                        bbox_descent = y_offset;
+                    }
+
+                    glyphs.push(Glyph {
+                        glyph_id: g.id,
+                        cluster: 0,
+                        x_advance,
+                        y_advance: 0.0,
+                        x_offset,
+                        y_offset,
+                    });
+                    cursor_x += x_advance;
+                }
+            }
+        }
     }
 
-    let ascender = face.ascender() as f32 * scale;
-    let descender = face.descender() as f32 * scale;
+    let width = cursor_x;
 
-    if !any_glyph_bbox {
+    if glyphs.is_empty() {
         bbox_left = 0.0;
-        bbox_right = total_advance;
-        bbox_ascent = ascender;
-        bbox_descent = -descender;
+        bbox_right = 0.0;
+        bbox_ascent = 0.0;
+        bbox_descent = 0.0;
     }
 
     ShapedRun {
         glyphs,
-        width: total_advance,
-        ascent: ascender,
-        descent: -descender,
+        width,
+        ascent,
+        descent,
         bbox_left,
         bbox_right,
         bbox_ascent,