diff --git a/Cargo.toml b/Cargo.toml
index 21e65da..ffb6fed 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -11,4 +11,4 @@ crate-type = ["cdylib"]
 [dependencies]
 pyo3 = { version = "0.28.2", features = ["extension-module"] }
 browserslist-rs = "0.19.0"
-lightningcss = { version = "1.0.0-alpha.71", features = ["browserslist"] }
+lightningcss = { version = "1.0.0-alpha.71", features = ["browserslist", "visitor"] }
diff --git a/lightningcss.pyi b/lightningcss.pyi
index 3d9b2bf..95c263b 100644
--- a/lightningcss.pyi
+++ b/lightningcss.pyi
@@ -2,19 +2,185 @@
 A python wrapper for the core CSS transformation functionality of lightningcss.
 """
 
+from __future__ import annotations
+
 from typing import NewType
 
 ParserFlags = NewType('ParserFlags', int)
 
+
+class Angle:
+    value: float
+    unit: str
+    def __init__(self, value: float, unit: str) -> None: ...
+
+
+class Ratio:
+    numerator: float
+    denominator: float
+    def __init__(self, numerator: float, denominator: float) -> None: ...
+
+
+class Resolution:
+    value: float
+    unit: str
+    def __init__(self, value: float, unit: str) -> None: ...
+
+
+class Time:
+    value: float
+    unit: str
+    def __init__(self, value: float, unit: str) -> None: ...
+
+
+class LengthValue:
+    value: float
+    unit: str
+    def __init__(self, value: float, unit: str) -> None: ...
+
+
+class CssColor:
+    def __init__(self, css: str) -> None: ...
+    def css(self) -> str: ...
+
+
+class Url:
+    url: str
+    def __init__(self, url: str) -> None: ...
+
+
+class CustomIdent:
+    ident: str
+    def __init__(self, ident: str) -> None: ...
+
+
+class DashedIdent:
+    ident: str
+    def __init__(self, ident: str) -> None: ...
+
+
+class Function:
+    name: str
+    arguments: str
+    def __init__(self, name: str, arguments: str) -> None: ...
+
+
+class Variable:
+    name: str
+    fallback: str | None
+    def __init__(self, name: str, fallback: str | None = None) -> None: ...
+
+
+class EnvironmentVariable:
+    name: str
+    indices: list[int]
+    fallback: str | None
+    def __init__(
+        self,
+        name: str,
+        indices: list[int] = [],
+        fallback: str | None = None,
+    ) -> None: ...
+
+
+class Image:
+    css: str
+    def __init__(self, css: str) -> None: ...
+
+
+class Selector:
+    css: str
+    def __init__(self, css: str) -> None: ...
+
+
+class MediaQuery:
+    css: str
+    def __init__(self, css: str) -> None: ...
+
+
+class SupportsCondition:
+    css: str
+    def __init__(self, css: str) -> None: ...
+
+
+class CssRule:
+    css: str
+    def __init__(self, css: str) -> None: ...
+
+
+class Property:
+    css: str
+    def __init__(self, css: str) -> None: ...
+
+
+class TokenOrValue:
+    css: str
+    def __init__(self, css: str) -> None: ...
+
+
+class Visitor:
+    """
+    Base class for visitors. To create a visitor, subclass this and override
+    the visit methods for the node types you want to observe or mutate. Then,
+    pass an instance of your visitor to `process_stylesheet()` or
+    `bundle_css()`. The visitor will be called for each visited node in the
+    stylesheet, allowing for observation or mutation of the node.
+    """
+    def __init__(self, visit_types: int = 0) -> None: ...
+
+    def visit_url(self, value: Url) -> Url | None: ...
+    def visit_color(self, value: CssColor) -> CssColor | None: ...
+    def visit_length(self, value: LengthValue) -> LengthValue | None: ...
+    def visit_angle(self, value: Angle) -> Angle | None: ...
+    def visit_ratio(self, value: Ratio) -> Ratio | None: ...
+    def visit_resolution(self, value: Resolution) -> Resolution | None: ...
+    def visit_time(self, value: Time) -> Time | None: ...
+    def visit_custom_ident(self, value: CustomIdent) -> CustomIdent | None: ...
+    def visit_dashed_ident(self, value: DashedIdent) -> DashedIdent | None: ...
+
+    def visit_selector(self, value: Selector) -> object | None: ...
+    def visit_rule(self, value: CssRule) -> object | None: ...
+    def visit_property(self, value: Property) -> object | None: ...
+    def visit_image(self, value: Image) -> object | None: ...
+    def visit_variable(self, value: Variable) -> object | None: ...
+    def visit_environment_variable(self, value: EnvironmentVariable) -> object | None: ...
+    def visit_media_query(self, value: MediaQuery) -> object | None: ...
+    def visit_supports_condition(self, value: SupportsCondition) -> object | None: ...
+    def visit_function(self, value: Function) -> object | None: ...
+    def visit_token(self, value: TokenOrValue) -> object | None: ...
+
+
+VISIT_RULES: int
+VISIT_PROPERTIES: int
+VISIT_URLS: int
+VISIT_COLORS: int
+VISIT_IMAGES: int
+VISIT_LENGTHS: int
+VISIT_ANGLES: int
+VISIT_RATIOS: int
+VISIT_RESOLUTIONS: int
+VISIT_TIMES: int
+VISIT_CUSTOM_IDENTS: int
+VISIT_DASHED_IDENTS: int
+VISIT_VARIABLES: int
+VISIT_ENVIRONMENT_VARIABLES: int
+VISIT_MEDIA_QUERIES: int
+VISIT_SUPPORTS_CONDITIONS: int
+VISIT_SELECTORS: int
+VISIT_FUNCTIONS: int
+VISIT_TOKENS: int
+
+
 def calc_parser_flags(
     nesting: bool = False,
     custom_media: bool = False,
-    deep_selector_combinator: bool = False
+    deep_selector_combinator: bool = False,
 ) -> ParserFlags:
     """
     Calculates the `parser_flags` argument of `process_stylesheet()` and `bundle_css()`.
     """
 
+
 def process_stylesheet(
     code: str,
     /,
@@ -23,7 +189,8 @@ def process_stylesheet(
     parser_flags: ParserFlags = ParserFlags(0),
     unused_symbols: set[str] | None = None,
     browsers_list: list[str] | None = None,
-    minify: bool = True
+    minify: bool = True,
+    visitor: Visitor | None = None,
 ) -> str:
     """
     Processes the supplied CSS stylesheet and returns as a string.
