From c73dfc95ffd0ec470e80d8956de1bf04a6685737 Mon Sep 17 00:00:00 2001
From: Daniel McNab <36049421+DJMcNab@users.noreply.github.com>
Date: Fri, 23 Jan 2026 16:22:28 +0000
Subject: [PATCH 01/14] Add an `ExactPathElements` trait

This represents shapes which can be turned into exact paths

Co-Authored-By: Tom Churchman <thomas@churchman.nl>
---
 sparse_strips/vello_api/src/exact.rs | 137 +++++++++++++++++++++++++++
 sparse_strips/vello_api/src/lib.rs   |   1 +
 2 files changed, 138 insertions(+)
 create mode 100644 sparse_strips/vello_api/src/exact.rs

diff --git a/sparse_strips/vello_api/src/exact.rs b/sparse_strips/vello_api/src/exact.rs
new file mode 100644
index 000000000..f6ddd5ba2
--- /dev/null
+++ b/sparse_strips/vello_api/src/exact.rs
@@ -0,0 +1,137 @@
+// Copyright 2025 the Vello Authors
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+//! Turning shapes into Bézier paths without approximation.
+
+use kurbo::{BezPath, CubicBez, Line, PathEl, QuadBez, Rect, Segments, Shape, Triangle, segments};
+use peniko::kurbo;
+
+/// A generic trait for shapes that can be mapped exactly to Bézier path elements (i.e., without
+/// approximation).
+///
+/// The methods on [`PaintScene`](crate::PaintScene) use this trait ensure that consistent behaviour
+/// is maintained when Vello API is used to render content which might be rescaled.
+///
+/// This is implemented for several [`Shape`]s from Kurbo.
+/// To convert a [`Shape`] which requires approximation (such as [`Circle`](kurbo::Circle) or
+/// [`RoundedRect`](kurbo::RoundedRect)), you can use [`within`].
+/// Note that the returned shape will use.
+/// This however requires you to provide the tolerance.
+pub trait ExactPathElements {
+    /// The iterator returned by the [`Self::exact_path_elements`] method.
+    ///
+    /// In many cases, this will be the same iterator as [`Shape::path_elements`]
+    type ExactPathElementsIter<'iter>: Iterator<Item = PathEl> + 'iter
+    where
+        Self: 'iter;
+
+    /// Returns an iterator over this shape expressed as exact [`PathEl`]s;
+    /// that is, as exact Bézier path _elements_.
+    ///
+    /// These path elements are exact, in the sense that no approximation is required
+    /// to calculate them. This is not possible for all shapes, but is possible for all
+    /// finite polygons and other piecewise-cubic parametric curves. Some shapes will
+    /// need to be approximated, which [`Shape::path_elements`] does instead.
+    /// The [`within`] helper function allows the approximated shape to be used
+    /// where an exact value is required, by providing the tolerance used.
+    ///
+    /// In many cases, shapes are able to iterate their elements without
+    /// allocating; however creating a [`BezPath`] object always allocates.
+    /// If you need an owned [`BezPath`] you can use [`BezPath::from_iter`] (or
+    /// [`Iterator::collect`]).
+    fn exact_path_elements(&self) -> Self::ExactPathElementsIter<'_>;
+
+    /// Returns an iterator over this shape expressed as exact Bézier path
+    /// _segments_ ([`PathSeg`]s).
+    ///
+    /// The allocation behaviour is the same as for [`ExactPathElements::exact_path_elements`].
+    ///
+    /// [`PathSeg`]: crate::PathSeg
+    #[inline]
+    fn exact_path_segments(&self) -> Segments<Self::ExactPathElementsIter<'_>> {
+        segments(self.exact_path_elements())
+    }
+}
+
+impl<'a, T: ExactPathElements> ExactPathElements for &'a T {
+    type ExactPathElementsIter<'iter>
+        = T::ExactPathElementsIter<'iter>
+    where
+        T: 'iter,
+        'a: 'iter;
+
+    #[inline]
+    fn exact_path_elements(&self) -> Self::ExactPathElementsIter<'_> {
+        (*self).exact_path_elements()
+    }
+}
+
+/// Use an approximated shape where an [`ExactPathElements`] is required, by approximating it to
+/// within the given tolerance.
+///
+/// This is useful for drawing shapes such as [`Circle`](kurbo::Circle)s and [`RoundedRect`](kurbo::RoundedRect)s
+/// to renderers which use Vello API.
+///
+/// As the user of this function, you are responsible for determining the correct tolerance for your use case.
+/// A reasonable approach might be to select a tolerance which allows scaling up ("zooming in") by 8x to be
+/// within your intended tolernace bound, then recomputing the [`Scene`](crate::Scene) from your base data
+/// representation once that is exceeded.
+/// If you know that the shape will not be scaled, you can use [`UNSCALED_TOLERANCE`].
+// TODO: Ideally, we would say something like: "the resulting path will be within a 1/10th
+// of a pixel of the actual shape, which is a negligible difference for rendering"
+// but we probably can't, because Kurbo doesn't document the properties of their tolerance
+// (at least, I've not found where it is documented...)
+// TODO: Provide as an extension trait?
+pub fn within<S: Shape>(shape: S, tolerance: f64) -> WithTolerance<S> {
+    WithTolerance { shape, tolerance }
+}
+
+/// The type used to implement [`within`].
+#[derive(Debug)]
+pub struct WithTolerance<S: Shape> {
+    /// The shape to be approximated.
+    pub shape: S,
+    /// The tolerance to use when approximating it.
+    pub tolerance: f64,
+}
+
+impl<S: Shape> ExactPathElements for WithTolerance<S> {
+    type ExactPathElementsIter<'iter>
+        = S::PathElementsIter<'iter>
+    where
+        S: 'iter;
+
+    fn exact_path_elements(&self) -> Self::ExactPathElementsIter<'_> {
+        self.shape.path_elements(self.tolerance)
+    }
+}
+
+/// The recommended tolerance for approximating shapes which won't be rescaled as Bezier paths.
+///
+/// This can be used as the tolerance parameter to [`within`], when you know that
+/// a shape will be drawn at its natural size, without scaling or skew.
+pub const UNSCALED_TOLERANCE: f64 = 0.1;
+
+// TODO: Provide an `fn ideal_tolerance(transform: Affine) -> f64`
+
+/// Implement `ExactPathElements` for an existing [`Shape`], which we know
+// In theory, the impl is the wrong way around; instead the `Shape` impl should be in terms of `ExactPathElements`.
+macro_rules! passthrough {
+    ($ty: ty) => {
+        impl ExactPathElements for $ty {
+            type ExactPathElementsIter<'iter> = <$ty as Shape>::PathElementsIter<'iter>;
+
+            fn exact_path_elements(&self) -> Self::ExactPathElementsIter<'_> {
+                // We use a tolerance of zero here because we know this to be exact.
+                self.path_elements(0.)
+            }
+        }
+    };
+}
+passthrough!(BezPath);
+
+passthrough!(CubicBez);
+passthrough!(Line);
+passthrough!(QuadBez);
+passthrough!(Rect);
+passthrough!(Triangle);
diff --git a/sparse_strips/vello_api/src/lib.rs b/sparse_strips/vello_api/src/lib.rs
index 24b1e9a3f..27fb3463b 100644
--- a/sparse_strips/vello_api/src/lib.rs
+++ b/sparse_strips/vello_api/src/lib.rs
@@ -137,6 +137,7 @@ extern crate alloc;
 
 mod painter;
 
+pub mod exact;
 pub mod paths;
 pub mod scene;
 pub mod texture;

From bba5ce774af89288fd6987b73de2fb9f0aa189a1 Mon Sep 17 00:00:00 2001
From: Daniel McNab <36049421+DJMcNab@users.noreply.github.com>
Date: Fri, 23 Jan 2026 16:30:22 +0000
Subject: [PATCH 02/14] Use `ExactPathElements` in Vello API

---
 sparse_strips/vello_api/src/exact.rs   | 38 ++++++++++++++++++++++----
 sparse_strips/vello_api/src/painter.rs | 16 +++++++----
 sparse_strips/vello_api/src/paths.rs   | 19 ++++++-------
 sparse_strips/vello_api/src/scene.rs   | 12 ++++++--
 sparse_strips/vello_cpu/src/api.rs     |  5 ++--
 5 files changed, 65 insertions(+), 25 deletions(-)

