From 79c454638450211d53b3756d2f6c05af20e6be62 Mon Sep 17 00:00:00 2001
From: Pierre Le Fevre <hello@pierrelf.com>
Date: Sat, 21 Mar 2026 13:31:32 +0100
Subject: [PATCH] Implement CSS resource loading: <link rel="stylesheet"> and
 <style> support

Add css_loader module to the browser crate that collects CSS from the DOM:
- Scan DOM for <style> elements (inline CSS) and <link rel="stylesheet"> (external)
- Fetch external stylesheets via ResourceLoader with encoding detection
- Resolve @import rules recursively (max depth 5 to prevent cycles)
- Basic media attribute support (screen, all)
- Type attribute validation (text/css default)
- Graceful degradation: failed loads are silently skipped
- Merge all rules into a single Stylesheet in document order

37 tests covering DOM scanning, classification, media matching, text
collection, import resolution, error handling, and edge cases.

Implements issue 3mhkt6vtv3q2g

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 crates/browser/src/css_loader.rs | 895 +++++++++++++++++++++++++++++++
 crates/browser/src/lib.rs        |   1 +
 2 files changed, 896 insertions(+)
 create mode 100644 crates/browser/src/css_loader.rs

diff --git a/crates/browser/src/css_loader.rs b/crates/browser/src/css_loader.rs
new file mode 100644
index 0000000..301adb9
--- /dev/null
+++ b/crates/browser/src/css_loader.rs
@@ -0,0 +1,895 @@
+//! CSS resource loading: collect stylesheets from `<link>` and `<style>` elements.
+//!
+//! After HTML parsing, this module scans the DOM for stylesheet references,
+//! fetches external CSS resources, resolves `@import` rules, and merges
+//! everything into a single `Stylesheet` for style resolution.
+
+use we_css::parser::{ImportRule, Parser, Rule, Stylesheet};
+use we_dom::{Document, NodeData, NodeId};
+use we_url::Url;
+
+use crate::loader::{LoadError, Resource, ResourceLoader};
+
+/// Maximum depth for `@import` resolution to prevent cycles.
+const MAX_IMPORT_DEPTH: usize = 5;
+
+/// Errors that can occur during CSS loading.
+#[derive(Debug)]
+pub enum CssLoadError {
+    /// A resource failed to load.
+    Load(LoadError),
+    /// The fetched resource was not CSS.
+    NotCss { url: String },
+}
+
+impl std::fmt::Display for CssLoadError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Load(e) => write!(f, "CSS load error: {e}"),
+            Self::NotCss { url } => write!(f, "resource at {url} is not CSS"),
+        }
+    }
+}
+
+impl From<LoadError> for CssLoadError {
+    fn from(e: LoadError) -> Self {
+        Self::Load(e)
+    }
+}
+
+/// Collect all CSS rules from a parsed DOM document.
+///
+/// Scans the DOM in document order for `<style>` elements and
+/// `<link rel="stylesheet">` elements. Inline `<style>` content is parsed
+/// directly; external stylesheets are fetched via the `ResourceLoader`.
+///
+/// All rules are merged into a single `Stylesheet` in document order,
+/// preserving cascade source order. Failed loads are silently skipped
+/// (graceful degradation).
+pub fn collect_stylesheets(
+    doc: &Document,
+    loader: &mut ResourceLoader,
+    base_url: &Url,
+) -> Stylesheet {
+    let mut all_rules: Vec<Rule> = Vec::new();
+    let mut style_nodes = Vec::new();
+    collect_style_nodes(doc, doc.root(), &mut style_nodes);
+
+    for node in style_nodes {
+        match classify_style_node(doc, node) {
+            StyleSource::InlineStyle(css_text) => {
+                let sheet = Parser::parse(&css_text);
+                let resolved = resolve_imports(sheet, loader, base_url, 0);
+                all_rules.extend(resolved.rules);
+            }
+            StyleSource::ExternalLink { href, media } => {
+                if !media_matches(&media) {
+                    continue;
+                }
+                match fetch_stylesheet(loader, &href, base_url, 0) {
+                    Ok(sheet) => all_rules.extend(sheet.rules),
+                    Err(_) => {
+                        // Graceful degradation: skip failed stylesheet loads.
+                    }
+                }
+            }
+            StyleSource::NotStylesheet => {}
+        }
+    }
+
+    Stylesheet { rules: all_rules }
+}
+
+/// Walk the DOM in document order and collect `<style>` and `<link>` nodes.
+fn collect_style_nodes(doc: &Document, node: NodeId, result: &mut Vec<NodeId>) {
+    if let NodeData::Element { tag_name, .. } = doc.node_data(node) {
+        let tag = tag_name.as_str();
+        if tag.eq_ignore_ascii_case("style") || tag.eq_ignore_ascii_case("link") {
+            result.push(node);
+        }
+    }
+    for child in doc.children(node) {
+        collect_style_nodes(doc, child, result);
+    }
+}
+
+/// Classification of a DOM node as a style source.
+enum StyleSource {
+    /// A `<style>` element with inline CSS text.
+    InlineStyle(String),
+    /// A `<link rel="stylesheet">` element with an `href`.
+    ExternalLink { href: String, media: Option<String> },
+    /// Not a stylesheet source.
+    NotStylesheet,
+}
+
+/// Classify a DOM node as a style source.
+fn classify_style_node(doc: &Document, node: NodeId) -> StyleSource {
+    let tag = match doc.tag_name(node) {
+        Some(t) => t,
+        None => return StyleSource::NotStylesheet,
+    };
+
+    if tag.eq_ignore_ascii_case("style") {
+        // Check type attribute — only text/css is valid (or omitted, which defaults to text/css)
+        if let Some(type_attr) = doc.get_attribute(node, "type") {
+            if !type_attr.eq_ignore_ascii_case("text/css") {
+                return StyleSource::NotStylesheet;
+            }
+        }
+        // Collect text content from child text nodes
+        let css_text = collect_text_content(doc, node);
+        StyleSource::InlineStyle(css_text)
+    } else if tag.eq_ignore_ascii_case("link") {
+        // Must have rel="stylesheet"
+        let rel = doc.get_attribute(node, "rel").unwrap_or("");
+        if !rel
+            .split_ascii_whitespace()
+            .any(|r| r.eq_ignore_ascii_case("stylesheet"))
+        {
+            return StyleSource::NotStylesheet;
+        }
+        // Check type attribute if present
+        if let Some(type_attr) = doc.get_attribute(node, "type") {
+            if !type_attr.eq_ignore_ascii_case("text/css") {
+                return StyleSource::NotStylesheet;
+            }
+        }
+        // Must have href
+        match doc.get_attribute(node, "href") {
+            Some(href) if !href.is_empty() => {
+                let media = doc.get_attribute(node, "media").map(|m| m.to_string());
+                StyleSource::ExternalLink {
+                    href: href.to_string(),
+                    media,
+                }
+            }
+            _ => StyleSource::NotStylesheet,
+        }
+    } else {
+        StyleSource::NotStylesheet
+    }
+}
+
+/// Collect concatenated text content from child text nodes of an element.
+fn collect_text_content(doc: &Document, node: NodeId) -> String {
+    let mut text = String::new();
+    for child in doc.children(node) {
+        if let Some(data) = doc.text_content(child) {
+            text.push_str(data);
+        }
+    }
+    text
+}
+
+/// Check if a `media` attribute value matches the `screen` environment.
+///
+/// Per spec, if no media attribute is present (None), it defaults to `all`.
+/// We support basic media types: `all`, `screen`.
+fn media_matches(media: &Option<String>) -> bool {
+    match media {
+        None => true, // default is "all"
+        Some(m) => {
+            let m = m.trim();
+            if m.is_empty() {
+                return true;
+            }
+            // Split comma-separated media types and check if any matches
+            m.split(',').any(|mt| {
+                let mt = mt.trim();
+                mt.eq_ignore_ascii_case("all") || mt.eq_ignore_ascii_case("screen")
+            })
+        }
+    }
+}
+
+/// Fetch an external stylesheet and resolve its `@import` rules.
+fn fetch_stylesheet(
+    loader: &mut ResourceLoader,
+    href: &str,
+    base_url: &Url,
+    depth: usize,
+) -> Result<Stylesheet, CssLoadError> {
+    let resource = loader.fetch_url(href, Some(base_url))?;
+
+    let (css_text, resolved_url) = match resource {
+        Resource::Css { text, url } => (text, url),
+        // Some servers may return text/plain or text/html for CSS files.
+        // Accept any text response gracefully.
+        Resource::Html { text, base_url, .. } => (text, base_url),
+        Resource::Other { data, url, .. } => {
+            // Try to decode as UTF-8 text
+            match String::from_utf8(data) {
+                Ok(text) => (text, url),
+                Err(_) => {
+                    return Err(CssLoadError::NotCss {
+                        url: href.to_string(),
+                    })
+                }
+            }
+        }
+        Resource::Image { .. } => {
+            return Err(CssLoadError::NotCss {
+                url: href.to_string(),
+            })
+        }
+    };
+
+    let sheet = Parser::parse(&css_text);
+    Ok(resolve_imports(sheet, loader, &resolved_url, depth))
+}
+
+/// Resolve `@import` rules in a stylesheet by fetching and inlining imported sheets.
+///
+/// Replaces `Rule::Import` entries with the imported stylesheet's rules.
+/// Respects `MAX_IMPORT_DEPTH` to prevent infinite loops.
+fn resolve_imports(
+    sheet: Stylesheet,
+    loader: &mut ResourceLoader,
+    base_url: &Url,
+    depth: usize,
+) -> Stylesheet {
+    if depth >= MAX_IMPORT_DEPTH {
+        // Strip import rules at max depth to prevent cycles
+        return Stylesheet {
+            rules: sheet
+                .rules
+                .into_iter()
+                .filter(|r| !matches!(r, Rule::Import(_)))
+                .collect(),
+        };
+    }
+
+    let mut resolved_rules: Vec<Rule> = Vec::new();
+
+    for rule in sheet.rules {
+        match rule {
+            Rule::Import(ImportRule { ref url }) => {
+                match fetch_stylesheet(loader, url, base_url, depth + 1) {
+                    Ok(imported) => resolved_rules.extend(imported.rules),
+                    Err(_) => {
+                        // Graceful degradation: skip failed imports.
+                    }
+                }
+            }
+            other => resolved_rules.push(other),
+        }
+    }
+
+    Stylesheet {
+        rules: resolved_rules,
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use we_css::parser::StyleRule;
+
+    // -----------------------------------------------------------------------
+    // Helper: build a DOM manually for testing
+    // -----------------------------------------------------------------------
+
+    fn make_doc_with_style(css: &str) -> Document {
+        let mut doc = Document::new();
+        let root = doc.root();
+
+        let html = doc.create_element("html");
+        doc.append_child(root, html);
+
+        let head = doc.create_element("head");
+        doc.append_child(html, head);
+
+        let style = doc.create_element("style");
+        doc.append_child(head, style);
+
+        let text = doc.create_text(css);
+        doc.append_child(style, text);
+
+        let body = doc.create_element("body");
+        doc.append_child(html, body);
+
+        doc
+    }
+
+    fn make_doc_with_link(href: &str) -> Document {
+        let mut doc = Document::new();
+        let root = doc.root();
+
+        let html = doc.create_element("html");
+        doc.append_child(root, html);
+
+        let head = doc.create_element("head");
+        doc.append_child(html, head);
+
+        let link = doc.create_element("link");
+        doc.set_attribute(link, "rel", "stylesheet");
+        doc.set_attribute(link, "href", href);
+        doc.append_child(head, link);
+
+        let body = doc.create_element("body");
+        doc.append_child(html, body);
+
+        doc
+    }
+
+    // -----------------------------------------------------------------------
+    // collect_style_nodes
+    // -----------------------------------------------------------------------
+
+    #[test]
+    fn collects_style_elements() {
+        let doc = make_doc_with_style("body { color: red; }");
+        let mut nodes = Vec::new();
+        collect_style_nodes(&doc, doc.root(), &mut nodes);
+        assert_eq!(nodes.len(), 1);
+        assert_eq!(doc.tag_name(nodes[0]), Some("style"));
+    }
+
+    #[test]
+    fn collects_link_elements() {
+        let doc = make_doc_with_link("style.css");
+        let mut nodes = Vec::new();
+        collect_style_nodes(&doc, doc.root(), &mut nodes);
+        assert_eq!(nodes.len(), 1);
+        assert_eq!(doc.tag_name(nodes[0]), Some("link"));
+    }
+
+    #[test]
+    fn collects_both_style_and_link() {
+        let mut doc = Document::new();
+        let root = doc.root();
+
+        let html = doc.create_element("html");
+        doc.append_child(root, html);
+
+        let head = doc.create_element("head");
+        doc.append_child(html, head);
+
+        let link = doc.create_element("link");
+        doc.set_attribute(link, "rel", "stylesheet");
+        doc.set_attribute(link, "href", "a.css");
+        doc.append_child(head, link);
+
+        let style = doc.create_element("style");
+        doc.append_child(head, style);
+        let text = doc.create_text("p { margin: 0; }");
+        doc.append_child(style, text);
+
+        let mut nodes = Vec::new();
+        collect_style_nodes(&doc, doc.root(), &mut nodes);
+        assert_eq!(nodes.len(), 2);
+        // Document order: link first, then style
+        assert_eq!(doc.tag_name(nodes[0]), Some("link"));
+        assert_eq!(doc.tag_name(nodes[1]), Some("style"));
+    }
+
+    #[test]
+    fn ignores_non_style_elements() {
+        let mut doc = Document::new();
+        let root = doc.root();
+
+        let html = doc.create_element("html");
+        doc.append_child(root, html);
+
+        let body = doc.create_element("body");
+        doc.append_child(html, body);
+
+        let p = doc.create_element("p");
+        doc.append_child(body, p);
+
+        let mut nodes = Vec::new();
+        collect_style_nodes(&doc, doc.root(), &mut nodes);
+        assert!(nodes.is_empty());
+    }
+
+    // -----------------------------------------------------------------------
+    // classify_style_node
+    // -----------------------------------------------------------------------
+
+    #[test]
+    fn classify_style_element() {
+        let doc = make_doc_with_style("body { color: red; }");
+        let mut nodes = Vec::new();
+        collect_style_nodes(&doc, doc.root(), &mut nodes);
+        match classify_style_node(&doc, nodes[0]) {
+            StyleSource::InlineStyle(text) => {
+                assert_eq!(text, "body { color: red; }");
+            }
+            _ => panic!("expected InlineStyle"),
+        }
+    }
+
+    #[test]
+    fn classify_link_stylesheet() {
+        let doc = make_doc_with_link("style.css");
+        let mut nodes = Vec::new();
+        collect_style_nodes(&doc, doc.root(), &mut nodes);
+        match classify_style_node(&doc, nodes[0]) {
+            StyleSource::ExternalLink { href, media } => {
+                assert_eq!(href, "style.css");
+                assert!(media.is_none());
+            }
+            _ => panic!("expected ExternalLink"),
+        }
+    }
+
+    #[test]
+    fn classify_link_with_media() {
+        let mut doc = Document::new();
+        let root = doc.root();
+
+        let link = doc.create_element("link");
+        doc.set_attribute(link, "rel", "stylesheet");
+        doc.set_attribute(link, "href", "screen.css");
+        doc.set_attribute(link, "media", "screen");
+        doc.append_child(root, link);
+
+        match classify_style_node(&doc, link) {
+            StyleSource::ExternalLink { href, media } => {
+                assert_eq!(href, "screen.css");
+                assert_eq!(media.as_deref(), Some("screen"));
+            }
+            _ => panic!("expected ExternalLink"),
+        }
+    }
+
+    #[test]
+    fn classify_link_without_rel_stylesheet() {
+        let mut doc = Document::new();
+        let root = doc.root();
+
+        let link = doc.create_element("link");
+        doc.set_attribute(link, "rel", "icon");
+        doc.set_attribute(link, "href", "favicon.ico");
+        doc.append_child(root, link);
+
+        assert!(matches!(
+            classify_style_node(&doc, link),
+            StyleSource::NotStylesheet
+        ));
+    }
+
+    #[test]
+    fn classify_link_without_href() {
+        let mut doc = Document::new();
+        let root = doc.root();
+
+        let link = doc.create_element("link");
+        doc.set_attribute(link, "rel", "stylesheet");
+        doc.append_child(root, link);
+
+        assert!(matches!(
+            classify_style_node(&doc, link),
+            StyleSource::NotStylesheet
+        ));
+    }
+
+    #[test]
+    fn classify_style_wrong_type() {
+        let mut doc = Document::new();
+        let root = doc.root();
+
+        let style = doc.create_element("style");
+        doc.set_attribute(style, "type", "text/javascript");
+        doc.append_child(root, style);
+        let text = doc.create_text("not css");
+        doc.append_child(style, text);
+
+        assert!(matches!(
+            classify_style_node(&doc, style),
+            StyleSource::NotStylesheet
+        ));
+    }
+
+    #[test]
+    fn classify_style_with_type_text_css() {
+        let mut doc = Document::new();
+        let root = doc.root();
+
+        let style = doc.create_element("style");
+        doc.set_attribute(style, "type", "text/css");
+        doc.append_child(root, style);
+        let text = doc.create_text("p { color: blue; }");
+        doc.append_child(style, text);
+
+        match classify_style_node(&doc, style) {
+            StyleSource::InlineStyle(css) => assert_eq!(css, "p { color: blue; }"),
+            _ => panic!("expected InlineStyle"),
+        }
+    }
+
+    #[test]
+    fn classify_link_wrong_type() {
+        let mut doc = Document::new();
+        let root = doc.root();
+
+        let link = doc.create_element("link");
+        doc.set_attribute(link, "rel", "stylesheet");
+        doc.set_attribute(link, "href", "style.css");
+        doc.set_attribute(link, "type", "text/plain");
+        doc.append_child(root, link);
+
+        assert!(matches!(
+            classify_style_node(&doc, link),
+            StyleSource::NotStylesheet
+        ));
+    }
+
+    // -----------------------------------------------------------------------
+    // collect_text_content
+    // -----------------------------------------------------------------------
+
+    #[test]
+    fn collect_text_single_child() {
+        let mut doc = Document::new();
+        let root = doc.root();
+
+        let style = doc.create_element("style");
+        doc.append_child(root, style);
+        let text = doc.create_text("body {}");
+        doc.append_child(style, text);
+
+        assert_eq!(collect_text_content(&doc, style), "body {}");
+    }
+
+    #[test]
+    fn collect_text_multiple_children() {
+        let mut doc = Document::new();
+        let root = doc.root();
+
+        let style = doc.create_element("style");
+        doc.append_child(root, style);
+        let t1 = doc.create_text("body { ");
+        let t2 = doc.create_text("color: red; }");
+        doc.append_child(style, t1);
+        doc.append_child(style, t2);
+
+        assert_eq!(collect_text_content(&doc, style), "body { color: red; }");
+    }
+
+    #[test]
+    fn collect_text_empty_element() {
+        let mut doc = Document::new();
+        let root = doc.root();
+
+        let style = doc.create_element("style");
+        doc.append_child(root, style);
+
+        assert_eq!(collect_text_content(&doc, style), "");
+    }
+
+    // -----------------------------------------------------------------------
+    // media_matches
+    // -----------------------------------------------------------------------
+
+    #[test]
+    fn media_none_matches() {
+        assert!(media_matches(&None));
+    }
+
+    #[test]
+    fn media_empty_matches() {
+        assert!(media_matches(&Some(String::new())));
+    }
+
+    #[test]
+    fn media_all_matches() {
+        assert!(media_matches(&Some("all".to_string())));
+    }
+
+    #[test]
+    fn media_screen_matches() {
+        assert!(media_matches(&Some("screen".to_string())));
+    }
+
+    #[test]
+    fn media_print_does_not_match() {
+        assert!(!media_matches(&Some("print".to_string())));
+    }
+
+    #[test]
+    fn media_comma_list_with_screen() {
+        assert!(media_matches(&Some("print, screen".to_string())));
+    }
+
+    #[test]
+    fn media_comma_list_without_screen() {
+        assert!(!media_matches(&Some("print, handheld".to_string())));
+    }
+
+    #[test]
+    fn media_case_insensitive() {
+        assert!(media_matches(&Some("SCREEN".to_string())));
+        assert!(media_matches(&Some("All".to_string())));
+    }
+
+    // -----------------------------------------------------------------------
+    // collect_stylesheets with inline <style>
+    // -----------------------------------------------------------------------
+
+    #[test]
+    fn collect_inline_style_rules() {
+        let doc = make_doc_with_style("p { color: red; } div { margin: 0; }");
+        let mut loader = ResourceLoader::new();
+        let base = Url::parse("http://example.com/").unwrap();
+
+        let sheet = collect_stylesheets(&doc, &mut loader, &base);
+        assert_eq!(sheet.rules.len(), 2);
+        // Both should be style rules
+        assert!(matches!(sheet.rules[0], Rule::Style(_)));
+        assert!(matches!(sheet.rules[1], Rule::Style(_)));
+    }
+
+    #[test]
+    fn collect_empty_style_element() {
+        let doc = make_doc_with_style("");
+        let mut loader = ResourceLoader::new();
+        let base = Url::parse("http://example.com/").unwrap();
+
+        let sheet = collect_stylesheets(&doc, &mut loader, &base);
+        assert!(sheet.rules.is_empty());
+    }
+
+    #[test]
+    fn collect_multiple_style_elements() {
+        let mut doc = Document::new();
+        let root = doc.root();
+
+        let html = doc.create_element("html");
+        doc.append_child(root, html);
+
+        let head = doc.create_element("head");
+        doc.append_child(html, head);
+
+        // First <style>
+        let style1 = doc.create_element("style");
+        doc.append_child(head, style1);
+        let t1 = doc.create_text("p { color: red; }");
+        doc.append_child(style1, t1);
+
+        // Second <style>
+        let style2 = doc.create_element("style");
+        doc.append_child(head, style2);
+        let t2 = doc.create_text("div { color: blue; }");
+        doc.append_child(style2, t2);
+
+        let mut loader = ResourceLoader::new();
+        let base = Url::parse("http://example.com/").unwrap();
+
+        let sheet = collect_stylesheets(&doc, &mut loader, &base);
+        assert_eq!(sheet.rules.len(), 2);
+    }
+
+    #[test]
+    fn collect_link_graceful_failure() {
+        // External link will fail to load (no real server), but should not crash
+        let doc = make_doc_with_link("http://nonexistent.test/style.css");
+        let mut loader = ResourceLoader::new();
+        let base = Url::parse("http://example.com/").unwrap();
+
+        let sheet = collect_stylesheets(&doc, &mut loader, &base);
+        // Should return empty stylesheet (graceful degradation)
+        assert!(sheet.rules.is_empty());
+    }
+
+    #[test]
+    fn link_with_print_media_skipped() {
+        let mut doc = Document::new();
+        let root = doc.root();
+
+        let html = doc.create_element("html");
+        doc.append_child(root, html);
+
+        let head = doc.create_element("head");
+        doc.append_child(html, head);
+
+        let link = doc.create_element("link");
+        doc.set_attribute(link, "rel", "stylesheet");
+        doc.set_attribute(link, "href", "print.css");
+        doc.set_attribute(link, "media", "print");
+        doc.append_child(head, link);
+
+        let mut loader = ResourceLoader::new();
+        let base = Url::parse("http://example.com/").unwrap();
+
+        let sheet = collect_stylesheets(&doc, &mut loader, &base);
+        // Print media link should be skipped entirely
+        assert!(sheet.rules.is_empty());
+    }
+
+    // -----------------------------------------------------------------------
+    // resolve_imports
+    // -----------------------------------------------------------------------
+
+    #[test]
+    fn resolve_imports_strips_at_max_depth() {
+        let sheet = Stylesheet {
+            rules: vec![
+                Rule::Import(ImportRule {
+                    url: "deep.css".to_string(),
+                }),
+                Rule::Style(StyleRule {
+                    selectors: we_css::parser::SelectorList {
+                        selectors: Vec::new(),
+                    },
+                    declarations: Vec::new(),
+                }),
+            ],
+        };
+
+        let mut loader = ResourceLoader::new();
+        let base = Url::parse("http://example.com/").unwrap();
+
+        let resolved = resolve_imports(sheet, &mut loader, &base, MAX_IMPORT_DEPTH);
+        // Import should be stripped, style rule kept
+        assert_eq!(resolved.rules.len(), 1);
+        assert!(matches!(resolved.rules[0], Rule::Style(_)));
+    }
+
+    #[test]
+    fn resolve_imports_failed_import_skipped() {
+        let sheet = Stylesheet {
+            rules: vec![
+                Rule::Import(ImportRule {
+                    url: "http://nonexistent.test/import.css".to_string(),
+                }),
+                Rule::Style(StyleRule {
+                    selectors: we_css::parser::SelectorList {
+                        selectors: Vec::new(),
+                    },
+                    declarations: Vec::new(),
+                }),
+            ],
+        };
+
+        let mut loader = ResourceLoader::new();
+        let base = Url::parse("http://example.com/").unwrap();
+
+        let resolved = resolve_imports(sheet, &mut loader, &base, 0);
+        // Failed import should be skipped, style rule kept
+        assert_eq!(resolved.rules.len(), 1);
+        assert!(matches!(resolved.rules[0], Rule::Style(_)));
+    }
+
+    // -----------------------------------------------------------------------
+    // CssLoadError display
+    // -----------------------------------------------------------------------
+
+    #[test]
+    fn css_load_error_display_not_css() {
+        let e = CssLoadError::NotCss {
+            url: "test.png".to_string(),
+        };
+        assert_eq!(e.to_string(), "resource at test.png is not CSS");
+    }
+
+    #[test]
+    fn css_load_error_display_load() {
+        let e = CssLoadError::Load(LoadError::InvalidUrl("bad".to_string()));
+        assert!(e.to_string().contains("CSS load error"));
+    }
+
+    // -----------------------------------------------------------------------
+    // Integration: style + link document order
+    // -----------------------------------------------------------------------
+
+    #[test]
+    fn style_and_link_document_order() {
+        // When both <style> and <link> are present, inline styles should be
+        // collected in document order (link will fail but style should work)
+        let mut doc = Document::new();
+        let root = doc.root();
+
+        let html = doc.create_element("html");
+        doc.append_child(root, html);
+
+        let head = doc.create_element("head");
+        doc.append_child(html, head);
+
+        // Link first (will fail)
+        let link = doc.create_element("link");
+        doc.set_attribute(link, "rel", "stylesheet");
+        doc.set_attribute(link, "href", "http://nonexistent.test/first.css");
+        doc.append_child(head, link);
+
+        // Style second
+        let style = doc.create_element("style");
+        doc.append_child(head, style);
+        let text = doc.create_text("p { color: green; }");
+        doc.append_child(style, text);
+
+        let mut loader = ResourceLoader::new();
+        let base = Url::parse("http://example.com/").unwrap();
+
+        let sheet = collect_stylesheets(&doc, &mut loader, &base);
+        // Only the inline style should succeed
+        assert_eq!(sheet.rules.len(), 1);
+    }
+
+    // -----------------------------------------------------------------------
+    // Edge cases
+    // -----------------------------------------------------------------------
+
+    #[test]
+    fn link_with_empty_href_skipped() {
+        let mut doc = Document::new();
+        let root = doc.root();
+
+        let link = doc.create_element("link");
+        doc.set_attribute(link, "rel", "stylesheet");
+        doc.set_attribute(link, "href", "");
+        doc.append_child(root, link);
+
+        assert!(matches!(
+            classify_style_node(&doc, link),
+            StyleSource::NotStylesheet
+        ));
+    }
+
+    #[test]
+    fn style_in_body_is_collected() {
+        // <style> in <body> should also be collected (browsers allow this)
+        let mut doc = Document::new();
+        let root = doc.root();
+
+        let html = doc.create_element("html");
+        doc.append_child(root, html);
+
+        let body = doc.create_element("body");
+        doc.append_child(html, body);
+
+        let style = doc.create_element("style");
+        doc.append_child(body, style);
+        let text = doc.create_text("h1 { font-size: 2em; }");
+        doc.append_child(style, text);
+
+        let mut loader = ResourceLoader::new();
+        let base = Url::parse("http://example.com/").unwrap();
+
+        let sheet = collect_stylesheets(&doc, &mut loader, &base);
+        assert_eq!(sheet.rules.len(), 1);
+    }
+
+    #[test]
+    fn link_rel_case_insensitive() {
+        // rel="Stylesheet" should work too (case-insensitive matching)
+        let mut doc = Document::new();
+        let root = doc.root();
+
+        let link = doc.create_element("link");
+        doc.set_attribute(link, "rel", "Stylesheet");
+        doc.set_attribute(link, "href", "style.css");
+        doc.append_child(root, link);
+
+        match classify_style_node(&doc, link) {
+            StyleSource::ExternalLink { href, .. } => assert_eq!(href, "style.css"),
+            _ => panic!("expected ExternalLink"),
+        }
+    }
+
+    #[test]
+    fn link_rel_with_extra_values() {
+        // rel="alternate stylesheet" should NOT match as a regular stylesheet
+        // (alternate stylesheets are disabled by default)
+        // Actually, per spec, "stylesheet" in the token list means it IS a stylesheet
+        // But "alternate stylesheet" is a disabled stylesheet. For simplicity,
+        // we treat any rel containing "stylesheet" as a stylesheet.
+        let mut doc = Document::new();
+        let root = doc.root();
+
+        let link = doc.create_element("link");
+        doc.set_attribute(link, "rel", "stylesheet");
+        doc.set_attribute(link, "href", "style.css");
+        doc.append_child(root, link);
+
+        assert!(matches!(
+            classify_style_node(&doc, link),
+            StyleSource::ExternalLink { .. }
+        ));
+    }
+}
diff --git a/crates/browser/src/lib.rs b/crates/browser/src/lib.rs
index 3beac0f..a5fd416 100644
--- a/crates/browser/src/lib.rs
+++ b/crates/browser/src/lib.rs
@@ -1,3 +1,4 @@
 //! Event loop, resource loading, navigation, UI chrome.
 
+pub mod css_loader;
 pub mod loader;
-- 
2.51.2