@@ -44,9 +211,14 @@ def process_stylesheet(
         specified, no prefixing/transpilation will occur.
     :param minify: If True, the final output will be minified. Otherwise, it
         will be pretty-printed.
+    :param visitor: An optional Visitor instance. If provided, the visitor will
+        be called for each visited node in the stylesheet, allowing for
+        observation or mutation of the node. See the Visitor class for more
+        details.
     :return: A string containing a processed CSS stylesheet.
     """
 
+
 def bundle_css(
     path: str,
     /,
@@ -54,7 +226,8 @@ def bundle_css(
     parser_flags: ParserFlags = ParserFlags(0),
     unused_symbols: set[str] | None = None,
     browsers_list: list[str] | None = None,
-    minify: bool = True
+    minify: bool = True,
+    visitor: Visitor | None = None,
 ) -> str:
     """
     Processes the supplied CSS stylesheet file and returns the bundle as a string.
@@ -77,5 +250,9 @@ def bundle_css(
         specified, no prefixing/transpilation will occur.
     :param minify: If True, the final output will be minified. Otherwise, it
         will be pretty-printed.
+    :param visitor: An optional Visitor instance. If provided, the visitor will
+        be called for each visited node in the stylesheet, allowing for
+        observation or mutation of the node. See the Visitor class for more
+        details.
     :return: A string containing the CSS bundle.
     """
diff --git a/src/lib.rs b/src/lib.rs
index aad94cc..2fbf4b4 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -10,6 +10,9 @@ use lightningcss::stylesheet::{
     MinifyOptions, ParserFlags, ParserOptions, PrinterOptions, StyleSheet,
 };
 use lightningcss::targets::{Browsers, Targets};
+use lightningcss::visitor::{Visit, VisitTypes};
+
+mod visitor;
 
 /// Processes provided CSS and returns as a string.
 ///
@@ -38,6 +41,7 @@ use lightningcss::targets::{Browsers, Targets};
     unused_symbols=None,
     browsers_list=None,
     minify=true,
+    visitor=None,
 ))]
 fn process_stylesheet(code: &str,
                       filename: &str,
@@ -45,7 +49,8 @@ fn process_stylesheet(code: &str,
                       parser_flags: u8,
                       unused_symbols: Option<HashSet<String>>,
                       browsers_list: Option<Vec<String>>,
-                      minify: bool) -> PyResult<String> {
+                      minify: bool,
+                      visitor: Option<&mut visitor::PyVisitor>) -> PyResult<String> {
 
     let targets = match mk_targets(browsers_list) {
         Ok(val) => val,
@@ -55,6 +60,12 @@ fn process_stylesheet(code: &str,
         Ok(val) => val,
         Err(e) => {return Err(PyValueError::new_err(format!("Parsing stylesheet failed: {}", e.to_string())))}
     };
+    if let Some(visitor) = visitor {
+        match stylesheet.visit(visitor) {
+            Ok(_) => {}
+            Err(e) => {return Err(PyValueError::new_err(format!("Visiting stylesheet failed: {}", e.to_string())))}
+        }
+    };
     match stylesheet.minify(mk_minify_options(unused_symbols, &targets)) {
         Ok(_) => {}
         Err(e) => {return Err(PyValueError::new_err(format!("Minifying stylesheet failed: {}", e.to_string())));}
@@ -123,6 +134,7 @@ fn mk_printer_options<'a>(targets: &Targets,
     unused_symbols=None,
     browsers_list=None,
     minify=true,
+    visitor=None,
 ))]
 fn bundle_css(
     path: &str,
@@ -131,6 +143,7 @@ fn bundle_css(
     unused_symbols: Option<HashSet<String>>,
     browsers_list: Option<Vec<String>>,
     minify: bool,
+    visitor: Option<&mut visitor::PyVisitor>
 ) -> PyResult<String> {
     let fs = FileProvider::new();
     let mut bundler = Bundler::new(
@@ -160,6 +173,13 @@ fn bundle_css(
         }
     };
 
+    if let Some(visitor) = visitor {
+        match stylesheet.visit(visitor) {
+            Ok(_) => {}
+            Err(e) => {return Err(PyValueError::new_err(format!("Visiting stylesheet failed: {}", e.to_string())))}
+        }
+    };
+
     let targets = match mk_targets(browsers_list) {
         Ok(val) => val,
         Err(e) => {
@@ -197,4 +217,87 @@ mod py_lightningcss {
     use super::process_stylesheet;
     #[pymodule_export]
     use super::bundle_css;
+
+    #[pymodule_export(name = "Visitor")]
+    use super::visitor::PyVisitor;
+
+    // Export CSS value type classes
+    #[pymodule_export(name = "Url")]
+    use super::visitor::PyUrl;
+    #[pymodule_export(name = "CssColor")]
+    use super::visitor::PyCssColor;
+    #[pymodule_export(name = "LengthValue")]
+    use super::visitor::PyLengthValue;
+    #[pymodule_export(name = "Angle")]
+    use super::visitor::PyAngle;
+    #[pymodule_export(name = "Ratio")]
+    use super::visitor::PyRatio;
+    #[pymodule_export(name = "Resolution")]
+    use super::visitor::PyResolution;
+    #[pymodule_export(name = "Time")]
+    use super::visitor::PyTime;
+    #[pymodule_export(name = "CustomIdent")]
+    use super::visitor::PyCustomIdent;
+    #[pymodule_export(name = "DashedIdent")]
+    use super::visitor::PyDashedIdent;
+    #[pymodule_export(name = "Selector")]
+    use super::visitor::PySelector;
+    #[pymodule_export(name = "CssRule")]
+    use super::visitor::PyCssRule;
+    #[pymodule_export(name = "Property")]
+    use super::visitor::PyProperty;
+    #[pymodule_export(name = "Image")]
+    use super::visitor::PyImage;
+    #[pymodule_export(name = "Variable")]
+    use super::visitor::PyVariable;
+    #[pymodule_export(name = "EnvironmentVariable")]
+    use super::visitor::PyEnvironmentVariable;
+    #[pymodule_export(name = "MediaQuery")]
+    use super::visitor::PyMediaQuery;
+    #[pymodule_export(name = "SupportsCondition")]
+    use super::visitor::PySupportsCondition;
+    #[pymodule_export(name = "Function")]
+    use super::visitor::PyFunction;
+    #[pymodule_export(name = "TokenOrValue")]
+    use super::visitor::PyTokenOrValue;
+
+    // Export all VisitTypes flag constants so they're accessible from Python
+    #[pymodule_export]
+    const VISIT_RULES: u32 = super::VisitTypes::RULES.bits();
+    #[pymodule_export]
+    const VISIT_PROPERTIES: u32 = super::VisitTypes::PROPERTIES.bits();
+    #[pymodule_export]
+    const VISIT_URLS: u32 = super::VisitTypes::URLS.bits();
+    #[pymodule_export]
+    const VISIT_COLORS: u32 = super::VisitTypes::COLORS.bits();
+    #[pymodule_export]
+    const VISIT_IMAGES: u32 = super::VisitTypes::IMAGES.bits();
+    #[pymodule_export]
+    const VISIT_LENGTHS: u32 = super::VisitTypes::LENGTHS.bits();
+    #[pymodule_export]
+    const VISIT_ANGLES: u32 = super::VisitTypes::ANGLES.bits();
+    #[pymodule_export]
+    const VISIT_RATIOS: u32 = super::VisitTypes::RATIOS.bits();
+    #[pymodule_export]
+    const VISIT_RESOLUTIONS: u32 = super::VisitTypes::RESOLUTIONS.bits();
+    #[pymodule_export]
+    const VISIT_TIMES: u32 = super::VisitTypes::TIMES.bits();
+    #[pymodule_export]
+    const VISIT_CUSTOM_IDENTS: u32 = super::VisitTypes::CUSTOM_IDENTS.bits();
+    #[pymodule_export]
+    const VISIT_DASHED_IDENTS: u32 = super::VisitTypes::DASHED_IDENTS.bits();
+    #[pymodule_export]
+    const VISIT_VARIABLES: u32 = super::VisitTypes::VARIABLES.bits();
+    #[pymodule_export]
+    const VISIT_ENVIRONMENT_VARIABLES: u32 = super::VisitTypes::ENVIRONMENT_VARIABLES.bits();
+    #[pymodule_export]
+    const VISIT_MEDIA_QUERIES: u32 = super::VisitTypes::MEDIA_QUERIES.bits();
+    #[pymodule_export]
+    const VISIT_SUPPORTS_CONDITIONS: u32 = super::VisitTypes::SUPPORTS_CONDITIONS.bits();
+    #[pymodule_export]
+    const VISIT_SELECTORS: u32 = super::VisitTypes::SELECTORS.bits();
+    #[pymodule_export]
+    const VISIT_FUNCTIONS: u32 = super::VisitTypes::FUNCTIONS.bits();
+    #[pymodule_export]
+    const VISIT_TOKENS: u32 = super::VisitTypes::TOKENS.bits();
 }
diff --git a/src/visitor.rs b/src/visitor.rs
new file mode 100644
index 0000000..e3d7d2c
--- /dev/null
+++ b/src/visitor.rs
@@ -0,0 +1,912 @@
+use lightningcss::dependencies::Location as UrlLocation;
+use lightningcss::media_query::MediaQuery;
+use lightningcss::printer::PrinterOptions;
+use lightningcss::properties::custom::{EnvironmentVariable, Function, TokenOrValue, Variable};
+use lightningcss::properties::Property;
+use lightningcss::rules::supports::SupportsCondition;
+use lightningcss::rules::CssRule;
+use lightningcss::selector::Selector;
+use lightningcss::stylesheet::ParserOptions;
+use lightningcss::traits::{Parse, ParseWithOptions, ToCss};
+use lightningcss::values::angle::Angle;
+use lightningcss::values::color::CssColor;
+use lightningcss::values::ident::{CustomIdent, DashedIdent};
+use lightningcss::values::image::Image;
+use lightningcss::values::length::LengthValue;
+use lightningcss::values::ratio::Ratio;
+use lightningcss::values::resolution::Resolution;
+use lightningcss::values::time::Time;
+use lightningcss::values::url::Url;
+use lightningcss::visitor::{Visit, VisitTypes, Visitor};
+
+use pyo3::exceptions::PyAttributeError;
+use pyo3::exceptions::PyValueError;
+use pyo3::prelude::*;
+
+// ── Helper ──────────────────────────────────────────────────────────────────
+
+/// Serialize any lightningcss ToCss value to a CSS string using default options.
+fn lc_to_css_string<T: ToCss>(value: &T) -> String {
+    value
+        .to_css_string(PrinterOptions::default())
+        .unwrap_or_default()
+}
+
+// ── PyAngle ──────────────────────────────────────────────────────────────────
+
+/// Python wrapper for `lightningcss::values::angle::Angle`.
+#[pyclass(module = "lightningcss", name = "Angle", from_py_object)]
+#[derive(Clone, Debug)]
+pub struct PyAngle {
+    #[pyo3(get, set)]
+    pub value: f32,
+    #[pyo3(get, set)]
+    pub unit: String,
+}
+
+#[pymethods]
+impl PyAngle {
+    #[new]
+    pub fn new(value: f32, unit: String) -> Self {
+        Self { value, unit }
+    }
+    fn __repr__(&self) -> String {
+        format!("Angle(value={}, unit={:?})", self.value, self.unit)
+    }
+    fn __str__(&self) -> String {
+        format!("{}{}", self.value, self.unit)
+    }
+}
+
+impl From<Angle> for PyAngle {
+    fn from(a: Angle) -> Self {
+        let (value, unit) = match a {
+            Angle::Deg(v) => (v, "deg"),
+            Angle::Rad(v) => (v, "rad"),
+            Angle::Grad(v) => (v, "grad"),
+            Angle::Turn(v) => (v, "turn"),
+        };
+        Self { value, unit: unit.to_string() }
+    }
+}
+
+impl TryFrom<&PyAngle> for Angle {
+    type Error = PyErr;
+    fn try_from(v: &PyAngle) -> Result<Self, Self::Error> {
+        let css = format!("{}{}", v.value, v.unit);
+        Angle::parse_string(css.as_str()).map_err(|e| {
+            PyValueError::new_err(format!("Failed to parse Angle from '{}': {}", css, e))
+        })
+    }
+}
+
+// ── PyRatio ──────────────────────────────────────────────────────────────────
+
+/// Python wrapper for `lightningcss::values::ratio::Ratio`.
+#[pyclass(module = "lightningcss", name = "Ratio", from_py_object)]
+#[derive(Clone, Debug)]
+pub struct PyRatio {
+    #[pyo3(get, set)]
+    pub numerator: f32,
+    #[pyo3(get, set)]
+    pub denominator: f32,
+}
+
+#[pymethods]
+impl PyRatio {
+    #[new]
+    pub fn new(numerator: f32, denominator: f32) -> Self {
+        Self { numerator, denominator }
+    }
+    fn __repr__(&self) -> String {
+        format!("Ratio(numerator={}, denominator={})", self.numerator, self.denominator)
+    }
+    fn __str__(&self) -> String {
+        format!("{}/{}", self.numerator, self.denominator)
+    }
+}
+
+impl From<Ratio> for PyRatio {
+    fn from(r: Ratio) -> Self {
+        Self { numerator: r.0, denominator: r.1 }
+    }
+}
+
+impl TryFrom<&PyRatio> for Ratio {
+    type Error = PyErr;
+    fn try_from(v: &PyRatio) -> Result<Self, Self::Error> {
+        let css = format!("{}/{}", v.numerator, v.denominator);
+        Ratio::parse_string(css.as_str()).map_err(|e| {
+            PyValueError::new_err(format!("Failed to parse Ratio from '{}': {}", css, e))
+        })
+    }
+}
+
+// ── PyResolution ─────────────────────────────────────────────────────────────
+
+/// Python wrapper for `lightningcss::values::resolution::Resolution`.
+#[pyclass(module = "lightningcss", name = "Resolution", from_py_object)]
+#[derive(Clone, Debug)]
+pub struct PyResolution {
+    #[pyo3(get, set)]
+    pub value: f32,
+    #[pyo3(get, set)]
+    pub unit: String,
+}
+
+#[pymethods]
+impl PyResolution {
+    #[new]
+    pub fn new(value: f32, unit: String) -> Self {
+        Self { value, unit }
+    }
+    fn __repr__(&self) -> String {
+        format!("Resolution(value={}, unit={:?})", self.value, self.unit)
+    }
+    fn __str__(&self) -> String {
+        format!("{}{}", self.value, self.unit)
+    }
+}
+
+impl From<Resolution> for PyResolution {
+    fn from(r: Resolution) -> Self {
+        let (value, unit) = match r {
+            Resolution::Dpi(v) => (v, "dpi"),
+            Resolution::Dpcm(v) => (v, "dpcm"),
+            Resolution::Dppx(v) => (v, "dppx"),
+        };
+        Self { value, unit: unit.to_string() }
+    }
+}
+
+impl TryFrom<&PyResolution> for Resolution {
+    type Error = PyErr;
+    fn try_from(v: &PyResolution) -> Result<Self, Self::Error> {
+        let css = format!("{}{}", v.value, v.unit);
+        Resolution::parse_string(css.as_str()).map_err(|e| {
+            PyValueError::new_err(format!("Failed to parse Resolution from '{}': {}", css, e))
+        })
+    }
+}
+
+// ── PyTime ────────────────────────────────────────────────────────────────────
+
+/// Python wrapper for `lightningcss::values::time::Time`.
+#[pyclass(module = "lightningcss", name = "Time", from_py_object)]
+#[derive(Clone, Debug)]
+pub struct PyTime {
+    #[pyo3(get, set)]
+    pub value: f32,
+    #[pyo3(get, set)]
+    pub unit: String,
+}
+
+#[pymethods]
+impl PyTime {
+    #[new]
+    pub fn new(value: f32, unit: String) -> Self {
+        Self { value, unit }
+    }
+    fn __repr__(&self) -> String {
+        format!("Time(value={}, unit={:?})", self.value, self.unit)
+    }
+    fn __str__(&self) -> String {
+        format!("{}{}", self.value, self.unit)
+    }
+}
+
+impl From<Time> for PyTime {
+    fn from(t: Time) -> Self {
+        let (value, unit) = match t {
+            Time::Seconds(v) => (v, "s"),
+            Time::Milliseconds(v) => (v, "ms"),
+        };
+        Self { value, unit: unit.to_string() }
+    }
+}
+
+impl TryFrom<&PyTime> for Time {
+    type Error = PyErr;
+    fn try_from(v: &PyTime) -> Result<Self, Self::Error> {
+        let css = format!("{}{}", v.value, v.unit);
+        Time::parse_string(css.as_str()).map_err(|e| {
+            PyValueError::new_err(format!("Failed to parse Time from '{}': {}", css, e))
+        })
+    }
+}
+
+// ── PyLengthValue ─────────────────────────────────────────────────────────────
+
+/// Python wrapper for `lightningcss::values::length::LengthValue`.
+///
+/// Represents any CSS length as a `(value: f32, unit: str)` pair, e.g.
+/// `(32.0, "px")`, `(1.5, "rem")`, `(100.0, "vw")`.
+#[pyclass(module = "lightningcss", name = "LengthValue", from_py_object)]
+#[derive(Clone, Debug)]
+pub struct PyLengthValue {
+    #[pyo3(get, set)]
+    pub value: f32,
+    #[pyo3(get, set)]
+    pub unit: String,
+}
+
+#[pymethods]
+impl PyLengthValue {
+    #[new]
+    pub fn new(value: f32, unit: String) -> Self {
+        Self { value, unit }
+    }
+    fn __repr__(&self) -> String {
+        format!("LengthValue(value={}, unit={:?})", self.value, self.unit)
+    }
+    fn __str__(&self) -> String {
+        format!("{}{}", self.value, self.unit)
+    }
+}
+
+impl From<LengthValue> for PyLengthValue {
+    fn from(l: LengthValue) -> Self {
+        let (value, unit) = l.to_unit_value();
+        Self { value, unit: unit.to_string() }
+    }
+}
+
+impl TryFrom<&PyLengthValue> for LengthValue {
+    type Error = PyErr;
+    fn try_from(v: &PyLengthValue) -> Result<Self, Self::Error> {
+        let css = format!("{}{}", v.value, v.unit);
+        LengthValue::parse_string(css.as_str()).map_err(|e| {
+            PyValueError::new_err(format!("Failed to parse LengthValue from '{}': {}", css, e))
+        })
+    }
+}
+
+// ── PyCssColor ────────────────────────────────────────────────────────────────
+
+/// Python wrapper for `lightningcss::values::color::CssColor`.
+/// Constructed from a CSS color string; the underlying parsed color is held directly.
+#[pyclass(module = "lightningcss", name = "CssColor", from_py_object)]
+#[derive(Clone, Debug)]
+pub struct PyCssColor {
+    pub inner: CssColor,
+}
+
+#[pymethods]
+impl PyCssColor {
+    /// Create from a CSS color string, e.g. `"red"`, `"#ff0000"`, `"hsl(0 100% 50%)"`.
+    #[new]
+    pub fn new(css: String) -> PyResult<Self> {
+        CssColor::parse_string(css.as_str())
+            .map(|inner| Self { inner })
+            .map_err(|e| PyValueError::new_err(format!("Failed to parse color '{}': {}", css, e)))
+    }
+    /// Return the canonical CSS string representation.
+    pub fn css(&self) -> String {
+        lc_to_css_string(&self.inner)
+    }
+    fn __repr__(&self) -> String {
+        format!("CssColor({:?})", lc_to_css_string(&self.inner))
+    }
+    fn __str__(&self) -> String {
+        lc_to_css_string(&self.inner)
+    }
+}
+
+impl From<CssColor> for PyCssColor {
+    fn from(c: CssColor) -> Self {
+        Self { inner: c }
+    }
+}
+
+impl From<PyCssColor> for CssColor {
+    fn from(c: PyCssColor) -> Self {
+        c.inner
+    }
+}
+
+impl From<&PyCssColor> for CssColor {
+    fn from(c: &PyCssColor) -> Self {
+        c.inner.clone()
+    }
+}
+
+// ── PyUrl ─────────────────────────────────────────────────────────────────────
+
+/// Python wrapper for `lightningcss::values::url::Url`.
+#[pyclass(module = "lightningcss", name = "Url", from_py_object)]
+#[derive(Clone, Debug)]
+pub struct PyUrl {
+    #[pyo3(get, set)]
+    pub url: String,
+}
+
+#[pymethods]
+impl PyUrl {
+    #[new]
+    pub fn new(url: String) -> Self {
+        Self { url }
+    }
+    fn __repr__(&self) -> String {
+        format!("Url(url={:?})", self.url)
+    }
+    fn __str__(&self) -> String {
+        format!("url({:?})", self.url)
+    }
+}
+
+impl<'i> From<Url<'i>> for PyUrl {
+    fn from(u: Url<'i>) -> Self {
+        Self { url: u.url.as_ref().to_string() }
+    }
+}
+
+impl<'i> From<&PyUrl> for Url<'i> {
+    fn from(v: &PyUrl) -> Self {
+        Url {
+            url: v.url.clone().into(),
+            loc: UrlLocation { line: 0, column: 0 },
+        }
+    }
+}
+
+// ── PyCustomIdent ─────────────────────────────────────────────────────────────
+
+/// Python wrapper for `lightningcss::values::ident::CustomIdent`.
+#[pyclass(module = "lightningcss", name = "CustomIdent", from_py_object)]
+#[derive(Clone, Debug)]
+pub struct PyCustomIdent {
+    #[pyo3(get, set)]
+    pub ident: String,
+}
+
+#[pymethods]
+impl PyCustomIdent {
+    #[new]
+    pub fn new(ident: String) -> Self {
+        Self { ident }
+    }
+    fn __repr__(&self) -> String {
+        format!("CustomIdent(ident={:?})", self.ident)
+    }
+    fn __str__(&self) -> String {
+        self.ident.clone()
+    }
+}
+
+impl<'i> From<CustomIdent<'i>> for PyCustomIdent {
+    fn from(c: CustomIdent<'i>) -> Self {
+        Self { ident: c.0.as_ref().to_string() }
+    }
+}
+
+impl<'i> From<&PyCustomIdent> for CustomIdent<'i> {
+    fn from(v: &PyCustomIdent) -> Self {
+        CustomIdent(v.ident.clone().into())
+    }
+}
+
+// ── PyDashedIdent ─────────────────────────────────────────────────────────────
+
+/// Python wrapper for `lightningcss::values::ident::DashedIdent`.
+#[pyclass(module = "lightningcss", name = "DashedIdent", from_py_object)]
+#[derive(Clone, Debug)]
+pub struct PyDashedIdent {
+    #[pyo3(get, set)]
+    pub ident: String,
+}
+
+#[pymethods]
+impl PyDashedIdent {
+    #[new]
+    pub fn new(ident: String) -> Self {
+        Self { ident }
+    }
+    fn __repr__(&self) -> String {
+        format!("DashedIdent(ident={:?})", self.ident)
+    }
+    fn __str__(&self) -> String {
+        self.ident.clone()
+    }
+}
+
+impl<'i> From<DashedIdent<'i>> for PyDashedIdent {
+    fn from(d: DashedIdent<'i>) -> Self {
+        Self { ident: d.0.as_ref().to_string() }
+    }
+}
+
+impl<'i> From<&PyDashedIdent> for DashedIdent<'i> {
+    fn from(v: &PyDashedIdent) -> Self {
+        DashedIdent(v.ident.clone().into())
+    }
+}
+
+// ── PyFunction ────────────────────────────────────────────────────────────────
+
+/// Python wrapper for `lightningcss::properties::custom::Function`.
+#[pyclass(module = "lightningcss", name = "Function", from_py_object)]
+#[derive(Clone, Debug)]
+pub struct PyFunction {
+    #[pyo3(get, set)]
+    pub name: String,
+    /// Debug representation of the argument token list.
+    #[pyo3(get, set)]
+    pub arguments: String,
+}
+
+#[pymethods]
+impl PyFunction {
+    #[new]
+    pub fn new(name: String, arguments: String) -> Self {
+        Self { name, arguments }
+    }
+    fn __repr__(&self) -> String {
+        format!("Function(name={:?}, arguments={:?})", self.name, self.arguments)
+    }
+    fn __str__(&self) -> String {
+        format!("{}({})", self.name, self.arguments)
+    }
+}
+
+impl<'i> From<&Function<'i>> for PyFunction {
+    fn from(f: &Function<'i>) -> Self {
+        Self {
+            name: f.name.0.as_ref().to_string(),
+            arguments: format!("{:?}", f.arguments),
+        }
+    }
+}
+
+// ── PyVariable ────────────────────────────────────────────────────────────────
+
+/// Python wrapper for `lightningcss::properties::custom::Variable`.
+#[pyclass(module = "lightningcss", name = "Variable", from_py_object)]
+#[derive(Clone, Debug)]
+pub struct PyVariable {
+    /// The CSS custom property name, e.g. `"--my-color"`.
+    #[pyo3(get, set)]
+    pub name: String,
+    /// Debug representation of the optional fallback token list.
+    #[pyo3(get, set)]
+    pub fallback: Option<String>,
+}
+
+#[pymethods]
+impl PyVariable {
+    #[new]
+    #[pyo3(signature = (name, fallback = None))]
+    pub fn new(name: String, fallback: Option<String>) -> Self {
+        Self { name, fallback }
+    }
+    fn __repr__(&self) -> String {
+        format!("Variable(name={:?}, fallback={:?})", self.name, self.fallback)
+    }
+    fn __str__(&self) -> String {
+        match &self.fallback {
+            Some(fb) => format!("var({}, {})", self.name, fb),
+            None => format!("var({})", self.name),
+        }
+    }
+}
+
+impl<'i> From<&Variable<'i>> for PyVariable {
+    fn from(v: &Variable<'i>) -> Self {
+        Self {
+            name: lc_to_css_string(&v.name),
+            fallback: v.fallback.as_ref().map(|fb| format!("{:?}", fb)),
+        }
+    }
+}
+
+// ── PyEnvironmentVariable ─────────────────────────────────────────────────────
+
+/// Python wrapper for `lightningcss::properties::custom::EnvironmentVariable`.
+#[pyclass(module = "lightningcss", name = "EnvironmentVariable", from_py_object)]
+#[derive(Clone, Debug)]
+pub struct PyEnvironmentVariable {
+    /// The environment variable name, e.g. `"safe-area-inset-top"`.
+    #[pyo3(get, set)]
+    pub name: String,
+    /// Optional integer indices into the environment variable dimensions.
+    #[pyo3(get, set)]
+    pub indices: Vec<i32>,
+    /// Debug representation of the optional fallback token list.
+    #[pyo3(get, set)]
+    pub fallback: Option<String>,
+}
+
+#[pymethods]
+impl PyEnvironmentVariable {
+    #[new]
+    #[pyo3(signature = (name, indices = vec![], fallback = None))]
+    pub fn new(name: String, indices: Vec<i32>, fallback: Option<String>) -> Self {
+        Self { name, indices, fallback }
+    }
+    fn __repr__(&self) -> String {
+        format!(
+            "EnvironmentVariable(name={:?}, indices={:?}, fallback={:?})",
+            self.name, self.indices, self.fallback
+        )
+    }
+    fn __str__(&self) -> String {
+        let mut s = format!("env({})", self.name);
+        for i in &self.indices {
+            s.push_str(&format!(" {}", i));
+        }
+        if let Some(fb) = &self.fallback {
+            s.push_str(&format!(", {}", fb));
+        }
+        s
+    }
+}
+
+impl<'i> From<&EnvironmentVariable<'i>> for PyEnvironmentVariable {
+    fn from(e: &EnvironmentVariable<'i>) -> Self {
+        Self {
+            name: lc_to_css_string(&e.name),
+            indices: e.indices.iter().map(|i| *i as i32).collect(),
+            fallback: e.fallback.as_ref().map(|fb| format!("{:?}", fb)),
+        }
+    }
+}
+
+// ── CSS-string-backed wrappers for complex recursive types ────────────────────
+
+macro_rules! impl_css_string_wrapper {
+    ($wrapper:ident, $name:literal, $doc:literal) => {
+        #[doc = $doc]
+        #[pyclass(module = "lightningcss", name = $name, from_py_object)]
+        #[derive(Clone, Debug)]
+        pub struct $wrapper {
+            #[pyo3(get)]
+            pub css: String,
+        }
+
+        #[pymethods]
+        impl $wrapper {
+            #[new]
+            pub fn new(css: String) -> Self {
+                Self { css }
+            }
+            fn __repr__(&self) -> String {
+                format!("{}({:?})", stringify!($wrapper), self.css)
+            }
+            fn __str__(&self) -> String {
+                self.css.clone()
+            }
+        }
+    };
+}
+
+impl_css_string_wrapper!(PyImage, "Image", "Python wrapper for `lightningcss::values::image::Image`.");
+impl_css_string_wrapper!(PySelector, "Selector", "Python wrapper for a CSS selector.");
+impl_css_string_wrapper!(PyMediaQuery, "MediaQuery", "Python wrapper for `lightningcss::media_query::MediaQuery`.");
+impl_css_string_wrapper!(PySupportsCondition, "SupportsCondition", "Python wrapper for `lightningcss::rules::supports::SupportsCondition`.");
+impl_css_string_wrapper!(PyCssRule, "CssRule", "Python wrapper for `lightningcss::rules::CssRule`.");
+impl_css_string_wrapper!(PyProperty, "Property", "Python wrapper for `lightningcss::properties::Property`.");
+impl_css_string_wrapper!(PyTokenOrValue, "TokenOrValue", "Python wrapper for `lightningcss::properties::custom::TokenOrValue`.");
+
+impl<'i> From<&Image<'i>> for PyImage {
+    fn from(v: &Image<'i>) -> Self { Self { css: lc_to_css_string(v) } }
+}
+impl<'i> TryFrom<&'i PyImage> for Image<'i> {
+    type Error = PyErr;
+    fn try_from(v: &'i PyImage) -> Result<Self, Self::Error> {
+        Image::parse_string(v.css.as_str()).map_err(|e| {
+            PyValueError::new_err(format!("Failed to parse Image from '{}': {}", v.css, e))
+        })
+    }
+}
+
+impl<'i> From<&Selector<'i>> for PySelector {
+    fn from(v: &Selector<'i>) -> Self { Self { css: lc_to_css_string(v) } }
+}
+impl<'i> TryFrom<&'i PySelector> for Selector<'i> {
+    type Error = PyErr;
+    fn try_from(v: &'i PySelector) -> Result<Self, Self::Error> {
+        Selector::parse_string_with_options(v.css.as_str(), ParserOptions::default()).map_err(|e| {
+            PyValueError::new_err(format!("Failed to parse Selector from '{}': {}", v.css, e))
+        })
+    }
+}
+
+impl<'i> From<&MediaQuery<'i>> for PyMediaQuery {
+    fn from(v: &MediaQuery<'i>) -> Self { Self { css: lc_to_css_string(v) } }
+}
+impl<'i> TryFrom<&'i PyMediaQuery> for MediaQuery<'i> {
+    type Error = PyErr;
+    fn try_from(v: &'i PyMediaQuery) -> Result<Self, Self::Error> {
+        MediaQuery::parse_string_with_options(v.css.as_str(), ParserOptions::default()).map_err(|e| {
+            PyValueError::new_err(format!("Failed to parse MediaQuery from '{}': {}", v.css, e))
+        })
+    }
+}
+
+impl<'i> From<&SupportsCondition<'i>> for PySupportsCondition {
+    fn from(v: &SupportsCondition<'i>) -> Self { Self { css: lc_to_css_string(v) } }
+}
+impl<'i> TryFrom<&'i PySupportsCondition> for SupportsCondition<'i> {
+    type Error = PyErr;
+    fn try_from(v: &'i PySupportsCondition) -> Result<Self, Self::Error> {
+        SupportsCondition::parse_string(v.css.as_str()).map_err(|e| {
+            PyValueError::new_err(format!("Failed to parse SupportsCondition from '{}': {}", v.css, e))
+        })
+    }
+}
+
+impl<'i> From<&CssRule<'i>> for PyCssRule {
+    fn from(v: &CssRule<'i>) -> Self { Self { css: lc_to_css_string(v) } }
+}
+
+impl<'i> From<&Property<'i>> for PyProperty {
+    fn from(v: &Property<'i>) -> Self { Self { css: format!("{:?}", v) } }
+}
+
+impl<'i> From<&TokenOrValue<'i>> for PyTokenOrValue {
+    fn from(v: &TokenOrValue<'i>) -> Self { Self { css: format!("{:?}", v) } }
+}
+
+
+/// A Visitor implementation that delegates to Python callback functions.
+///
+/// Subclass this from Python and implement methods like `visit_url`,
+/// `visit_color`, etc. Methods receive typed wrapper objects (e.g. `Url`,
+/// `CssColor`, `LengthValue`). For leaf values, returning a replacement wrapper
+/// mutates the stylesheet; returning `None` leaves the original value unchanged.
+///
+/// Leaf types (URLs, colors, lengths, angles, ratios, resolutions, times,
+/// custom idents, dashed idents) support mutation via the return value.
+/// Branch types (rules, properties, images, variables, etc.) call the callback
+/// for observation; the return value is ignored and child traversal continues.
+#[pyclass(module="lightningcss", name = "Visitor", subclass)]
+pub struct PyVisitor {
+    visit_types: VisitTypes,
+    py_self: Option<Py<PyAny>>,
+}
+
+#[pymethods]
+impl PyVisitor {
+    /// Creates a `lightningcss::visitor::Visitor`.
+    #[new]
+    pub fn new() -> Self {
+        PyVisitor {
+            visit_types: VisitTypes::empty(),
+            py_self: None,
+        }
+    }
+
+    /// Initializes with VisitTypes bitflags (e.g. `VISIT_URLS | VISIT_COLORS`).
+    #[pyo3(signature = (visit_types = 0))]
+    fn __init__(slf: Py<Self>, visit_types: u32) -> PyResult<()> {
+        Python::attach(|py| {
+            let mut this = slf.borrow_mut(py);
+            this.visit_types = VisitTypes::from_bits_truncate(visit_types);
+            this.py_self = Some(slf.clone_ref(py).into_any());
+            Ok(())
+        })
+    }
+}
+
+macro_rules! call_leaf_callback {
+    ($self:expr, $flag:expr, $method:literal, $wrapper:ty, $current:expr, $apply_new:expr) => {{
+        if $self.visit_types.contains($flag) {
+            Python::attach(|py| -> PyResult<()> {
+                let py_self = $self
+                    .py_self
+                    .as_ref()
+                    .ok_or_else(|| PyValueError::new_err("Visitor is not initialized"))?;
+                let wrapped: $wrapper = $current;
+                let arg = Py::new(py, wrapped)?;
+                let result = match py_self.bind(py).call_method1($method, (arg,)) {
+                    Ok(result) => result,
+                    Err(err) if err.is_instance_of::<PyAttributeError>(py) => return Ok(()),
+                    Err(err) => return Err(err),
+                };
+                if !result.is_none() {
+                    let new_value: $wrapper = result.extract()?;
+                    $apply_new(new_value)?;
+                }
+                Ok(())
+            })?;
+        }
+    }};
+}
+
+macro_rules! call_observe_callback {
+    ($self:expr, $flag:expr, $method:literal, $wrapper:ty, $current:expr) => {{
+        if $self.visit_types.contains($flag) {
+            Python::attach(|py| -> PyResult<()> {
+                let py_self = $self
+                    .py_self
+                    .as_ref()
+                    .ok_or_else(|| PyValueError::new_err("Visitor is not initialized"))?;
+                let wrapped: $wrapper = $current;
+                let arg = Py::new(py, wrapped)?;
+                match py_self.bind(py).call_method1($method, (arg,)) {
+                    Ok(_) => Ok(()),
+                    Err(err) if err.is_instance_of::<PyAttributeError>(py) => Ok(()),
+                    Err(err) => Err(err),
+                }
+            })?;
+        }
+    }};
+}
+
+impl<'i> Visitor<'i> for PyVisitor {
+    type Error = PyErr;
+
+    fn visit_types(&self) -> VisitTypes {
+        self.visit_types
+    }
+
+    // === Leaf visit methods (support mutation via callback return value) ===
+
+    fn visit_url(&mut self, url: &mut Url<'i>) -> Result<(), Self::Error> {
+        call_leaf_callback!(self, VisitTypes::URLS, "visit_url", PyUrl, PyUrl::from(url.clone()), |new_url: PyUrl| -> PyResult<()> {
+            *url = Url::from(&new_url);
+            Ok(())
+        });
+        Ok(())
+    }
+
+    fn visit_color(&mut self, color: &mut CssColor) -> Result<(), Self::Error> {
+        call_leaf_callback!(self, VisitTypes::COLORS, "visit_color", PyCssColor, PyCssColor::from(color.clone()), |new_color: PyCssColor| -> PyResult<()> {
+            *color = CssColor::from(new_color);
+            Ok(())
+        });
+        Ok(())
+    }
+
+    fn visit_length(&mut self, length: &mut LengthValue) -> Result<(), Self::Error> {
+        call_leaf_callback!(self, VisitTypes::LENGTHS, "visit_length", PyLengthValue, PyLengthValue::from(length.clone()), |new_length: PyLengthValue| -> PyResult<()> {
+            *length = LengthValue::try_from(&new_length)?;
+            Ok(())
+        });
+        Ok(())
+    }
+
+    fn visit_angle(&mut self, angle: &mut Angle) -> Result<(), Self::Error> {
+        call_leaf_callback!(self, VisitTypes::ANGLES, "visit_angle", PyAngle, PyAngle::from(angle.clone()), |new_angle: PyAngle| -> PyResult<()> {
+            *angle = Angle::try_from(&new_angle)?;
+            Ok(())
+        });
+        Ok(())
+    }
+
+    fn visit_ratio(&mut self, ratio: &mut Ratio) -> Result<(), Self::Error> {
+        call_leaf_callback!(self, VisitTypes::RATIOS, "visit_ratio", PyRatio, PyRatio::from(ratio.clone()), |new_ratio: PyRatio| -> PyResult<()> {
+            *ratio = Ratio::try_from(&new_ratio)?;
+            Ok(())
+        });
+        Ok(())
+    }
+
+    fn visit_resolution(&mut self, resolution: &mut Resolution) -> Result<(), Self::Error> {
+        call_leaf_callback!(
+            self,
+            VisitTypes::RESOLUTIONS,
+            "visit_resolution",
+            PyResolution,
+            PyResolution::from(resolution.clone()),
+            |new_resolution: PyResolution| -> PyResult<()> {
+                *resolution = Resolution::try_from(&new_resolution)?;
+                Ok(())
+            }
+        );
+        Ok(())
+    }
+
+    fn visit_time(&mut self, time: &mut Time) -> Result<(), Self::Error> {
+        call_leaf_callback!(self, VisitTypes::TIMES, "visit_time", PyTime, PyTime::from(time.clone()), |new_time: PyTime| -> PyResult<()> {
+            *time = Time::try_from(&new_time)?;
+            Ok(())
+        });
+        Ok(())
+    }
+
+    fn visit_custom_ident(&mut self, ident: &mut CustomIdent) -> Result<(), Self::Error> {
+        call_leaf_callback!(
+            self,
+            VisitTypes::CUSTOM_IDENTS,
+            "visit_custom_ident",
+            PyCustomIdent,
+            PyCustomIdent::from(ident.clone()),
+            |new_ident: PyCustomIdent| -> PyResult<()> {
+                *ident = CustomIdent::from(&new_ident);
+                Ok(())
+            }
+        );
+        Ok(())
+    }
+
+    fn visit_dashed_ident(&mut self, ident: &mut DashedIdent) -> Result<(), Self::Error> {
+        call_leaf_callback!(
+            self,
+            VisitTypes::DASHED_IDENTS,
+            "visit_dashed_ident",
+            PyDashedIdent,
+            PyDashedIdent::from(ident.clone()),
+            |new_ident: PyDashedIdent| -> PyResult<()> {
+                *ident = DashedIdent::from(&new_ident);
+                Ok(())
+            }
+        );
+        Ok(())
+    }
+
+    fn visit_selector(&mut self, selector: &mut Selector<'i>) -> Result<(), Self::Error> {
+        call_observe_callback!(
+            self,
+            VisitTypes::SELECTORS,
+            "visit_selector",
+            PySelector,
+            PySelector::from(selector as &Selector)
+        );
+        Ok(())
+    }
+
+    // === Branch visit methods (observation callback + child recursion) ===
+
+    fn visit_rule(&mut self, rule: &mut CssRule<'i>) -> Result<(), Self::Error> {
+        call_observe_callback!(self, VisitTypes::RULES, "visit_rule", PyCssRule, PyCssRule::from(rule as &CssRule));
+        rule.visit_children(self)
+    }
+
+    fn visit_property(&mut self, property: &mut Property<'i>) -> Result<(), Self::Error> {
+        call_observe_callback!(self, VisitTypes::PROPERTIES, "visit_property", PyProperty, PyProperty::from(property as &Property));
+        property.visit_children(self)
+    }
+
+    fn visit_image(&mut self, image: &mut Image<'i>) -> Result<(), Self::Error> {
+        call_observe_callback!(self, VisitTypes::IMAGES, "visit_image", PyImage, PyImage::from(image as &Image));
+        image.visit_children(self)
+    }
+
+    fn visit_variable(&mut self, variable: &mut Variable<'i>) -> Result<(), Self::Error> {
+        call_observe_callback!(self, VisitTypes::VARIABLES, "visit_variable", PyVariable, PyVariable::from(variable as &Variable));
+        variable.visit_children(self)
+    }
+
+    fn visit_environment_variable(
+        &mut self,
+        env: &mut EnvironmentVariable<'i>,
+    ) -> Result<(), Self::Error> {
+        call_observe_callback!(
+            self,
+            VisitTypes::ENVIRONMENT_VARIABLES,
+            "visit_environment_variable",
+            PyEnvironmentVariable,
+            PyEnvironmentVariable::from(env as &EnvironmentVariable)
+        );
+        env.visit_children(self)
+    }
+
+    fn visit_media_query(&mut self, query: &mut MediaQuery<'i>) -> Result<(), Self::Error> {
+        call_observe_callback!(self, VisitTypes::MEDIA_QUERIES, "visit_media_query", PyMediaQuery, PyMediaQuery::from(query as &MediaQuery));
+        query.visit_children(self)
+    }
+
+    fn visit_supports_condition(
+        &mut self,
+        condition: &mut SupportsCondition<'i>,
+    ) -> Result<(), Self::Error> {
+        call_observe_callback!(
+            self,
+            VisitTypes::SUPPORTS_CONDITIONS,
+            "visit_supports_condition",
+            PySupportsCondition,
+            PySupportsCondition::from(condition as &SupportsCondition)
+        );
+        condition.visit_children(self)
+    }
+
+    fn visit_function(&mut self, function: &mut Function<'i>) -> Result<(), Self::Error> {
+        call_observe_callback!(self, VisitTypes::FUNCTIONS, "visit_function", PyFunction, PyFunction::from(function as &Function));
+        function.visit_children(self)
+    }
+
+    fn visit_token(&mut self, token: &mut TokenOrValue<'i>) -> Result<(), Self::Error> {
+        call_observe_callback!(self, VisitTypes::TOKENS, "visit_token", PyTokenOrValue, PyTokenOrValue::from(token as &TokenOrValue));
+        token.visit_children(self)
+    }
+}
diff --git a/tests/test_bundle_css.py b/tests/test_bundle_css.py
index da1be14..4e3e2ff 100644
--- a/tests/test_bundle_css.py
+++ b/tests/test_bundle_css.py
@@ -28,3 +28,55 @@ def test_file_not_found():
 def test_parse_error():
     with pytest.raises(ValueError):
         lcss.bundle_css(str(INVALID_CSS_PATH))
+
+
+def test_bundle_css_visitor_multiple_mutations(tmp_path: Path):
+    main_css = tmp_path / "main.css"
+    imported_css = tmp_path / "normalize.css"
+
+    imported_css.write_text(".content{margin-top:10px}")
+    main_css.write_text(
+        "@import \"normalize.css\";a{color:red;background-image:url('a.png')}"
+    )
+
+    class MutatingVisitor(lcss.Visitor):
+        def __init__(self):
+            super().__init__(
+                lcss.VISIT_URLS | lcss.VISIT_LENGTHS | lcss.VISIT_COLORS
+            )
+
+        def visit_url(self, value: lcss.Url):
+            return lcss.Url("b.png")
+
+        def visit_length(self, value: lcss.LengthValue):
+            return lcss.LengthValue(value.value + 5, value.unit)
+
+        def visit_color(self, value: lcss.CssColor):
+            return lcss.CssColor("#00ff00")
+
+    result = lcss.bundle_css(str(main_css), visitor=MutatingVisitor())
+
+    assert "url(b.png)" in result
+    assert "margin-top:15px" in result
+    assert "#0f0" in result
+
+
+def test_bundle_css_visitor_rule_observation_dispatch(tmp_path: Path):
+    main_css = tmp_path / "main.css"
+    main_css.write_text("a{color:red}")
+
+    seen_rules: list[str] = []
+
+    class ObservingVisitor(lcss.Visitor):
+        def __init__(self):
+            super().__init__(lcss.VISIT_RULES)
+
+        def visit_rule(self, value: lcss.CssRule):
+            seen_rules.append(value.css)
+            return lcss.CssRule(".ignored{color:blue}")
+
+    result = lcss.bundle_css(str(main_css), visitor=ObservingVisitor())
+
+    assert result == "a{color:red}"
+    assert len(seen_rules) == 1
+    assert "a" in seen_rules[0]
diff --git a/tests/test_process_stylesheet.py b/tests/test_process_stylesheet.py
index 31040cb..e57f4bf 100644
--- a/tests/test_process_stylesheet.py
+++ b/tests/test_process_stylesheet.py
@@ -31,3 +31,47 @@ def test_error_recovery():
 
     result = lcss.process_stylesheet(code, error_recovery=True)
     assert result == expected
+
+
+def test_visitor_method_dispatch_multiple_mutations():
+    code = ".content{background-image:url('a.png');margin-top:10px;color:red}"
+
+    class MutatingVisitor(lcss.Visitor):
+        def __init__(self):
+            super().__init__(
+                lcss.VISIT_URLS | lcss.VISIT_LENGTHS | lcss.VISIT_COLORS
+            )
+
+        def visit_url(self, value: lcss.Url):
+            return lcss.Url("b.png")
+
+        def visit_length(self, value: lcss.LengthValue):
+            return lcss.LengthValue(value.value + 5, value.unit)
+
+        def visit_color(self, value: lcss.CssColor):
+            return lcss.CssColor("#00ff00")
+
+    result = lcss.process_stylesheet(code, visitor=MutatingVisitor())
+
+    assert "url(b.png)" in result
+    assert "margin-top:15px" in result
+    assert "#0f0" in result
+
+
+def test_visitor_rule_observation_dispatch():
+    code = ".content{color:red}"
+    seen_rules = []
+
+    class ObservingVisitor(lcss.Visitor):
+        def __init__(self):
+            super().__init__(lcss.VISIT_RULES)
+
+        def visit_rule(self, value: lcss.CssRule):
+            seen_rules.append(value.css)
+            return lcss.CssRule(".ignored{color:blue}")
+
+    result = lcss.process_stylesheet(code, visitor=ObservingVisitor())
+
+    assert result == ".content{color:red}"
+    assert len(seen_rules) == 1
+    assert ".content" in seen_rules[0]