diff --git a/sparse_strips/vello_api/src/exact.rs b/sparse_strips/vello_api/src/exact.rs
index f6ddd5ba2..2349936de 100644
--- a/sparse_strips/vello_api/src/exact.rs
+++ b/sparse_strips/vello_api/src/exact.rs
@@ -17,7 +17,7 @@ use peniko::kurbo;
 /// [`RoundedRect`](kurbo::RoundedRect)), you can use [`within`].
 /// Note that the returned shape will use.
 /// This however requires you to provide the tolerance.
-pub trait ExactPathElements {
+pub trait ExactPathElements: Shape {
     /// The iterator returned by the [`Self::exact_path_elements`] method.
     ///
     /// In many cases, this will be the same iterator as [`Shape::path_elements`]
@@ -77,10 +77,8 @@ impl<'a, T: ExactPathElements> ExactPathElements for &'a T {
 /// within your intended tolernace bound, then recomputing the [`Scene`](crate::Scene) from your base data
 /// representation once that is exceeded.
 /// If you know that the shape will not be scaled, you can use [`UNSCALED_TOLERANCE`].
-// TODO: Ideally, we would say something like: "the resulting path will be within a 1/10th
-// of a pixel of the actual shape, which is a negligible difference for rendering"
-// but we probably can't, because Kurbo doesn't document the properties of their tolerance
-// (at least, I've not found where it is documented...)
+/// The resulting path will be within 1/10th of a pixel of the actual shape, which is a negligible
+/// difference for rendering.
 // TODO: Provide as an extension trait?
 pub fn within<S: Shape>(shape: S, tolerance: f64) -> WithTolerance<S> {
     WithTolerance { shape, tolerance }
@@ -106,6 +104,36 @@ impl<S: Shape> ExactPathElements for WithTolerance<S> {
     }
 }
 
+impl<S: Shape> Shape for WithTolerance<S> {
+    type PathElementsIter<'iter>
+        = <Self as ExactPathElements>::ExactPathElementsIter<'iter>
+    where
+        S: 'iter;
+
+    fn path_elements(&self, _tolerance: f64) -> Self::PathElementsIter<'_> {
+        self.exact_path_elements()
+    }
+
+    fn area(&self) -> f64 {
+        self.shape.area()
+    }
+
+    fn perimeter(&self, accuracy: f64) -> f64 {
+        // TODO: Is this correct? Should it instead be based on the result of evaluating with the stored tolerance?
+        self.shape.perimeter(accuracy)
+    }
+
+    fn winding(&self, pt: kurbo::Point) -> i32 {
+        // TODO: Is this correct?
+        self.shape.winding(pt)
+    }
+
+    fn bounding_box(&self) -> Rect {
+        // TODO: Is this correct?
+        self.shape.bounding_box()
+    }
+}
+
 /// The recommended tolerance for approximating shapes which won't be rescaled as Bezier paths.
 ///
 /// This can be used as the tolerance parameter to [`within`], when you know that
diff --git a/sparse_strips/vello_api/src/painter.rs b/sparse_strips/vello_api/src/painter.rs
index 0e2134a0e..09afa5a81 100644
--- a/sparse_strips/vello_api/src/painter.rs
+++ b/sparse_strips/vello_api/src/painter.rs
@@ -3,9 +3,10 @@
 
 use core::any::Any;
 
-use peniko::kurbo::{Affine, BezPath, Rect, Shape, Stroke};
+use peniko::kurbo::{Affine, BezPath, Rect, Stroke};
 use peniko::{BlendMode, Brush, Color, Fill, ImageBrush};
 
+use crate::exact::ExactPathElements;
 use crate::scene::Scene;
 use crate::texture::TextureId;
 
@@ -86,13 +87,18 @@ pub trait PaintScene: Any {
     /// Both `shape` and the current brush will be transformed using the 2d affine `transform`.
     /// See the documentation on [`Fill`]'s variants for details on when you might choose a given fill rule.
     // It would be really nice to have images of nested paths here, to explain winding numbers.
-    fn fill_path(&mut self, transform: Affine, fill_rule: Fill, path: impl Shape);
+    fn fill_path(&mut self, transform: Affine, fill_rule: Fill, path: impl ExactPathElements);
 
     /// Stroke along `path` with the current brush, following the given stroke parameters.
     ///
     /// Both the stroked area and the current brush will be transformed using the 2d affine `transform`.
     /// Dashes configured in the stroke parameter will be expanded.
-    fn stroke_path(&mut self, transform: Affine, stroke_params: &Stroke, path: impl Shape);
+    fn stroke_path(
+        &mut self,
+        transform: Affine,
+        stroke_params: &Stroke,
+        path: impl ExactPathElements,
+    );
 
     /// Set the current brush to `brush`.
     ///
@@ -198,7 +204,7 @@ pub trait PaintScene: Any {
     fn push_layer(
         &mut self,
         clip_transform: Affine,
-        clip_path: Option<impl Shape>,
+        clip_path: Option<impl ExactPathElements>,
         blend_mode: Option<BlendMode>,
         opacity: Option<f32>,
     );
@@ -212,7 +218,7 @@ pub trait PaintScene: Any {
     ///
     /// **However, the transforms are *not* saved or modified by the layer stack.**
     /// That is, the `transform` argument to this function only applies a transform to the `clip` shape.
-    fn push_clip_layer(&mut self, clip_transform: Affine, path: impl Shape) {
+    fn push_clip_layer(&mut self, clip_transform: Affine, path: impl ExactPathElements) {
         self.push_layer(clip_transform, Some(path), None, None);
     }
 
diff --git a/sparse_strips/vello_api/src/paths.rs b/sparse_strips/vello_api/src/paths.rs
index b75965ad1..00b4e2c54 100644
--- a/sparse_strips/vello_api/src/paths.rs
+++ b/sparse_strips/vello_api/src/paths.rs
@@ -15,10 +15,9 @@
 //! for each path).
 
 use alloc::vec::Vec;
-use peniko::{
-    Style,
-    kurbo::{PathEl, Shape},
-};
+use peniko::{Style, kurbo::PathEl};
+
+use crate::exact::ExactPathElements;
 
 /// The id for a single path within a given [`PathSet`].
 /// This is an index into the [`meta`](PathSet::meta) field.
@@ -87,13 +86,13 @@ impl PathSet {
     /// See the docs on [`append`](PathSet::append) for how this changes when path sets are combined.
     ///
     /// This method is generally only expected to be used by [`Scene`](crate::Scene).
-    pub fn prepare_shape(&mut self, shape: &impl Shape, style: impl Into<Style>) -> PathId {
+    pub fn prepare_shape(
+        &mut self,
+        shape: &impl ExactPathElements,
+        style: impl Into<Style>,
+    ) -> PathId {
         let start_index = self.elements.len();
-        // TODO: We hard-code this tolerance to be 0.1, as every other call does so.
-        // We should maybe change that at some point?
-        // https://xi.zulipchat.com/#narrow/channel/197075-vello/topic/Determining.20correct.20.60Shape.60.20tolerance/with/565793178
-        // If you need a different tolerance, you should pass in a `BezPath` (i.e. using Shape::to_path with the tolerance you require)
-        self.elements.extend(shape.path_elements(0.1));
+        self.elements.extend(shape.exact_path_elements());
         let meta_index = self.meta.len();
         self.meta.push(PathMeta {
             start_index,
diff --git a/sparse_strips/vello_api/src/scene.rs b/sparse_strips/vello_api/src/scene.rs
index 8031bfee7..2ec4c6f4b 100644
--- a/sparse_strips/vello_api/src/scene.rs
+++ b/sparse_strips/vello_api/src/scene.rs
@@ -17,6 +17,7 @@ use peniko::{
 
 use crate::{
     PaintScene, StandardBrush,
+    exact::ExactPathElements,
     paths::{PathId, PathSet},
 };
 
@@ -230,7 +231,12 @@ impl PaintScene for Scene {
         Ok(())
     }
 
-    fn fill_path(&mut self, transform: Affine, fill_rule: peniko::Fill, path: impl kurbo::Shape) {
+    fn fill_path(
+        &mut self,
+        transform: Affine,
+        fill_rule: peniko::Fill,
+        path: impl ExactPathElements,
+    ) {
         let idx = self.paths.prepare_shape(&path, fill_rule);
         self.commands.push(RenderCommand::DrawPath(transform, idx));
     }
@@ -239,7 +245,7 @@ impl PaintScene for Scene {
         &mut self,
         transform: Affine,
         stroke_params: &kurbo::Stroke,
-        path: impl kurbo::Shape,
+        path: impl ExactPathElements,
     ) {
         let idx = self.paths.prepare_shape(&path, stroke_params.clone());
         self.commands.push(RenderCommand::DrawPath(transform, idx));
@@ -273,7 +279,7 @@ impl PaintScene for Scene {
     fn push_layer(
         &mut self,
         clip_transform: Affine,
-        clip_path: Option<impl kurbo::Shape>,
+        clip_path: Option<impl ExactPathElements>,
         blend_mode: Option<BlendMode>,
         opacity: Option<f32>,
         // mask: Option<Mask>,
diff --git a/sparse_strips/vello_cpu/src/api.rs b/sparse_strips/vello_cpu/src/api.rs
index 75f828bd5..1fd890f9c 100644
--- a/sparse_strips/vello_cpu/src/api.rs
+++ b/sparse_strips/vello_cpu/src/api.rs
@@ -12,6 +12,7 @@
 
 use vello_api::{
     PaintScene, Scene,
+    exact::ExactPathElements,
     peniko::Style,
     scene::{RenderCommand, extract_integer_translation},
     texture::TextureId,
@@ -133,7 +134,7 @@ impl PaintScene for CPUScenePainter {
         Ok(())
     }
 
-    fn fill_path(&mut self, transform: Affine, fill_rule: Fill, path: impl Shape) {
+    fn fill_path(&mut self, transform: Affine, fill_rule: Fill, path: impl ExactPathElements) {
         self.render_context.set_transform(transform);
         self.render_context.set_fill_rule(fill_rule);
         // TODO: Tweak inner `fill_path` API to either take a `Shape` or an &[PathEl]
@@ -198,7 +199,7 @@ impl PaintScene for CPUScenePainter {
     fn push_layer(
         &mut self,
         clip_transform: Affine,
-        clip_path: Option<impl Shape>,
+        clip_path: Option<impl ExactPathElements>,
         blend_mode: Option<BlendMode>,
         opacity: Option<f32>,
         // mask: Option<Mask>,

From 159457b9de247a359a195d6cc9616a4b00e72349 Mon Sep 17 00:00:00 2001
From: Daniel McNab <36049421+DJMcNab@users.noreply.github.com>
Date: Fri, 23 Jan 2026 17:02:29 +0000
Subject: [PATCH 03/14] Improve docs and make Shape subtrait again

---
 sparse_strips/vello_api/src/exact.rs  | 43 ++++++++-------------------
 sparse_strips/vello_cpu/src/api.rs    | 24 ++++++++++-----
 sparse_strips/vello_hybrid/src/api.rs | 25 +++++++++++-----
 3 files changed, 47 insertions(+), 45 deletions(-)

diff --git a/sparse_strips/vello_api/src/exact.rs b/sparse_strips/vello_api/src/exact.rs
index 2349936de..dea3bb8cb 100644
--- a/sparse_strips/vello_api/src/exact.rs
+++ b/sparse_strips/vello_api/src/exact.rs
@@ -3,7 +3,7 @@
 
 //! Turning shapes into Bézier paths without approximation.
 
-use kurbo::{BezPath, CubicBez, Line, PathEl, QuadBez, Rect, Segments, Shape, Triangle, segments};
+use kurbo::{BezPath, CubicBez, Line, QuadBez, Rect, Segments, Shape, Triangle, segments};
 use peniko::kurbo;
 
 /// A generic trait for shapes that can be mapped exactly to Bézier path elements (i.e., without
@@ -17,14 +17,10 @@ use peniko::kurbo;
 /// [`RoundedRect`](kurbo::RoundedRect)), you can use [`within`].
 /// Note that the returned shape will use.
 /// This however requires you to provide the tolerance.
+///
+/// It is a requirement of this trait that [`Shape::path_elements`] returns the same iterator
+/// as [`ExactPathElements::exact_path_elements`] for any provided tolerance value.
 pub trait ExactPathElements: Shape {
-    /// The iterator returned by the [`Self::exact_path_elements`] method.
-    ///
-    /// In many cases, this will be the same iterator as [`Shape::path_elements`]
-    type ExactPathElementsIter<'iter>: Iterator<Item = PathEl> + 'iter
-    where
-        Self: 'iter;
-
     /// Returns an iterator over this shape expressed as exact [`PathEl`]s;
     /// that is, as exact Bézier path _elements_.
     ///
@@ -39,29 +35,23 @@ pub trait ExactPathElements: Shape {
     /// allocating; however creating a [`BezPath`] object always allocates.
     /// If you need an owned [`BezPath`] you can use [`BezPath::from_iter`] (or
     /// [`Iterator::collect`]).
-    fn exact_path_elements(&self) -> Self::ExactPathElementsIter<'_>;
+    fn exact_path_elements(&self) -> Self::PathElementsIter<'_>;
 
     /// Returns an iterator over this shape expressed as exact Bézier path
     /// _segments_ ([`PathSeg`]s).
     ///
     /// The allocation behaviour is the same as for [`ExactPathElements::exact_path_elements`].
     ///
-    /// [`PathSeg`]: crate::PathSeg
+    /// [`PathSeg`]: kurbo::PathSeg
     #[inline]
-    fn exact_path_segments(&self) -> Segments<Self::ExactPathElementsIter<'_>> {
+    fn exact_path_segments(&self) -> Segments<Self::PathElementsIter<'_>> {
         segments(self.exact_path_elements())
     }
 }
 
-impl<'a, T: ExactPathElements> ExactPathElements for &'a T {
-    type ExactPathElementsIter<'iter>
-        = T::ExactPathElementsIter<'iter>
-    where
-        T: 'iter,
-        'a: 'iter;
-
+impl<T: ExactPathElements> ExactPathElements for &T {
     #[inline]
-    fn exact_path_elements(&self) -> Self::ExactPathElementsIter<'_> {
+    fn exact_path_elements(&self) -> Self::PathElementsIter<'_> {
         (*self).exact_path_elements()
     }
 }
@@ -73,7 +63,7 @@ impl<'a, T: ExactPathElements> ExactPathElements for &'a T {
 /// to renderers which use Vello API.
 ///
 /// As the user of this function, you are responsible for determining the correct tolerance for your use case.
-/// A reasonable approach might be to select a tolerance which allows scaling up ("zooming in") by 8x to be
+/// A reasonable approach might be to select a tolerance which allows scaling up ("zooming in") by 4x to be
 /// within your intended tolernace bound, then recomputing the [`Scene`](crate::Scene) from your base data
 /// representation once that is exceeded.
 /// If you know that the shape will not be scaled, you can use [`UNSCALED_TOLERANCE`].
@@ -94,19 +84,14 @@ pub struct WithTolerance<S: Shape> {
 }
 
 impl<S: Shape> ExactPathElements for WithTolerance<S> {
-    type ExactPathElementsIter<'iter>
-        = S::PathElementsIter<'iter>
-    where
-        S: 'iter;
-
-    fn exact_path_elements(&self) -> Self::ExactPathElementsIter<'_> {
+    fn exact_path_elements(&self) -> Self::PathElementsIter<'_> {
         self.shape.path_elements(self.tolerance)
     }
 }
 
 impl<S: Shape> Shape for WithTolerance<S> {
     type PathElementsIter<'iter>
-        = <Self as ExactPathElements>::ExactPathElementsIter<'iter>
+        = S::PathElementsIter<'iter>
     where
         S: 'iter;
 
@@ -147,9 +132,7 @@ pub const UNSCALED_TOLERANCE: f64 = 0.1;
 macro_rules! passthrough {
     ($ty: ty) => {
         impl ExactPathElements for $ty {
-            type ExactPathElementsIter<'iter> = <$ty as Shape>::PathElementsIter<'iter>;
-
-            fn exact_path_elements(&self) -> Self::ExactPathElementsIter<'_> {
+            fn exact_path_elements(&self) -> Self::PathElementsIter<'_> {
                 // We use a tolerance of zero here because we know this to be exact.
                 self.path_elements(0.)
             }
diff --git a/sparse_strips/vello_cpu/src/api.rs b/sparse_strips/vello_cpu/src/api.rs
index 1fd890f9c..1e59ccd0e 100644
--- a/sparse_strips/vello_cpu/src/api.rs
+++ b/sparse_strips/vello_cpu/src/api.rs
@@ -18,7 +18,7 @@ use vello_api::{
     texture::TextureId,
 };
 use vello_common::{
-    kurbo::{self, Affine, BezPath, Shape},
+    kurbo::{self, Affine, BezPath},
     paint::{ImageId, ImageSource},
     peniko::{BlendMode, Brush, Color, Fill, ImageBrush},
 };
@@ -137,13 +137,22 @@ impl PaintScene for CPUScenePainter {
     fn fill_path(&mut self, transform: Affine, fill_rule: Fill, path: impl ExactPathElements) {
         self.render_context.set_transform(transform);
         self.render_context.set_fill_rule(fill_rule);
-        // TODO: Tweak inner `fill_path` API to either take a `Shape` or an &[PathEl]
+        // This tolerance parameter is meaningless, because this is an `ExactPathElements`
+        // However, using `to_path` avoids allocation in some cases.
+        // TODO: Tweak inner API to accept an `ExactPathElements` (or at least, the resultant iterator)
+        // That would also fix the need for the tolerance parameter.
         self.render_context.fill_path(&path.into_path(0.1));
     }
 
-    fn stroke_path(&mut self, transform: Affine, stroke_params: &kurbo::Stroke, path: impl Shape) {
+    fn stroke_path(
+        &mut self,
+        transform: Affine,
+        stroke_params: &kurbo::Stroke,
+        path: impl ExactPathElements,
+    ) {
         self.render_context.set_transform(transform);
         self.render_context.set_stroke(stroke_params.clone());
+        // TODO: As in `fill_path`
         self.render_context.stroke_path(&path.into_path(0.1));
     }
 
@@ -209,6 +218,7 @@ impl PaintScene for CPUScenePainter {
         self.render_context.set_fill_rule(Fill::NonZero);
         self.render_context.set_transform(clip_transform);
         self.render_context.push_layer(
+            // TODO: As in `fill_path`
             clip_path.map(|it| it.into_path(0.1)).as_ref(),
             blend_mode,
             opacity,
@@ -217,13 +227,11 @@ impl PaintScene for CPUScenePainter {
         );
     }
 
-    fn push_clip_layer(&mut self, clip_transform: Affine, path: impl Shape) {
+    fn push_clip_layer(&mut self, clip_transform: Affine, path: impl ExactPathElements) {
         self.render_context.set_fill_rule(Fill::NonZero);
         self.render_context.set_transform(clip_transform);
-        self.render_context.push_clip_layer(
-            // TODO: Not allocate
-            &path.into_path(0.1),
-        );
+        // TODO: As in `fill_path`
+        self.render_context.push_clip_layer(&path.into_path(0.1));
     }
 
     fn pop_layer(&mut self) {
diff --git a/sparse_strips/vello_hybrid/src/api.rs b/sparse_strips/vello_hybrid/src/api.rs
index 896432dc9..6ea849904 100644
--- a/sparse_strips/vello_hybrid/src/api.rs
+++ b/sparse_strips/vello_hybrid/src/api.rs
@@ -12,12 +12,13 @@
 
 use vello_api::{
     PaintScene, Scene,
+    exact::ExactPathElements,
     peniko::Style,
     scene::{RenderCommand, extract_integer_translation},
     texture::TextureId,
 };
 use vello_common::{
-    kurbo::{self, Affine, BezPath, Shape},
+    kurbo::{self, Affine, BezPath},
     paint::{ImageId, ImageSource},
     peniko::{BlendMode, Brush, Color, Fill, ImageBrush},
 };
@@ -131,16 +132,25 @@ impl PaintScene for HybridScenePainter {
         Ok(())
     }
 
-    fn fill_path(&mut self, transform: Affine, fill_rule: Fill, path: impl Shape) {
+    fn fill_path(&mut self, transform: Affine, fill_rule: Fill, path: impl ExactPathElements) {
         self.scene.set_transform(transform);
         self.scene.set_fill_rule(fill_rule);
-        // TODO: Tweak inner `fill_path` API to either take a `Shape` or an &[PathEl]
+        // This tolerance parameter is meaningless, because this is an `ExactPathElements`
+        // However, using `to_path` avoids allocation in some cases.
+        // TODO: Tweak inner API to accept an `ExactPathElements` (or at least, the resultant iterator)
+        // That would also fix the need for the tolerance parameter.
         self.scene.fill_path(&path.into_path(0.1));
     }
 
-    fn stroke_path(&mut self, transform: Affine, stroke_params: &kurbo::Stroke, path: impl Shape) {
+    fn stroke_path(
+        &mut self,
+        transform: Affine,
+        stroke_params: &kurbo::Stroke,
+        path: impl ExactPathElements,
+    ) {
         self.scene.set_transform(transform);
         self.scene.set_stroke(stroke_params.clone());
+        // TODO: As in `fill_path`
         self.scene.stroke_path(&path.into_path(0.1));
     }
 
@@ -179,7 +189,7 @@ impl PaintScene for HybridScenePainter {
     fn push_layer(
         &mut self,
         clip_transform: Affine,
-        clip_path: Option<impl Shape>,
+        clip_path: Option<impl ExactPathElements>,
         blend_mode: Option<BlendMode>,
         opacity: Option<f32>,
         // mask: Option<Mask>,
@@ -189,6 +199,7 @@ impl PaintScene for HybridScenePainter {
         self.scene.set_fill_rule(Fill::NonZero);
         self.scene.set_transform(clip_transform);
         self.scene.push_layer(
+            // TODO: As in `fill_path`
             clip_path.map(|it| it.into_path(0.1)).as_ref(),
             blend_mode,
             opacity,
@@ -197,10 +208,10 @@ impl PaintScene for HybridScenePainter {
         );
     }
 
-    fn push_clip_layer(&mut self, clip_transform: Affine, path: impl Shape) {
+    fn push_clip_layer(&mut self, clip_transform: Affine, path: impl ExactPathElements) {
         self.scene.set_transform(clip_transform);
         self.scene.push_clip_layer(
-            // TODO: Not allocate
+            // TODO: As in `fill_path`
             &path.into_path(0.1),
         );
     }

From 651818af29a4f27e0bf37512c1d6e1c9e4b64806 Mon Sep 17 00:00:00 2001
From: Daniel McNab <36049421+DJMcNab@users.noreply.github.com>
Date: Fri, 23 Jan 2026 17:23:10 +0000
Subject: [PATCH 04/14] Fix docs

---
 sparse_strips/vello_api/src/exact.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sparse_strips/vello_api/src/exact.rs b/sparse_strips/vello_api/src/exact.rs
index dea3bb8cb..c97bf22c1 100644
--- a/sparse_strips/vello_api/src/exact.rs
+++ b/sparse_strips/vello_api/src/exact.rs
@@ -21,7 +21,7 @@ use peniko::kurbo;
 /// It is a requirement of this trait that [`Shape::path_elements`] returns the same iterator
 /// as [`ExactPathElements::exact_path_elements`] for any provided tolerance value.
 pub trait ExactPathElements: Shape {
-    /// Returns an iterator over this shape expressed as exact [`PathEl`]s;
+    /// Returns an iterator over this shape expressed as exact [`PathEl`](kurbo::PathEl)s;
     /// that is, as exact Bézier path _elements_.
     ///
     /// These path elements are exact, in the sense that no approximation is required

From a69f47a0830bbd81a5633cc4e2edb294c0709604 Mon Sep 17 00:00:00 2001
From: Daniel McNab <36049421+DJMcNab@users.noreply.github.com>
Date: Mon, 26 Jan 2026 17:04:52 +0000
Subject: [PATCH 05/14] Initial changes

Co-authored-by: Taj Pereira <taj@canva.com>
---
 sparse_strips/vello_api/src/exact.rs | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/sparse_strips/vello_api/src/exact.rs b/sparse_strips/vello_api/src/exact.rs
index c97bf22c1..52f19edf5 100644
--- a/sparse_strips/vello_api/src/exact.rs
+++ b/sparse_strips/vello_api/src/exact.rs
@@ -12,7 +12,7 @@ use peniko::kurbo;
 /// The methods on [`PaintScene`](crate::PaintScene) use this trait ensure that consistent behaviour
 /// is maintained when Vello API is used to render content which might be rescaled.
 ///
-/// This is implemented for several [`Shape`]s from Kurbo.
+/// This is implemented for [`Shape`]s from Kurbo that can be exactly mapped to Bézier path elements.
 /// To convert a [`Shape`] which requires approximation (such as [`Circle`](kurbo::Circle) or
 /// [`RoundedRect`](kurbo::RoundedRect)), you can use [`within`].
 /// Note that the returned shape will use.
@@ -59,16 +59,18 @@ impl<T: ExactPathElements> ExactPathElements for &T {
 /// Use an approximated shape where an [`ExactPathElements`] is required, by approximating it to
 /// within the given tolerance.
 ///
-/// This is useful for drawing shapes such as [`Circle`](kurbo::Circle)s and [`RoundedRect`](kurbo::RoundedRect)s
-/// to renderers which use Vello API.
+/// *WARNING*: Unlike [`ExactPathElements`], which will produce correct renderings for any scale, this
+/// approximation is only valid for a fixed range of transforms.
 ///
 /// As the user of this function, you are responsible for determining the correct tolerance for your use case.
-/// A reasonable approach might be to select a tolerance which allows scaling up ("zooming in") by 4x to be
-/// within your intended tolernace bound, then recomputing the [`Scene`](crate::Scene) from your base data
+/// A reasonable approach might be to select a tolerance which allows scaling up ("zooming in") by 4x (for example, 0.00001) to be
+/// within your intended tolerance bound, then recomputing the [`Scene`](crate::Scene) from your base data
 /// representation once that is exceeded.
 /// If you know that the shape will not be scaled, you can use [`UNSCALED_TOLERANCE`].
 /// The resulting path will be within 1/10th of a pixel of the actual shape, which is a negligible
 /// difference for rendering.
+///
+/// This is useful for drawing shapes such as [`Circle`](kurbo::Circle)s and [`RoundedRect`](kurbo::RoundedRect)s.
 // TODO: Provide as an extension trait?
 pub fn within<S: Shape>(shape: S, tolerance: f64) -> WithTolerance<S> {
     WithTolerance { shape, tolerance }
@@ -139,8 +141,8 @@ macro_rules! passthrough {
         }
     };
 }
-passthrough!(BezPath);
 
+passthrough!(BezPath);
 passthrough!(CubicBez);
 passthrough!(Line);
 passthrough!(QuadBez);

From 8228d5bc5eb5e24e4bf2dad4d5c5a282c17fc83e Mon Sep 17 00:00:00 2001
From: Daniel McNab <36049421+DJMcNab@users.noreply.github.com>
Date: Mon, 26 Jan 2026 17:07:41 +0000
Subject: [PATCH 06/14] Remove sentence fragment

I don't know what I was trying to say :)
---
 sparse_strips/vello_api/src/exact.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sparse_strips/vello_api/src/exact.rs b/sparse_strips/vello_api/src/exact.rs
index 52f19edf5..2db38d48c 100644
--- a/sparse_strips/vello_api/src/exact.rs
+++ b/sparse_strips/vello_api/src/exact.rs
@@ -15,8 +15,8 @@ use peniko::kurbo;
 /// This is implemented for [`Shape`]s from Kurbo that can be exactly mapped to Bézier path elements.
 /// To convert a [`Shape`] which requires approximation (such as [`Circle`](kurbo::Circle) or
 /// [`RoundedRect`](kurbo::RoundedRect)), you can use [`within`].
-/// Note that the returned shape will use.
 /// This however requires you to provide the tolerance.
+/// See the docs of `within` for more details.
 ///
 /// It is a requirement of this trait that [`Shape::path_elements`] returns the same iterator
 /// as [`ExactPathElements::exact_path_elements`] for any provided tolerance value.

From 5b4e851fca917fad53e9c9643f584accbfdc3288 Mon Sep 17 00:00:00 2001
From: Daniel McNab <36049421+DJMcNab@users.noreply.github.com>
Date: Tue, 27 Jan 2026 12:12:36 +0000
Subject: [PATCH 07/14] Remove the `Shape` supertrait again

---
 sparse_strips/vello_api/src/exact.rs  | 63 ++++++++++++---------------
 sparse_strips/vello_cpu/src/api.rs    | 15 ++++---
 sparse_strips/vello_hybrid/src/api.rs | 13 +++---
 3 files changed, 45 insertions(+), 46 deletions(-)

diff --git a/sparse_strips/vello_api/src/exact.rs b/sparse_strips/vello_api/src/exact.rs
index 2db38d48c..46f2c2159 100644
--- a/sparse_strips/vello_api/src/exact.rs
+++ b/sparse_strips/vello_api/src/exact.rs
@@ -4,7 +4,7 @@
 //! Turning shapes into Bézier paths without approximation.
 
 use kurbo::{BezPath, CubicBez, Line, QuadBez, Rect, Segments, Shape, Triangle, segments};
-use peniko::kurbo;
+use peniko::kurbo::{self, PathEl};
 
 /// A generic trait for shapes that can be mapped exactly to Bézier path elements (i.e., without
 /// approximation).
@@ -20,7 +20,14 @@ use peniko::kurbo;
 ///
 /// It is a requirement of this trait that [`Shape::path_elements`] returns the same iterator
 /// as [`ExactPathElements::exact_path_elements`] for any provided tolerance value.
-pub trait ExactPathElements: Shape {
+pub trait ExactPathElements {
+    /// The iterator returned by the [`Self::exact_path_elements`] method.
+    ///
+    /// In many cases, this will be the same iterator as [`Shape::path_elements`]
+    type ExactPathElementsIter<'iter>: Iterator<Item = PathEl> + 'iter
+    where
+        Self: 'iter;
+
     /// Returns an iterator over this shape expressed as exact [`PathEl`](kurbo::PathEl)s;
     /// that is, as exact Bézier path _elements_.
     ///
@@ -35,7 +42,7 @@ pub trait ExactPathElements: Shape {
     /// allocating; however creating a [`BezPath`] object always allocates.
     /// If you need an owned [`BezPath`] you can use [`BezPath::from_iter`] (or
     /// [`Iterator::collect`]).
-    fn exact_path_elements(&self) -> Self::PathElementsIter<'_>;
+    fn exact_path_elements(&self) -> Self::ExactPathElementsIter<'_>;
 
     /// Returns an iterator over this shape expressed as exact Bézier path
     /// _segments_ ([`PathSeg`]s).
@@ -44,14 +51,19 @@ pub trait ExactPathElements: Shape {
     ///
     /// [`PathSeg`]: kurbo::PathSeg
     #[inline]
-    fn exact_path_segments(&self) -> Segments<Self::PathElementsIter<'_>> {
+    fn exact_path_segments(&self) -> Segments<Self::ExactPathElementsIter<'_>> {
         segments(self.exact_path_elements())
     }
 }
 
 impl<T: ExactPathElements> ExactPathElements for &T {
+    type ExactPathElementsIter<'iter>
+        = T::ExactPathElementsIter<'iter>
+    where
+        Self: 'iter;
+
     #[inline]
-    fn exact_path_elements(&self) -> Self::PathElementsIter<'_> {
+    fn exact_path_elements(&self) -> Self::ExactPathElementsIter<'_> {
         (*self).exact_path_elements()
     }
 }
@@ -86,38 +98,12 @@ pub struct WithTolerance<S: Shape> {
 }
 
 impl<S: Shape> ExactPathElements for WithTolerance<S> {
-    fn exact_path_elements(&self) -> Self::PathElementsIter<'_> {
-        self.shape.path_elements(self.tolerance)
-    }
-}
-
-impl<S: Shape> Shape for WithTolerance<S> {
-    type PathElementsIter<'iter>
+    type ExactPathElementsIter<'iter>
         = S::PathElementsIter<'iter>
     where
         S: 'iter;
-
-    fn path_elements(&self, _tolerance: f64) -> Self::PathElementsIter<'_> {
-        self.exact_path_elements()
-    }
-
-    fn area(&self) -> f64 {
-        self.shape.area()
-    }
-
-    fn perimeter(&self, accuracy: f64) -> f64 {
-        // TODO: Is this correct? Should it instead be based on the result of evaluating with the stored tolerance?
-        self.shape.perimeter(accuracy)
-    }
-
-    fn winding(&self, pt: kurbo::Point) -> i32 {
-        // TODO: Is this correct?
-        self.shape.winding(pt)
-    }
-
-    fn bounding_box(&self) -> Rect {
-        // TODO: Is this correct?
-        self.shape.bounding_box()
+    fn exact_path_elements(&self) -> Self::ExactPathElementsIter<'_> {
+        self.shape.path_elements(self.tolerance)
     }
 }
 
@@ -129,12 +115,17 @@ pub const UNSCALED_TOLERANCE: f64 = 0.1;
 
 // TODO: Provide an `fn ideal_tolerance(transform: Affine) -> f64`
 
-/// Implement `ExactPathElements` for an existing [`Shape`], which we know
+/// Implement `ExactPathElements` for an existing [`Shape`], which we know will not be approximated in Kurbo.
 // In theory, the impl is the wrong way around; instead the `Shape` impl should be in terms of `ExactPathElements`.
 macro_rules! passthrough {
     ($ty: ty) => {
         impl ExactPathElements for $ty {
-            fn exact_path_elements(&self) -> Self::PathElementsIter<'_> {
+            type ExactPathElementsIter<'iter>
+                = <$ty as Shape>::PathElementsIter<'iter>
+            where
+                $ty: 'iter;
+
+            fn exact_path_elements(&self) -> Self::ExactPathElementsIter<'_> {
                 // We use a tolerance of zero here because we know this to be exact.
                 self.path_elements(0.)
             }
diff --git a/sparse_strips/vello_cpu/src/api.rs b/sparse_strips/vello_cpu/src/api.rs
index 1e59ccd0e..0b86d8c07 100644
--- a/sparse_strips/vello_cpu/src/api.rs
+++ b/sparse_strips/vello_cpu/src/api.rs
@@ -140,8 +140,9 @@ impl PaintScene for CPUScenePainter {
         // This tolerance parameter is meaningless, because this is an `ExactPathElements`
         // However, using `to_path` avoids allocation in some cases.
         // TODO: Tweak inner API to accept an `ExactPathElements` (or at least, the resultant iterator)
-        // That would also fix the need for the tolerance parameter.
-        self.render_context.fill_path(&path.into_path(0.1));
+        // That would avoid the superfluous allocation here.
+        self.render_context
+            .fill_path(&path.exact_path_elements().collect());
     }
 
     fn stroke_path(
@@ -153,7 +154,8 @@ impl PaintScene for CPUScenePainter {
         self.render_context.set_transform(transform);
         self.render_context.set_stroke(stroke_params.clone());
         // TODO: As in `fill_path`
-        self.render_context.stroke_path(&path.into_path(0.1));
+        self.render_context
+            .stroke_path(&path.exact_path_elements().collect());
     }
 
     fn set_brush(
@@ -219,7 +221,9 @@ impl PaintScene for CPUScenePainter {
         self.render_context.set_transform(clip_transform);
         self.render_context.push_layer(
             // TODO: As in `fill_path`
-            clip_path.map(|it| it.into_path(0.1)).as_ref(),
+            clip_path
+                .map(|it| it.exact_path_elements().collect())
+                .as_ref(),
             blend_mode,
             opacity,
             None,
@@ -231,7 +235,8 @@ impl PaintScene for CPUScenePainter {
         self.render_context.set_fill_rule(Fill::NonZero);
         self.render_context.set_transform(clip_transform);
         // TODO: As in `fill_path`
-        self.render_context.push_clip_layer(&path.into_path(0.1));
+        self.render_context
+            .push_clip_layer(&path.exact_path_elements().collect());
     }
 
     fn pop_layer(&mut self) {
diff --git a/sparse_strips/vello_hybrid/src/api.rs b/sparse_strips/vello_hybrid/src/api.rs
index 6ea849904..7ce228929 100644
--- a/sparse_strips/vello_hybrid/src/api.rs
+++ b/sparse_strips/vello_hybrid/src/api.rs
@@ -138,8 +138,8 @@ impl PaintScene for HybridScenePainter {
         // This tolerance parameter is meaningless, because this is an `ExactPathElements`
         // However, using `to_path` avoids allocation in some cases.
         // TODO: Tweak inner API to accept an `ExactPathElements` (or at least, the resultant iterator)
-        // That would also fix the need for the tolerance parameter.
-        self.scene.fill_path(&path.into_path(0.1));
+        // That would avoid the superfluous allocation here.
+        self.scene.fill_path(&path.exact_path_elements().collect());
     }
 
     fn stroke_path(
@@ -151,7 +151,8 @@ impl PaintScene for HybridScenePainter {
         self.scene.set_transform(transform);
         self.scene.set_stroke(stroke_params.clone());
         // TODO: As in `fill_path`
-        self.scene.stroke_path(&path.into_path(0.1));
+        self.scene
+            .stroke_path(&path.exact_path_elements().collect());
     }
 
     fn set_brush(
@@ -200,7 +201,9 @@ impl PaintScene for HybridScenePainter {
         self.scene.set_transform(clip_transform);
         self.scene.push_layer(
             // TODO: As in `fill_path`
-            clip_path.map(|it| it.into_path(0.1)).as_ref(),
+            clip_path
+                .map(|it| it.exact_path_elements().collect())
+                .as_ref(),
             blend_mode,
             opacity,
             None,
@@ -212,7 +215,7 @@ impl PaintScene for HybridScenePainter {
         self.scene.set_transform(clip_transform);
         self.scene.push_clip_layer(
             // TODO: As in `fill_path`
-            &path.into_path(0.1),
+            &path.exact_path_elements().collect(),
         );
     }
 

From 098ec2ea740504aeac740f87a0ff40af2f699985 Mon Sep 17 00:00:00 2001
From: Daniel McNab <36049421+DJMcNab@users.noreply.github.com>
Date: Tue, 27 Jan 2026 12:12:51 +0000
Subject: [PATCH 08/14] Drive-By: Add tracking link to blurred rounded
 rectangles

---
 sparse_strips/vello_hybrid/src/api.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/sparse_strips/vello_hybrid/src/api.rs b/sparse_strips/vello_hybrid/src/api.rs
index 7ce228929..d999bc716 100644
--- a/sparse_strips/vello_hybrid/src/api.rs
+++ b/sparse_strips/vello_hybrid/src/api.rs
@@ -184,7 +184,10 @@ impl PaintScene for HybridScenePainter {
         _radius: f32,
         _std_dev: f32,
     ) {
-        unimplemented!("Vello Hybrid doesn't support drawing blurred rounded rectangles yet.")
+        unimplemented!(
+            "Vello Hybrid doesn't support drawing blurred rounded rectangles yet.\n\
+            This is tracked in https://github.com/linebender/vello/issues/1373."
+        )
     }
 
     fn push_layer(

From 4904c2445151cc09419f2a59b8ccbc37e669bfe8 Mon Sep 17 00:00:00 2001
From: Daniel McNab <36049421+DJMcNab@users.noreply.github.com>
Date: Tue, 27 Jan 2026 13:43:10 +0000
Subject: [PATCH 09/14] Fix link

---
 sparse_strips/vello_api/src/exact.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sparse_strips/vello_api/src/exact.rs b/sparse_strips/vello_api/src/exact.rs
index 46f2c2159..3152deae4 100644
--- a/sparse_strips/vello_api/src/exact.rs
+++ b/sparse_strips/vello_api/src/exact.rs
@@ -28,7 +28,7 @@ pub trait ExactPathElements {
     where
         Self: 'iter;
 
-    /// Returns an iterator over this shape expressed as exact [`PathEl`](kurbo::PathEl)s;
+    /// Returns an iterator over this shape expressed as exact [`PathEl`]s;
     /// that is, as exact Bézier path _elements_.
     ///
     /// These path elements are exact, in the sense that no approximation is required

From 8bfd288063aff8143b4c6c5d8f8a33ce9e4e189a Mon Sep 17 00:00:00 2001
From: Daniel McNab <36049421+DJMcNab@users.noreply.github.com>
Date: Wed, 28 Jan 2026 13:21:19 +0000
Subject: [PATCH 10/14] Pass in paths through a `&impl ExactPathElements`

---
 sparse_strips/vello_api/src/exact.rs   |  2 +-
 sparse_strips/vello_api/src/painter.rs | 14 +++++++-------
 sparse_strips/vello_api/src/scene.rs   |  6 +++---
 sparse_strips/vello_cpu/src/api.rs     |  8 ++++----
 sparse_strips/vello_hybrid/src/api.rs  |  8 ++++----
 5 files changed, 19 insertions(+), 19 deletions(-)

diff --git a/sparse_strips/vello_api/src/exact.rs b/sparse_strips/vello_api/src/exact.rs
index 3152deae4..1675a7aa3 100644
--- a/sparse_strips/vello_api/src/exact.rs
+++ b/sparse_strips/vello_api/src/exact.rs
@@ -89,7 +89,7 @@ pub fn within<S: Shape>(shape: S, tolerance: f64) -> WithTolerance<S> {
 }
 
 /// The type used to implement [`within`].
-#[derive(Debug)]
+#[derive(Debug, Clone, Copy)]
 pub struct WithTolerance<S: Shape> {
     /// The shape to be approximated.
     pub shape: S,
diff --git a/sparse_strips/vello_api/src/painter.rs b/sparse_strips/vello_api/src/painter.rs
index 09afa5a81..24369d230 100644
--- a/sparse_strips/vello_api/src/painter.rs
+++ b/sparse_strips/vello_api/src/painter.rs
@@ -87,7 +87,7 @@ pub trait PaintScene: Any {
     /// Both `shape` and the current brush will be transformed using the 2d affine `transform`.
     /// See the documentation on [`Fill`]'s variants for details on when you might choose a given fill rule.
     // It would be really nice to have images of nested paths here, to explain winding numbers.
-    fn fill_path(&mut self, transform: Affine, fill_rule: Fill, path: impl ExactPathElements);
+    fn fill_path(&mut self, transform: Affine, fill_rule: Fill, path: &impl ExactPathElements);
 
     /// Stroke along `path` with the current brush, following the given stroke parameters.
     ///
@@ -97,7 +97,7 @@ pub trait PaintScene: Any {
         &mut self,
         transform: Affine,
         stroke_params: &Stroke,
-        path: impl ExactPathElements,
+        path: &impl ExactPathElements,
     );
 
     /// Set the current brush to `brush`.
@@ -180,7 +180,7 @@ pub trait PaintScene: Any {
         let kernel_size = (2.5 * std_dev) as f64;
 
         let shape: Rect = rect.inflate(kernel_size, kernel_size);
-        self.fill_path(transform, Fill::EvenOdd, shape);
+        self.fill_path(transform, Fill::EvenOdd, &shape);
     }
 
     /// Pushes a new layer clipped by the specified shape (if provided) and composed with
@@ -204,7 +204,7 @@ pub trait PaintScene: Any {
     fn push_layer(
         &mut self,
         clip_transform: Affine,
-        clip_path: Option<impl ExactPathElements>,
+        clip_path: Option<&impl ExactPathElements>,
         blend_mode: Option<BlendMode>,
         opacity: Option<f32>,
     );
@@ -218,7 +218,7 @@ pub trait PaintScene: Any {
     ///
     /// **However, the transforms are *not* saved or modified by the layer stack.**
     /// That is, the `transform` argument to this function only applies a transform to the `clip` shape.
-    fn push_clip_layer(&mut self, clip_transform: Affine, path: impl ExactPathElements) {
+    fn push_clip_layer(&mut self, clip_transform: Affine, path: &impl ExactPathElements) {
         self.push_layer(clip_transform, Some(path), None, None);
     }
 
@@ -230,7 +230,7 @@ pub trait PaintScene: Any {
         self.push_layer(
             Affine::IDENTITY,
             // This needing to be turbofished shows a real footgun with the proposed "push_layer" API here.
-            None::<BezPath>,
+            None::<&BezPath>,
             Some(blend_mode),
             None,
         );
@@ -245,7 +245,7 @@ pub trait PaintScene: Any {
     /// Every drawing command after this call will be composed as described
     /// until the layer is [popped](PaintScene::pop_layer).
     fn push_opacity_layer(&mut self, opacity: f32) {
-        self.push_layer(Affine::IDENTITY, None::<BezPath>, None, Some(opacity));
+        self.push_layer(Affine::IDENTITY, None::<&BezPath>, None, Some(opacity));
     }
 
     /// Pop the most recently pushed layer.
diff --git a/sparse_strips/vello_api/src/scene.rs b/sparse_strips/vello_api/src/scene.rs
index 2ec4c6f4b..3a98a85e3 100644
--- a/sparse_strips/vello_api/src/scene.rs
+++ b/sparse_strips/vello_api/src/scene.rs
@@ -235,7 +235,7 @@ impl PaintScene for Scene {
         &mut self,
         transform: Affine,
         fill_rule: peniko::Fill,
-        path: impl ExactPathElements,
+        path: &impl ExactPathElements,
     ) {
         let idx = self.paths.prepare_shape(&path, fill_rule);
         self.commands.push(RenderCommand::DrawPath(transform, idx));
@@ -245,7 +245,7 @@ impl PaintScene for Scene {
         &mut self,
         transform: Affine,
         stroke_params: &kurbo::Stroke,
-        path: impl ExactPathElements,
+        path: &impl ExactPathElements,
     ) {
         let idx = self.paths.prepare_shape(&path, stroke_params.clone());
         self.commands.push(RenderCommand::DrawPath(transform, idx));
@@ -279,7 +279,7 @@ impl PaintScene for Scene {
     fn push_layer(
         &mut self,
         clip_transform: Affine,
-        clip_path: Option<impl ExactPathElements>,
+        clip_path: Option<&impl ExactPathElements>,
         blend_mode: Option<BlendMode>,
         opacity: Option<f32>,
         // mask: Option<Mask>,
diff --git a/sparse_strips/vello_cpu/src/api.rs b/sparse_strips/vello_cpu/src/api.rs
index 0b86d8c07..35ff39818 100644
--- a/sparse_strips/vello_cpu/src/api.rs
+++ b/sparse_strips/vello_cpu/src/api.rs
@@ -134,7 +134,7 @@ impl PaintScene for CPUScenePainter {
         Ok(())
     }
 
-    fn fill_path(&mut self, transform: Affine, fill_rule: Fill, path: impl ExactPathElements) {
+    fn fill_path(&mut self, transform: Affine, fill_rule: Fill, path: &impl ExactPathElements) {
         self.render_context.set_transform(transform);
         self.render_context.set_fill_rule(fill_rule);
         // This tolerance parameter is meaningless, because this is an `ExactPathElements`
@@ -149,7 +149,7 @@ impl PaintScene for CPUScenePainter {
         &mut self,
         transform: Affine,
         stroke_params: &kurbo::Stroke,
-        path: impl ExactPathElements,
+        path: &impl ExactPathElements,
     ) {
         self.render_context.set_transform(transform);
         self.render_context.set_stroke(stroke_params.clone());
@@ -210,7 +210,7 @@ impl PaintScene for CPUScenePainter {
     fn push_layer(
         &mut self,
         clip_transform: Affine,
-        clip_path: Option<impl ExactPathElements>,
+        clip_path: Option<&impl ExactPathElements>,
         blend_mode: Option<BlendMode>,
         opacity: Option<f32>,
         // mask: Option<Mask>,
@@ -231,7 +231,7 @@ impl PaintScene for CPUScenePainter {
         );
     }
 
-    fn push_clip_layer(&mut self, clip_transform: Affine, path: impl ExactPathElements) {
+    fn push_clip_layer(&mut self, clip_transform: Affine, path: &impl ExactPathElements) {
         self.render_context.set_fill_rule(Fill::NonZero);
         self.render_context.set_transform(clip_transform);
         // TODO: As in `fill_path`
diff --git a/sparse_strips/vello_hybrid/src/api.rs b/sparse_strips/vello_hybrid/src/api.rs
index d999bc716..076194155 100644
--- a/sparse_strips/vello_hybrid/src/api.rs
+++ b/sparse_strips/vello_hybrid/src/api.rs
@@ -132,7 +132,7 @@ impl PaintScene for HybridScenePainter {
         Ok(())
     }
 
-    fn fill_path(&mut self, transform: Affine, fill_rule: Fill, path: impl ExactPathElements) {
+    fn fill_path(&mut self, transform: Affine, fill_rule: Fill, path: &impl ExactPathElements) {
         self.scene.set_transform(transform);
         self.scene.set_fill_rule(fill_rule);
         // This tolerance parameter is meaningless, because this is an `ExactPathElements`
@@ -146,7 +146,7 @@ impl PaintScene for HybridScenePainter {
         &mut self,
         transform: Affine,
         stroke_params: &kurbo::Stroke,
-        path: impl ExactPathElements,
+        path: &impl ExactPathElements,
     ) {
         self.scene.set_transform(transform);
         self.scene.set_stroke(stroke_params.clone());
@@ -193,7 +193,7 @@ impl PaintScene for HybridScenePainter {
     fn push_layer(
         &mut self,
         clip_transform: Affine,
-        clip_path: Option<impl ExactPathElements>,
+        clip_path: Option<&impl ExactPathElements>,
         blend_mode: Option<BlendMode>,
         opacity: Option<f32>,
         // mask: Option<Mask>,
@@ -214,7 +214,7 @@ impl PaintScene for HybridScenePainter {
         );
     }
 
-    fn push_clip_layer(&mut self, clip_transform: Affine, path: impl ExactPathElements) {
+    fn push_clip_layer(&mut self, clip_transform: Affine, path: &impl ExactPathElements) {
         self.scene.set_transform(clip_transform);
         self.scene.push_clip_layer(
             // TODO: As in `fill_path`

From d3b9a7e31c9aa7b04991dc3791baa64b8e34e8d2 Mon Sep 17 00:00:00 2001
From: Daniel McNab <36049421+DJMcNab@users.noreply.github.com>
Date: Wed, 28 Jan 2026 13:23:26 +0000
Subject: [PATCH 11/14] Drive-by fix: improve handling of `Style` for clips

---
 sparse_strips/vello_cpu/src/api.rs    | 1 +
 sparse_strips/vello_hybrid/src/api.rs | 2 ++
 2 files changed, 3 insertions(+)

diff --git a/sparse_strips/vello_cpu/src/api.rs b/sparse_strips/vello_cpu/src/api.rs
index 35ff39818..a363f3c56 100644
--- a/sparse_strips/vello_cpu/src/api.rs
+++ b/sparse_strips/vello_cpu/src/api.rs
@@ -87,6 +87,7 @@ impl PaintScene for CPUScenePainter {
                         .set_transform(push_layer_command.clip_transform);
                     let clip_path = if let Some(path_id) = push_layer_command.clip_path {
                         let path = &input_paths.meta[usize::try_from(path_id.0).unwrap()];
+                        // TODO: Also correctly support the case where the meta has a `Style::Stroke`
                         let path_end = &input_paths
                             .meta
                             .get(usize::try_from(path_id.0).unwrap() + 1)
diff --git a/sparse_strips/vello_hybrid/src/api.rs b/sparse_strips/vello_hybrid/src/api.rs
index 076194155..3a6ebe61f 100644
--- a/sparse_strips/vello_hybrid/src/api.rs
+++ b/sparse_strips/vello_hybrid/src/api.rs
@@ -85,6 +85,7 @@ impl PaintScene for HybridScenePainter {
                     self.scene.set_transform(push_layer_command.clip_transform);
                     let clip_path = if let Some(path_id) = push_layer_command.clip_path {
                         let path = &input_paths.meta[usize::try_from(path_id.0).unwrap()];
+                        // TODO: Also correctly support the case where the meta has a `Style::Stroke`
                         let path_end = &input_paths
                             .meta
                             .get(usize::try_from(path_id.0).unwrap() + 1)
@@ -215,6 +216,7 @@ impl PaintScene for HybridScenePainter {
     }
 
     fn push_clip_layer(&mut self, clip_transform: Affine, path: &impl ExactPathElements) {
+        self.scene.set_fill_rule(Fill::NonZero);
         self.scene.set_transform(clip_transform);
         self.scene.push_clip_layer(
             // TODO: As in `fill_path`

From 882164e11f806ad9f801a5cfdec6f2223f29416c Mon Sep 17 00:00:00 2001
From: Daniel McNab <36049421+DJMcNab@users.noreply.github.com>
Date: Fri, 6 Feb 2026 14:49:08 +0000
Subject: [PATCH 12/14] Update sparse_strips/vello_cpu/src/api.rs

Co-authored-by: Taj Pereira <taj@canva.com>
---
 sparse_strips/vello_cpu/src/api.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/sparse_strips/vello_cpu/src/api.rs b/sparse_strips/vello_cpu/src/api.rs
index a363f3c56..23a22b611 100644
--- a/sparse_strips/vello_cpu/src/api.rs
+++ b/sparse_strips/vello_cpu/src/api.rs
@@ -138,7 +138,6 @@ impl PaintScene for CPUScenePainter {
     fn fill_path(&mut self, transform: Affine, fill_rule: Fill, path: &impl ExactPathElements) {
         self.render_context.set_transform(transform);
         self.render_context.set_fill_rule(fill_rule);
-        // This tolerance parameter is meaningless, because this is an `ExactPathElements`
         // However, using `to_path` avoids allocation in some cases.
         // TODO: Tweak inner API to accept an `ExactPathElements` (or at least, the resultant iterator)
         // That would avoid the superfluous allocation here.

From 32501e65d6f337fd06ca566c1a95fb8e668c04a9 Mon Sep 17 00:00:00 2001
From: Daniel McNab <36049421+DJMcNab@users.noreply.github.com>
Date: Fri, 6 Feb 2026 14:49:19 +0000
Subject: [PATCH 13/14] Update sparse_strips/vello_hybrid/src/api.rs

Co-authored-by: Taj Pereira <taj@canva.com>
---
 sparse_strips/vello_hybrid/src/api.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/sparse_strips/vello_hybrid/src/api.rs b/sparse_strips/vello_hybrid/src/api.rs
index 3a6ebe61f..203b33e87 100644
--- a/sparse_strips/vello_hybrid/src/api.rs
+++ b/sparse_strips/vello_hybrid/src/api.rs
@@ -136,7 +136,6 @@ impl PaintScene for HybridScenePainter {
     fn fill_path(&mut self, transform: Affine, fill_rule: Fill, path: &impl ExactPathElements) {
         self.scene.set_transform(transform);
         self.scene.set_fill_rule(fill_rule);
-        // This tolerance parameter is meaningless, because this is an `ExactPathElements`
         // However, using `to_path` avoids allocation in some cases.
         // TODO: Tweak inner API to accept an `ExactPathElements` (or at least, the resultant iterator)
         // That would avoid the superfluous allocation here.

From 08ce9de8982b76da1554b8710084ee51dfc5ce86 Mon Sep 17 00:00:00 2001
From: Daniel McNab <36049421+DJMcNab@users.noreply.github.com>
Date: Fri, 6 Feb 2026 14:55:36 +0000
Subject: [PATCH 14/14] Tweak the doc comment to remove the over-precise
 0.00001

---
 sparse_strips/vello_api/src/exact.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/sparse_strips/vello_api/src/exact.rs b/sparse_strips/vello_api/src/exact.rs
index 1675a7aa3..d02c61008 100644
--- a/sparse_strips/vello_api/src/exact.rs
+++ b/sparse_strips/vello_api/src/exact.rs
@@ -75,9 +75,9 @@ impl<T: ExactPathElements> ExactPathElements for &T {
 /// approximation is only valid for a fixed range of transforms.
 ///
 /// As the user of this function, you are responsible for determining the correct tolerance for your use case.
-/// A reasonable approach might be to select a tolerance which allows scaling up ("zooming in") by 4x (for example, 0.00001) to be
-/// within your intended tolerance bound, then recomputing the [`Scene`](crate::Scene) from your base data
-/// representation once that is exceeded.
+/// A reasonable approach might be to select a tolerance which allows scaling up ("zooming in") by 4x (for example;
+/// you should evaluate the correct value yourself) and remaining within your intended tolerance bound.
+/// If the user zoomed past that limit, you would then recomputing the [`Scene`](crate::Scene) from your base data representation once that is exceeded.
 /// If you know that the shape will not be scaled, you can use [`UNSCALED_TOLERANCE`].
 /// The resulting path will be within 1/10th of a pixel of the actual shape, which is a negligible
 /// difference for rendering.