diff --git a/crates/eps/src/import/graphics.rs b/crates/eps/src/import/graphics.rs
index 5d4f7b9fa..bd6f25287 100644
--- a/crates/eps/src/import/graphics.rs
+++ b/crates/eps/src/import/graphics.rs
@@ -17,6 +17,14 @@ use vectorcraft_geom::{Affine, BezPath, FillRule, PathData, Point, Rect, Vec2};
 use super::interp::{Interp, MAX_GSAVE, matrix_obj};
 use super::obj::{DictRef, Key, Obj, Op, PsError, Res, Shared, clamp_between, ps_err};
 
+mod ops;
+mod paint;
+mod path;
+mod state;
+
+pub(crate) use paint::collapse;
+pub(crate) use state::{GState, Out, Space, process};
+
 /// Most objects one file makes.
 const MAX_NODES: usize = 1 << 20;
 /// Objects reaching further than this from the page (points) come from damaged coordinates and
@@ -61,1775 +69,3 @@ const NESTED_PATTERNS: &str = "patterns nested too deeply are filled with mid-gr
 pub(crate) const MAX_APART: u32 = 8;
 const UNKNOWN_FUNCTIONS: &str = "shadings whose functions are of an unknown type are filled with their middle colour";
 const UNKNOWN_SHADINGS: &str = "shadings of an unknown type were left out";
-
-/// A colour space.
-#[derive(Clone, Debug)]
-pub(crate) enum Space {
-    Gray,
-    Rgb,
-    Cmyk,
-    /// Separation and DeviceN: the ink names, the alternate space and the tint transform.
-    Inks {
-        names: Vec<Rc<str>>,
-        alt: Rc<Space>,
-        tint: Obj,
-    },
-    Indexed {
-        base: Rc<Space>,
-        table: Rc<Vec<f64>>,
-    },
-    /// Patterns; an uncoloured one paints in a colour of the underlying space.
-    Pattern(Option<Rc<Space>>),
-}
-
-impl Space {
-    /// Components a colour has in it.
-    pub fn n(&self) -> usize {
-        match self {
-            Self::Gray | Self::Indexed { .. } | Self::Pattern(_) => 1,
-            Self::Rgb => 3,
-            Self::Cmyk => 4,
-            Self::Inks { names, .. } => names.len().max(1),
-        }
-    }
-
-    /// The colour `setcolorspace` starts with.
-    fn initial(&self) -> Vec<f64> {
-        match self {
-            Self::Cmyk => vec![0.0, 0.0, 0.0, 1.0],
-            Self::Inks { names, .. } => vec![1.0; names.len().max(1)],
-            s => vec![0.0; s.n()],
-        }
-    }
-}
-
-/// A process colour from components in `space` (grey, RGB or CMYK), each clamped to 0–1.
-pub(crate) fn process(space: &Space, c: &[f64]) -> Option<Color> {
-    let v = |i: usize| c.get(i).map_or(0.0, |x| if x.is_finite() { x.clamp(0.0, 1.0) as f32 } else { 0.0 });
-    Some(match space {
-        Space::Gray => Color::gray(1.0 - v(0)),
-        Space::Rgb => Color::rgb(v(0), v(1), v(2)),
-        Space::Cmyk => Color::cmyk(v(0), v(1), v(2), v(3)),
-        _ => return None,
-    })
-}
-
-#[derive(Clone, Debug)]
-pub(crate) struct GState {
-    /// User space → PostScript's default space.
-    pub ctm: Affine,
-    pub space: Rc<Space>,
-    /// The `setcolorspace` operand, for `currentcolorspace`.
-    pub space_obj: Obj,
-    pub comps: Vec<f64>,
-    pub paint: Paint,
-    pub width: f64,
-    pub cap: LineCap,
-    pub join: LineJoin,
-    pub miter: f64,
-    /// The dash pattern, shared by the states saved or copied from this one.
-    pub dash: Rc<[f64]>,
-    pub dash_offset: f64,
-    /// The current path, in document space.
-    pub path: BezPath,
-    pub cur: Option<Point>,
-    pub start: Option<Point>,
-    pub clips: Vec<Arc<Clip>>,
-    /// The clips `clipsave` saved, for `cliprestore`.
-    pub saved_clips: Vec<Rc<[Arc<Clip>]>>,
-    pub overprint: bool,
-    pub font: Option<DictRef>,
-    /// `nulldevice`: painting draws nothing.
-    pub null: bool,
-    /// The colour is a shading pattern whose shading is a mesh: a fill paints it (the shading
-    /// and pattern space → the document).
-    pub mesh: Option<(DictRef, Affine)>,
-}
-
-impl Default for GState {
-    fn default() -> Self {
-        Self {
-            ctm: Affine::IDENTITY,
-            space: Rc::new(Space::Gray),
-            space_obj: Obj::name("DeviceGray"),
-            comps: vec![0.0],
-            paint: Paint::solid(Color::gray(1.0)),
-            width: 1.0,
-            cap: LineCap::Butt,
-            join: LineJoin::Miter,
-            miter: 10.0,
-            dash: Rc::from([]),
-            dash_offset: 0.0,
-            path: BezPath::new(),
-            cur: None,
-            start: None,
-            clips: vec![],
-            saved_clips: vec![],
-            overprint: false,
-            font: None,
-            null: false,
-            mesh: None,
-        }
-    }
-}
-
-/// What the program draws.
-pub(crate) struct Out {
-    /// The document being made: ids, images and swatches.
-    pub doc: Document,
-    pub drawn: Drawn,
-    pub warnings: Vec<String>,
-    /// PostScript's default space → document space.
-    pub page: Affine,
-    /// The page (the bounding box) in document space.
-    pub frame: Rect,
-    /// Clip and group ids are given in the order they open, so a chain of both sorts by id.
-    next_clip: u32,
-    /// The groups open (outermost first), and how many more opened past [`MAX_NEST`] (their art
-    /// goes in the innermost group kept).
-    groups: Vec<Arc<Clip>>,
-    too_deep: usize,
-    /// Path elements (and the clips and groups of each object) drawn so far (see [`MAX_DRAWN`]).
-    elements: usize,
-    /// The path the last object was filled with: a stroke of the same path right after joins it.
-    merge: Option<BezPath>,
-    /// Process colours painted, by model (the document opens in CMYK when most are).
-    pub cmyk: usize,
-    pub rgb: usize,
-    /// Spot inks used: name and colour at full tint.
-    pub spots: Vec<(String, Color)>,
-    /// The color at full tint of each spot ink in [`Self::spots`], by name.
-    spot_colors: HashMap<Rc<str>, Color>,
-    /// Rectangles painted with a shading (`shfill`): a clipping group of one is the clip path
-    /// filled with it.
-    pub shadings: HashSet<NodeId>,
-    /// Tiling patterns made into pattern swatches: the pattern's `PaintProc` (a pattern made
-    /// again with `makepattern` shares it) and cell, the colour an uncoloured one painted in, and
-    /// the swatch's name. Each list holds the patterns of one [`tiling_hash`]; a pattern whose
-    /// cell has a NaN corner is left out.
-    tilings: HashMap<u64, Vec<Tiling>>,
-    /// How deep art drawn apart (a pattern's cell, a Type 3 glyph) is nested.
-    pub apart: u32,
-}
-
-fn sane(r: Rect) -> bool {
-    [r.x0, r.y0, r.x1, r.y1].iter().all(|v| v.is_finite() && v.abs() <= LIMIT)
-}
-
-/// A tiling pattern made into a pattern swatch, as [`Out::tilings`] lists it.
-type Tiling = (Shared<Obj>, Rect, Option<Paint>, String);
-
-/// A hash of what tells tiling patterns apart in [`Out::tilings`]. Patterns that compare equal
-/// hash alike: each number goes in by its bits, and −0 goes in as 0.
-fn tiling_hash(proc: &Shared<Obj>, tile: Rect, under: Option<&Paint>) -> u64 {
-    let mut h = DefaultHasher::new();
-    proc.hash(&mut h);
-    [tile.x0, tile.y0, tile.x1, tile.y1].map(|v| (v + 0.0).to_bits()).hash(&mut h);
-    if let Some(Paint::Solid { color, swatch, tint }) = under {
-        let c = match *color {
-            Color::Rgb { r, g, b } => [r, g, b, 0.0],
-            Color::Cmyk { c, m, y, k } => [c, m, y, k],
-            Color::Gray { k } => [k, 0.0, 0.0, 0.0],
-            Color::Lab { l, a, b } => [l, a, b, 0.0],
-        };
-        c.map(|v| (v + 0.0).to_bits()).hash(&mut h);
-        swatch.hash(&mut h);
-        (tint + 0.0).to_bits().hash(&mut h);
-    }
-    h.finish()
-}
-
-impl Out {
-    pub fn new(doc: Document, page: Affine, frame: Rect) -> Self {
-        Self {
-            doc,
-            drawn: vec![],
-            warnings: vec![],
-            page,
-            frame,
-            next_clip: 0,
-            groups: vec![],
-            too_deep: 0,
-            elements: 0,
-            merge: None,
-            cmyk: 0,
-            rgb: 0,
-            spots: vec![],
-            spot_colors: HashMap::new(),
-            shadings: HashSet::new(),
-            tilings: HashMap::new(),
-            apart: 0,
-        }
-    }
-
-    pub fn warn(&mut self, w: &str) {
-        if !self.warnings.iter().any(|x| x == w) {
-            self.warnings.push(w.to_string());
-        }
-    }
-
-    /// Open a group: what is drawn until it ends ([`Self::end_group`]) goes in it.
-    pub fn begin_group(&mut self) {
-        if self.groups.len() >= MAX_NEST {
-            self.too_deep += 1;
-            self.warn(&format!("groups nested more than {MAX_NEST} deep were read as part of the group around them"));
-            return;
-        }
-        self.next_clip += 1;
-        self.groups.push(Arc::new(Clip { id: self.next_clip, region: None }));
-    }
-
-    /// End the innermost group open (an end without a beginning ends nothing).
-    pub fn end_group(&mut self) {
-        if self.too_deep > 0 {
-            self.too_deep -= 1;
-        } else {
-            self.groups.pop();
-        }
-    }
-
-    /// The chain an object drawn under `clips` is drawn in: the clips and the groups open, in the
-    /// order they opened.
-    pub fn chain(&self, clips: &[Arc<Clip>]) -> Vec<Arc<Clip>> {
-        if self.groups.is_empty() {
-            return clips.to_vec();
-        }
-        let mut chain = Vec::with_capacity(clips.len() + self.groups.len());
-        let (mut a, mut b) = (clips.iter().peekable(), self.groups.iter().peekable());
-        while let (Some(x), Some(y)) = (a.peek(), b.peek()) {
-            let next = if x.id < y.id { a.next() } else { b.next() };
-            chain.extend(next.cloned());
-        }
-        chain.extend(a.chain(b).cloned());
-        chain
-    }
-
-    /// Add `node` under `clips` (in the groups open); `None` when it was left out.
-    pub fn push(&mut self, mut node: Node, clips: &[Arc<Clip>]) -> Option<NodeId> {
-        self.merge = None;
-        let chain = self.chain(clips);
-        let size = node.path_data().map_or(1, |p| p.subpaths.iter().map(|s| s.anchors.len()).sum()) + chain.len();
-        self.elements = self.elements.saturating_add(size);
-        if self.drawn.len() >= MAX_NODES || self.elements > MAX_DRAWN {
-            self.warn(TOO_MUCH);
-            return None;
-        }
-        if !node.visual_bounds().is_none_or(sane) {
-            self.warn(FAR_AWAY);
-            return None;
-        }
-        node.id = self.doc.alloc_id();
-        let id = node.id;
-        self.drawn.push((chain, node));
-        Some(id)
-    }
-
-    /// Count a paint's colour model.
-    fn count(&mut self, p: &Paint) {
-        match p {
-            Paint::Solid { color: Color::Cmyk { .. }, swatch: None, .. } => self.cmyk += 1,
-            Paint::Solid { color: Color::Rgb { .. }, swatch: None, .. } => self.rgb += 1,
-            _ => {}
-        }
-    }
-
-    /// Fill `bp` with `paint`.
-    fn fill(&mut self, bp: BezPath, rule: FillRule, paint: Paint, overprint: bool, clips: &[Arc<Clip>]) {
-        self.count(&paint);
-        let item = AppearanceItem::Fill(FillLayer { overprint, ..FillLayer::new(paint) });
-        let mut n = Node::path(NodeId(0), PathData::from_bezpath(&bp), Appearance { items: vec![item], ..Appearance::default() });
-        if let NodeKind::Path { rule: r, .. } = &mut n.kind {
-            *r = rule;
-        }
-        if self.push(n, clips).is_some() {
-            self.merge = Some(bp);
-        }
-    }
-
-    /// Stroke `bp` with `st`: joins the object just filled with the same path, under the same
-    /// clips (`gsave fill grestore stroke`).
-    fn stroke(&mut self, bp: BezPath, st: StrokeLayer, clips: &[Arc<Clip>]) {
-        self.count(&st.paint);
-        if self.merge.as_ref() == Some(&bp) {
-            let here = self.chain(clips);
-            if let Some((chain, last)) = self.drawn.last_mut()
-                && chain.iter().map(|c| c.id).eq(here.iter().map(|c| c.id))
-            {
-                last.appearance.items.push(AppearanceItem::Stroke(st));
-                self.merge = None;
-                return;
-            }
-        }
-        let n = Node::path(NodeId(0), PathData::from_bezpath(&bp), Appearance { items: vec![AppearanceItem::Stroke(st)], ..Appearance::default() });
-        self.push(n, clips);
-    }
-
-    /// A new clip of `path` inside `clips`; `None` for a rectangle around the whole page, which
-    /// clips nothing.
-    fn clip(&mut self, path: BezPath, rule: FillRule) -> Option<Arc<Clip>> {
-        // Only a polygon that really covers the page: a diamond touching its edges has the page as
-        // its bounding box but cuts its corners away (#1542).
-        if path.elements().len() <= 6 && vectorcraft_geom::hit::polygon_covers_rect(&path, self.frame, 0.5) {
-            return None;
-        }
-        self.next_clip += 1;
-        Some(Arc::new(Clip { id: self.next_clip, region: Some((path, rule)) }))
-    }
-}
-
-/// The smallest angle from `a` to `b` (radians, −π to π).
-fn turn(a: f64, b: f64) -> f64 {
-    let d = (b - a).rem_euclid(std::f64::consts::TAU);
-    if d > std::f64::consts::PI { d - std::f64::consts::TAU } else { d }
-}
-
-/// The angle from `a` counterclockwise to `b` (degrees, 0 to 360), worked out from what is left
-/// of each after whole turns.
-fn ccw_turn(a: f64, b: f64) -> f64 {
-    (b % 360.0 - a % 360.0).rem_euclid(360.0)
-}
-
-impl Interp<'_> {
-    /// User space → document space.
-    pub fn xf(&self) -> Affine {
-        self.out.page * self.g.ctm
-    }
-
-    /// How much user-space lengths grow in the document.
-    pub fn scale(&self) -> f64 {
-        let s = self.xf().determinant().abs().sqrt();
-        if s.is_finite() { s } else { 0.0 }
-    }
-
-    /// The current point in user space.
-    pub fn user_point(&self) -> Res<Point> {
-        let p = self.g.cur.ok_or(PsError::Ps("nocurrentpoint", String::new()))?;
-        let inv = self.xf();
-        if inv.determinant().abs() < 1e-12 {
-            return ps_err("undefinedresult", "");
-        }
-        Ok(inv.inverse() * p)
-    }
-
-    pub fn gsave(&mut self) -> Res {
-        if self.saved.len() >= MAX_GSAVE {
-            return Err(PsError::Limit("too many saved graphics states"));
-        }
-        self.alloc(std::mem::size_of_val(self.g.path.elements()))?;
-        self.saved.push(self.g.clone());
-        Ok(())
-    }
-
-    pub fn grestore(&mut self) {
-        if let Some(g) = self.saved.pop() {
-            self.g = g;
-        }
-    }
-
-    // ---------- paths ----------
-
-    /// Room for one more element in the current path.
-    pub fn grow(&self) -> Res {
-        if self.g.path.elements().len() >= MAX_PATH {
-            return Err(PsError::Limit("a path has too many points"));
-        }
-        Ok(())
-    }
-
-    /// Count `n` path elements an operator makes, reads or copies against the operation budget,
-    /// an operation each: making or reading an element takes up to about as long as an operation,
-    /// and copying one takes less (measured).
-    fn spend_elements(&mut self, n: usize) -> Res {
-        self.spend(n as u64)
-    }
-
-    fn move_to(&mut self, p: Point) -> Res {
-        self.grow()?;
-        // Consecutive movetos: the last one counts.
-        if let Some(PathEl::MoveTo(_)) = self.g.path.elements().last() {
-            self.g.path.pop();
-        }
-        self.g.path.move_to(p);
-        self.g.cur = Some(p);
-        self.g.start = Some(p);
-        Ok(())
-    }
-
-    fn line_to(&mut self, p: Point) -> Res {
-        self.grow()?;
-        if self.g.cur.is_none() {
-            return ps_err("nocurrentpoint", "");
-        }
-        self.g.path.line_to(p);
-        self.g.cur = Some(p);
-        Ok(())
-    }
-
-    /// Path elements in user space appended (the first move a line when there is a current point),
-    /// each counted against the operation budget.
-    fn append_user(&mut self, els: impl Iterator<Item = PathEl>) -> Res {
-        let xf = self.xf();
-        for el in els {
-            self.spend_elements(1)?;
-            match el {
-                PathEl::MoveTo(p) => {
-                    let p = xf * p;
-                    if self.g.cur.is_some() { self.line_to(p)? } else { self.move_to(p)? }
-                }
-                PathEl::LineTo(p) => self.line_to(xf * p)?,
-                PathEl::QuadTo(a, p) => {
-                    self.grow()?;
-                    self.g.path.quad_to(xf * a, xf * p);
-                    self.g.cur = Some(xf * p);
-                }
-                PathEl::CurveTo(a, b, p) => {
-                    self.grow()?;
-                    self.g.path.curve_to(xf * a, xf * b, xf * p);
-                    self.g.cur = Some(xf * p);
-                }
-                PathEl::ClosePath => {
-                    self.grow()?;
-                    self.g.path.close_path();
-                }
-            }
-        }
-        Ok(())
-    }
-
-    /// `arc` / `arcn`: from angle `a1` to `a2` (degrees, counter-clockwise or clockwise).
-    fn arc(&mut self, c: Point, r: f64, a1: f64, a2: f64, ccw: bool) -> Res {
-        // `arc` raises `a2` by multiples of 360 until it is at least `a1`, and `arcn` lowers it
-        // until it is at most `a1` (PLRM 3rd ed., `arc` and `arcn` in chapter 8). Those sweeps,
-        // and the first endpoint, are worked out from what is left of each angle after whole turns.
-        let sweep = if ccw && a2 < a1 {
-            ccw_turn(a1, a2)
-        } else if !ccw && a2 > a1 {
-            -ccw_turn(a2, a1)
-        } else {
-            a2 - a1
-        };
-        let tau = std::f64::consts::TAU;
-        let sweep = sweep.to_radians().clamp(-tau * 4.0, tau * 4.0);
-        let a1 = (a1 % 360.0).to_radians();
-        let start = c + Vec2::new(r * a1.cos(), r * a1.sin());
-        self.append_user(std::iter::once(PathEl::MoveTo(start)))?;
-        let arc = kurbo::Arc::new(c, Vec2::new(r, r), a1, sweep, 0.0);
-        let tol = (0.01 / self.scale().max(1e-9)).max(1e-9);
-        self.append_user(arc.append_iter(tol))
-    }
-
-    /// `arct` / `arcto`: a line towards `p1` rounded with radius `r` into the line to `p2`; the
-    /// tangent points (user space).
-    fn arct(&mut self, p1: Point, p2: Point, r: f64) -> Res<[Point; 2]> {
-        let p0 = self.user_point()?;
-        let (u, v) = (p0 - p1, p2 - p1);
-        let (lu, lv) = (u.hypot(), v.hypot());
-        let cross = u.cross(v);
-        if lu < 1e-12 || lv < 1e-12 || cross.abs() < 1e-12 || r <= 0.0 {
-            self.append_user(std::iter::once(PathEl::LineTo(p1)))?;
-            return Ok([p1, p1]);
-        }
-        let (u, v) = (u / lu, v / lv);
-        let half = u.dot(v).clamp(-1.0, 1.0).acos() / 2.0;
-        let dist = r / half.tan();
-        let (t1, t2) = (p1 + u * dist, p1 + v * dist);
-        let bis = (u + v).normalize();
-        let c = p1 + bis * (r / half.sin());
-        let (a1, a2) = ((t1 - c).atan2(), (t2 - c).atan2());
-        self.append_user(std::iter::once(PathEl::LineTo(t1)))?;
-        let tol = (0.01 / self.scale().max(1e-9)).max(1e-9);
-        let arc = kurbo::Arc::new(c, Vec2::new(r, r), a1, turn(a1, a2), 0.0);
-        self.append_user(arc.append_iter(tol))?;
-        Ok([t1, t2])
-    }
-
-    fn rect_path(&self, x: f64, y: f64, w: f64, h: f64) -> BezPath {
-        let xf = self.xf();
-        let mut bp = BezPath::new();
-        bp.move_to(xf * Point::new(x, y));
-        bp.line_to(xf * Point::new(x + w, y));
-        bp.line_to(xf * Point::new(x + w, y + h));
-        bp.line_to(xf * Point::new(x, y + h));
-        bp.close_path();
-        bp
-    }
-
-    /// The rectangles of `rectfill`, `rectstroke` and `rectclip`: `x y w h` or an array of them.
-    fn rects(&mut self) -> Res<BezPath> {
-        let nums: Vec<f64> = match self.stack.last() {
-            Some(Obj::Array { .. }) => {
-                let items = self.pop_array()?;
-                // Five elements a rectangle, counted before the array is read.
-                self.spend_elements(items.len() / 4 * 5)?;
-                let v: Option<Vec<f64>> = items.borrow().iter().map(Obj::as_num).collect();
-                v.ok_or(PsError::Ps("typecheck", String::new()))?
-            }
-            _ => self.nums::<4>()?.to_vec(),
-        };
-        if nums.len() / 4 * 5 >= MAX_PATH {
-            return Err(PsError::Limit("a path has too many points"));
-        }
-        let mut bp = BezPath::new();
-        for [x, y, w, h] in nums.as_chunks::<4>().0 {
-            bp.extend(self.rect_path(*x, *y, *w, *h));
-        }
-        Ok(bp)
-    }
-
-    // ---------- painting ----------
-
-    fn fill_path(&mut self, bp: BezPath, rule: FillRule) -> Res {
-        if bp.elements().is_empty() || self.g.null {
-            return Ok(());
-        }
-        // A mesh pattern paints its shading inside the path.
-        if let Some((sh, m)) = self.g.mesh.clone() {
-            let clips = self.g.clips.clone();
-            self.clip_with(bp, rule);
-            let r = self.mesh_fill(&sh, m);
-            self.g.clips = clips;
-            return r;
-        }
-        if self.g.paint.is_none() {
-            return Ok(());
-        }
-        let (paint, overprint) = (self.g.paint.clone(), self.g.overprint);
-        self.out.fill(bp, rule, paint, overprint, &self.g.clips);
-        Ok(())
-    }
-
-    fn stroke_path(&mut self, bp: BezPath) -> Res {
-        if bp.elements().is_empty() || self.g.paint.is_none() || self.g.null {
-            return Ok(());
-        }
-        let st = self.stroke_layer()?;
-        self.out.stroke(bp, st, &self.g.clips);
-        Ok(())
-    }
-
-    /// The stroke the graphics state draws, in document space. Each entry of the dash pattern it
-    /// copies counts as an operation.
-    fn stroke_layer(&mut self) -> Res<StrokeLayer> {
-        self.spend(self.g.dash.len() as u64)?;
-        let k = self.scale();
-        let w = self.g.width * k;
-        let mut st = StrokeLayer::new(self.g.paint.clone(), if w > 0.0 && w.is_finite() { w } else { HAIRLINE });
-        st.cap = self.g.cap;
-        st.join = self.g.join;
-        st.miter_limit = self.g.miter.clamp(1.0, 500.0);
-        st.overprint = self.g.overprint;
-        let pattern: Vec<f64> = self.g.dash.iter().map(|d| d * k).collect();
-        let dash = Dash { pattern, offset: self.g.dash_offset * k, align_corners: false };
-        st.dash = dash.is_dashed().then_some(dash);
-        Ok(st)
-    }
-
-    /// The current path in user space, each element as its operator and points (quadratic
-    /// segments as cubic ones).
-    fn user_elements(&self) -> Res<Vec<(Op, Vec<Point>)>> {
-        let xf = self.xf();
-        if xf.determinant().abs() < 1e-12 {
-            return ps_err("undefinedresult", "");
-        }
-        let inv = xf.inverse();
-        let mut last = Point::ZERO;
-        let mut out = Vec::with_capacity(self.g.path.elements().len());
-        for el in self.g.path.elements() {
-            let (op, pts) = match *el {
-                PathEl::MoveTo(p) => (Op::MoveTo, vec![p]),
-                PathEl::LineTo(p) => (Op::LineTo, vec![p]),
-                PathEl::QuadTo(a, p) => (Op::CurveTo, vec![last + (a - last) * (2.0 / 3.0), p + (a - p) * (2.0 / 3.0), p]),
-                PathEl::CurveTo(a, b, p) => (Op::CurveTo, vec![a, b, p]),
-                PathEl::ClosePath => (Op::ClosePath, vec![]),
-            };
-            last = pts.last().copied().unwrap_or(last);
-            out.push((op, pts.into_iter().map(|p| inv * p).collect()));
-        }
-        Ok(out)
-    }
-
-    /// `pathforall`: the current path in user space, each element through its procedure.
-    fn path_for_all(&mut self) -> Res {
-        let close = self.pop_proc()?;
-        let curve = self.pop_proc()?;
-        let line = self.pop_proc()?;
-        let mv = self.pop_proc()?;
-        self.spend_elements(self.g.path.elements().len())?;
-        for (op, pts) in self.user_elements()? {
-            for p in pts {
-                self.push_num(p.x)?;
-                self.push_num(p.y)?;
-            }
-            let proc = match op {
-                Op::MoveTo => &mv,
-                Op::LineTo => &line,
-                Op::CurveTo => &curve,
-                _ => &close,
-            };
-            if !self.body(proc)? {
-                break;
-            }
-        }
-        Ok(())
-    }
-
-    /// Append user path `up` to the current path: a procedure of path operators, or the encoded
-    /// form (numbers and a string of operator codes).
-    fn user_path(&mut self, up: Obj) -> Res {
-        let items = up.items().cloned().ok_or(PsError::Ps("typecheck", "a user path".into()))?;
-        let encoded = match (items.get(0), items.get(1), items.len()) {
-            (Some(nums @ (Obj::Array { .. } | Obj::Str(_))), Some(Obj::Str(ops)), 2) => Some((nums, ops.to_vec())),
-            _ => None,
-        };
-        let Some((nums, ops)) = encoded else { return self.call(Obj::Array { items, exec: true }) };
-        // The operators by code, with how many operands each takes.
-        const OPS: [(Op, usize); 12] = [
-            (Op::SetBBox, 4),
-            (Op::MoveTo, 2),
-            (Op::RMoveTo, 2),
-            (Op::LineTo, 2),
-            (Op::RLineTo, 2),
-            (Op::CurveTo, 6),
-            (Op::RCurveTo, 6),
-            (Op::Arc, 5),
-            (Op::Arcn, 5),
-            (Op::Arct, 5),
-            (Op::ClosePath, 0),
-            (Op::UCache, 0),
-        ];
-        let nums: Vec<f64> = match nums {
-            Obj::Array { items, .. } => {
-                // Each entry of the data array and each byte of the operator string counts as an
-                // element read.
-                self.spend_elements(items.len().saturating_add(ops.len()))?;
-                items.borrow().iter().filter_map(Obj::as_num).collect()
-            }
-            _ => return ps_err("typecheck", "an encoded user path"),
-        };
-        let mut next = nums.into_iter();
-        let mut repeat = 1usize;
-        for code in ops {
-            if code >= 32 {
-                repeat = usize::from(code - 32);
-                continue;
-            }
-            let &(op, n) = OPS.get(usize::from(code)).ok_or(PsError::Ps("rangecheck", "a user path".into()))?;
-            for _ in 0..std::mem::replace(&mut repeat, 1) {
-                for _ in 0..n {
-                    let v = next.next().ok_or(PsError::Ps("rangecheck", "a user path".into()))?;
-                    self.push_num(v)?;
-                }
-                // Each operator run counts as an operation.
-                self.spend(1)?;
-                self.op(op)?;
-            }
-        }
-        Ok(())
-    }
-
-    /// `ufill`, `ueofill`, `ustroke` (with an optional matrix): paint a user path, keeping the
-    /// current path.
-    fn paint_user_path(&mut self, op: Op) -> Res {
-        let m = match (op, self.stack.last()) {
-            (Op::UStroke, Some(Obj::Array { items, exec: false })) if items.len() == 6 && self.stack.len() >= 2 => Some(self.pop_matrix()?),
-            _ => None,
-        };
-        let up = self.pop()?;
-        self.gsave()?;
-        let depth = self.saved.len();
-        self.take_path();
-        let r = self.user_path(up).and_then(|()| {
-            if let Some(m) = m {
-                self.g.ctm *= m;
-            }
-            let bp = self.take_path();
-            match op {
-                Op::UStroke => self.stroke_path(bp),
-                _ => self.fill_path(bp, if op == Op::UEoFill { FillRule::EvenOdd } else { FillRule::NonZero }),
-            }
-        });
-        self.saved.truncate(depth);
-        self.grestore();
-        r
-    }
-
-    /// `upath`: the current path as a user path (a procedure, in user space).
-    fn upath(&mut self) -> Res {
-        self.pop_bool()?;
-        let elements = self.user_elements()?;
-        let b = self.xf().inverse().transform_rect_bbox(self.g.path.bounding_box());
-        let mut items: Vec<Obj> = [b.x0, b.y0, b.x1, b.y1].into_iter().map(Obj::Real).collect();
-        items.push(Obj::Op(Op::SetBBox));
-        for (op, pts) in elements {
-            items.extend(pts.iter().flat_map(|p| [Obj::Real(p.x), Obj::Real(p.y)]));
-            items.push(Obj::Op(op));
-        }
-        self.alloc(items.len() * std::mem::size_of::<Obj>())?;
-        self.push(Obj::proc(items))
-    }
-
-    /// `execform`: the form's `PaintProc` run with its matrix, clipped to its box.
-    fn exec_form(&mut self) -> Res {
-        let d = self.pop_dict()?;
-        let get = |k: &str| d.borrow().get(&Key::name(k)).cloned();
-        let m = get("Matrix").and_then(|o| o.items().and_then(|i| super::interp::matrix_of(&i.borrow()))).unwrap_or(Affine::IDENTITY);
-        let bbox: Vec<f64> = get("BBox").and_then(|o| o.items().map(|i| i.borrow().iter().filter_map(Obj::as_num).collect())).unwrap_or_default();
-        let paint = get("PaintProc").ok_or(PsError::Ps("undefined", "PaintProc".into()))?;
-        self.gsave()?;
-        let depth = self.saved.len();
-        self.g.ctm *= m;
-        if let [x0, y0, x1, y1] = bbox[..] {
-            let bp = self.rect_path(x0, y0, x1 - x0, y1 - y0);
-            self.take_path();
-            self.clip_with(bp, FillRule::NonZero);
-        }
-        self.push(Obj::Dict(d))?;
-        let r = self.call(paint);
-        self.saved.truncate(depth);
-        self.grestore();
-        r
-    }
-
-    pub(super) fn take_path(&mut self) -> BezPath {
-        self.g.cur = None;
-        self.g.start = None;
-        std::mem::take(&mut self.g.path)
-    }
-
-    fn clip_with(&mut self, path: BezPath, rule: FillRule) {
-        let Some(c) = self.out.clip(path, rule) else { return };
-        if self.g.clips.len() < MAX_NEST {
-            self.g.clips.push(c);
-        } else {
-            self.out.warn(&deep_clips());
-        }
-    }
-
-    /// The area the clip leaves, in document space (the page without a clip). The clip path read
-    /// counts against the operation budget.
-    fn clip_bounds(&mut self) -> Res<Rect> {
-        let (bounds, len) =
-            self.g.clips.iter().rev().find_map(|c| c.region.as_ref()).map_or((self.out.frame, 0), |(p, _)| (p.bounding_box(), p.elements().len()));
-        self.spend_elements(len)?;
-        Ok(bounds)
-    }
-
-    // ---------- colour ----------
-
-    /// A colour space operand.
-    pub(super) fn space_of(&mut self, o: &Obj, depth: u32) -> Res<Space> {
-        if depth > 4 {
-            return ps_err("limitcheck", "setcolorspace");
-        }
-        let (family, items) = match o {
-            Obj::Name(n) | Obj::Exec(n) => (n.clone(), vec![]),
-            Obj::Array { items, .. } => {
-                let v = items.to_vec();
-                let n = v.first().and_then(Obj::text).ok_or(PsError::Ps("typecheck", "setcolorspace".into()))?;
-                (n, v)
-            }
-            _ => return ps_err("typecheck", "setcolorspace"),
-        };
-        let arg = |i: usize| items.get(i).cloned().ok_or(PsError::Ps("rangecheck", "setcolorspace".into()));
-        Ok(match &*family {
-            "DeviceGray" | "CIEBasedA" | "CalGray" => Space::Gray,
-            "DeviceRGB" | "CIEBasedABC" | "CalRGB" | "Lab" | "CIEBasedDEF" => Space::Rgb,
-            "DeviceCMYK" | "CIEBasedDEFG" => Space::Cmyk,
-            "Pattern" => Space::Pattern(match items.get(1) {
-                Some(base) => Some(Rc::new(self.space_of(base, depth + 1)?)),
-                None => None,
-            }),
-            "ICCBased" => match arg(1)? {
-                Obj::Dict(d) => match d.borrow().get(&Key::name("N")).and_then(Obj::as_num) {
-                    Some(1.0) => Space::Gray,
-                    Some(4.0) => Space::Cmyk,
-                    _ => Space::Rgb,
-                },
-                _ => Space::Rgb,
-            },
-            "Separation" | "DeviceN" => {
-                let names: Vec<Rc<str>> = match arg(1)? {
-                    Obj::Array { items, .. } => items.borrow().iter().filter_map(Obj::text).collect(),
-                    o => o.text().into_iter().collect(),
-                };
-                if names.len() > MAX_INKS {
-                    return ps_err("limitcheck", "DeviceN");
-                }
-                let alt = self.space_of(&arg(2)?, depth + 1)?;
-                Space::Inks { names, alt: Rc::new(alt), tint: arg(3)? }
-            }
-            "Indexed" => {
-                let base = self.space_of(&arg(1)?, depth + 1)?;
-                let hival =
-                    arg(2)?.as_num().filter(|v| (0.0..=MAX_HIVAL as f64).contains(v)).ok_or(PsError::Ps("rangecheck", "Indexed".into()))? as usize;
-                let n = base.n();
-                let table: Vec<f64> = match arg(3)? {
-                    Obj::Str(s) => s.borrow().iter().map(|b| f64::from(*b) / 255.0).collect(),
-                    p @ Obj::Array { .. } => {
-                        let mut t = Vec::with_capacity((hival + 1) * n);
-                        for i in 0..=hival {
-                            self.push(Obj::Int(i as i64))?;
-                            self.call(p.clone())?;
-                            let mut c = vec![0.0; n];
-                            for slot in c.iter_mut().rev() {
-                                *slot = self.pop_num()?;
-                            }
-                            t.extend(c);
-                        }
-                        t
-                    }
-                    _ => return ps_err("typecheck", "Indexed"),
-                };
-                Space::Indexed { base: Rc::new(base), table: Rc::new(table) }
-            }
-            _ => return ps_err("undefined", &family),
-        })
-    }
-
-    fn set_space(&mut self, o: Obj) -> Res {
-        let space = self.space_of(&o, 0)?;
-        let comps = space.initial();
-        self.g.space = Rc::new(space);
-        self.g.space_obj = o;
-        self.set_comps(comps)
-    }
-
-    /// Set the colour to `comps` in the current space.
-    fn set_comps(&mut self, comps: Vec<f64>) -> Res {
-        let space = self.g.space.clone();
-        self.g.mesh = None;
-        self.g.paint = self.paint_of(&space, &comps)?;
-        self.g.comps = comps;
-        Ok(())
-    }
-
-    /// Set a process colour, its space with it.
-    fn set_process(&mut self, space: Space, name: &str, comps: Vec<f64>) -> Res {
-        self.g.space = Rc::new(space);
-        self.g.space_obj = Obj::name(name);
-        self.set_comps(comps)
-    }
-
-    /// The paint of colour `comps` in `space`: a spot ink links to its swatch at the tint.
-    pub fn paint_of(&mut self, space: &Space, comps: &[f64]) -> Res<Paint> {
-        Ok(match space {
-            Space::Inks { names, alt, tint } => {
-                let t = comps.first().copied().unwrap_or(1.0).clamp(0.0, 1.0) as f32;
-                match names.as_slice() {
-                    [one] if &**one == "None" => Paint::None,
-                    [one] if &**one == "All" => {
-                        Paint::Solid { color: Color::cmyk(1.0, 1.0, 1.0, 1.0).tinted(t), swatch: Some(REGISTRATION.into()), tint: t }
-                    }
-                    [one] => {
-                        let full = match self.out.spot_colors.get(one) {
-                            Some(c) => *c,
-                            None => {
-                                let c = self.tint_color(alt, tint, &[1.0])?;
-                                self.out.spots.push((one.to_string(), c));
-                                // The tint transform may have listed this ink already: the color
-                                // listed first stays.
-                                self.out.spot_colors.entry(one.clone()).or_insert(c);
-                                c
-                            }
-                        };
-                        Paint::Solid { color: full.tinted(t), swatch: Some(one.to_string()), tint: t }
-                    }
-                    _ => Paint::solid(self.tint_color(alt, tint, comps)?),
-                }
-            }
-            Space::Indexed { base, table } => {
-                let n = base.n();
-                let i = comps.first().copied().unwrap_or(0.0).round().max(0.0) as usize;
-                let c = table.get(i * n..i * n + n).ok_or(PsError::Ps("rangecheck", "setcolor".into()))?.to_vec();
-                Paint::solid(process(base, &c).unwrap_or(Color::BLACK))
-            }
-            Space::Pattern(_) => Paint::None,
-            s => Paint::solid(process(s, comps).unwrap_or(Color::BLACK)),
-        })
-    }
-
-    /// The alternate colour of inks at `comps`, through the tint transform.
-    pub fn tint_color(&mut self, alt: &Space, tint: &Obj, comps: &[f64]) -> Res<Color> {
-        let base = self.stack.len();
-        for c in comps {
-            self.push_num(*c)?;
-        }
-        self.call(tint.clone())?;
-        let n = alt.n();
-        let at = self.stack.len().checked_sub(n).filter(|a| *a >= base).ok_or(PsError::Ps("stackunderflow", "tint transform".into()))?;
-        let v: Vec<f64> = self.stack.split_off(at).iter().map(|o| o.as_num().unwrap_or(0.0)).collect();
-        self.stack.truncate(base);
-        Ok(process(alt, &v).unwrap_or(Color::BLACK))
-    }
-
-    /// The current colour as grey, RGB or CMYK components (`currentgray` …).
-    fn current_rgb(&self) -> [f32; 3] {
-        self.g.paint.color().map_or([0.0; 3], |c| c.to_rgb_uncalibrated())
-    }
-
-    /// `setcolor` in a pattern space: the pattern operand, and before it an uncoloured
-    /// pattern's colour in the underlying space.
-    fn set_pattern(&mut self, base: Option<Rc<Space>>) -> Res {
-        let Obj::Dict(d) = self.pop()? else { return ps_err("typecheck", "") };
-        let uncoloured = d.borrow().get(&Key::name("PaintType")).and_then(Obj::as_num) == Some(2.0);
-        let under = match base.filter(|_| uncoloured) {
-            Some(base) => {
-                let mut c = vec![0.0; base.n()];
-                for slot in c.iter_mut().rev() {
-                    *slot = self.pop_num()?;
-                }
-                Some(self.paint_of(&base, &c)?)
-            }
-            None => None,
-        };
-        self.g.mesh = None;
-        self.g.paint = self.pattern_paint(&d, under)?;
-        Ok(())
-    }
-
-    /// A pattern colour: a shading pattern's gradient, a tiling pattern's swatch (`under`: the
-    /// colour an uncoloured one paints in).
-    fn pattern_paint(&mut self, d: &DictRef, under: Option<Paint>) -> Res<Paint> {
-        let kind = d.borrow().get(&Key::name("PatternType")).and_then(Obj::as_num);
-        let sh = d.borrow().get(&Key::name("Shading")).cloned();
-        let m = d.borrow().get(&Key::name("VCMatrix")).and_then(|o| o.items().and_then(|i| super::interp::matrix_of(&i.borrow())));
-        // Pattern space → the document.
-        let m = self.out.page * m.unwrap_or(self.g.ctm);
-        match (kind, sh) {
-            (Some(2.0), Some(Obj::Dict(sh))) if is_mesh(&sh) => {
-                self.g.mesh = Some((sh, m));
-                Ok(Paint::None)
-            }
-            (Some(2.0), Some(Obj::Dict(sh))) => Ok(self.gradient(&sh, m)?.map_or(Paint::None, |g| Paint::Gradient(Box::new(g)))),
-            (Some(2.0), _) => ps_err("typecheck", "Shading"),
-            _ => self.tiling(d, under, m),
-        }
-    }
-
-    /// A tiling pattern as a pattern swatch (made the first time): its `PaintProc` drawn in
-    /// pattern space, one cell of `XStep` × `YStep` from the corner of its `BBox`; `m` maps pattern
-    /// space onto the document.
-    fn tiling(&mut self, d: &DictRef, under: Option<Paint>, m: Affine) -> Res<Paint> {
-        let get = |k: &str| d.borrow().get(&Key::name(k)).cloned();
-        let bbox: Vec<f64> = get("BBox").and_then(|o| o.items().map(|i| i.borrow().iter().filter_map(Obj::as_num).collect())).unwrap_or_default();
-        let [x0, y0, x1, y1] = bbox[..] else { return ps_err("rangecheck", "BBox") };
-        let step = |k: &str| get(k).and_then(|o| o.as_num()).map(f64::abs).filter(|v| v.is_finite() && *v > 1e-9 && *v < LIMIT);
-        let (Some(xs), Some(ys)) = (step("XStep"), step("YStep")) else { return ps_err("rangecheck", "XStep") };
-        let tile = Rect::from_origin_size((x0.min(x1), y0.min(y1)), (xs, ys));
-        let xf = m * Affine::translate(tile.origin().to_vec2());
-        let proc = get("PaintProc").ok_or(PsError::Ps("undefined", "PaintProc".into()))?;
-        let key = proc.items().cloned().ok_or(PsError::Ps("typecheck", "PaintProc".into()))?;
-        let hash = tiling_hash(&key, tile, under.as_ref());
-        let made = self.out.tilings.get(&hash).and_then(|list| list.iter().find(|(p, t, u, _)| p.same(&key) && *t == tile && *u == under));
-        if let Some((.., name)) = made {
-            return Ok(Paint::Pattern { pattern: name.clone(), xf });
-        }
-        if self.out.apart >= MAX_APART {
-            self.out.warn(NESTED_PATTERNS);
-            return Ok(Paint::solid(Color::gray(0.5)));
-        }
-        let paint = under.clone();
-        let art = self.draw_apart(Rect::new(x0, y0, x1, y1).abs(), |it| {
-            if let Some(p) = paint {
-                it.g.paint = p;
-            }
-            it.push(Obj::Dict(d.clone()))?;
-            it.call(proc)
-        })?;
-        if art.is_empty() {
-            return Ok(Paint::None);
-        }
-        // The document gets its patterns only here, so the n made so far are Pattern 1 to
-        // Pattern n.
-        let name = format!("Pattern {}", self.out.doc.patterns.len() + 1);
-        let mut def = PatternDef::new(&name, art);
-        def.tile = tile;
-        self.out.doc.patterns.push(def);
-        // A cell with a NaN corner equals no cell, so the lookup above could never find it.
-        if !tile.is_nan() {
-            self.out.tilings.entry(hash).or_insert_with(|| Vec::with_capacity(1)).push((key, tile, under, name.clone()));
-        }
-        Ok(Paint::Pattern { pattern: name, xf })
-    }
-
-    /// The art `draw` draws on its own, in its own space (user space is the document's, the page
-    /// `frame`), from a fresh graphics state with the current font: a pattern's cell, a glyph.
-    pub fn draw_apart(&mut self, frame: Rect, draw: impl FnOnce(&mut Self) -> Res) -> Res<Vec<Arc<Node>>> {
-        let fresh = GState { font: self.g.font.clone(), ..GState::default() };
-        let g = std::mem::replace(&mut self.g, fresh);
-        let saved = std::mem::take(&mut self.saved);
-        let drawn = std::mem::take(&mut self.out.drawn);
-        let page = std::mem::replace(&mut self.out.page, Affine::IDENTITY);
-        let frame = std::mem::replace(&mut self.out.frame, frame);
-        let merge = self.out.merge.take();
-        // The art isn't in the groups open around it.
-        let groups = std::mem::take(&mut self.out.groups);
-        let too_deep = std::mem::take(&mut self.out.too_deep);
-        self.out.apart += 1;
-        let r = draw(self);
-        self.out.apart -= 1;
-        let art = std::mem::replace(&mut self.out.drawn, drawn);
-        (self.out.page, self.out.frame, self.out.merge) = (page, frame, merge);
-        (self.out.groups, self.out.too_deep) = (groups, too_deep);
-        (self.g, self.saved) = (g, saved);
-        r?;
-        let mut nodes = vectorcraft_doc::clipnest::nest(&mut self.out.doc, art);
-        if !self.out.shadings.is_empty() {
-            collapse(&mut nodes, &self.out.shadings);
-        }
-        Ok(nodes)
-    }
-
-    /// An axial or radial shading as a gradient, `m` mapping its space onto the document.
-    fn gradient(&mut self, sh: &DictRef, m: Affine) -> Res<Option<GradientPaint>> {
-        let get = |k: &str| sh.borrow().get(&Key::name(k)).cloned();
-        let kind = get("ShadingType").and_then(|o| o.as_num()).unwrap_or(0.0);
-        if !is_gradient(sh) {
-            self.out.warn(UNKNOWN_SHADINGS);
-            return Ok(None);
-        }
-        let space = self.space_of(&get("ColorSpace").ok_or(PsError::Ps("undefined", "ColorSpace".into()))?, 0)?;
-        let nums = |o: Option<Obj>| -> Vec<f64> {
-            o.and_then(|o| o.items().map(|i| i.borrow().iter().filter_map(Obj::as_num).collect())).unwrap_or_default()
-        };
-        let coords = nums(get("Coords"));
-        let domain = nums(get("Domain"));
-        let (d0, d1) = (domain.first().copied().unwrap_or(0.0), domain.get(1).copied().unwrap_or(1.0));
-        let f = get("Function").ok_or(PsError::Ps("undefined", "Function".into()))?;
-        // Where the colour changes: the ends, and the bounds of stitched linear functions (unless
-        // there are too many).
-        let mut visits = 0;
-        let points = linear_points(&f, 0, &mut visits).filter(|p| p.len() <= MAX_STITCH_STOPS);
-        let stitched = points.is_some();
-        let ts: Vec<f64> = match points {
-            Some(mut pts) => {
-                pts.retain(|t| (d0.min(d1)..=d0.max(d1)).contains(t));
-                pts.iter().map(|t| if d1 != d0 { (t - d0) / (d1 - d0) } else { 0.0 }).chain([0.0, 1.0]).collect()
-            }
-            None => (0..=SHADING_SAMPLES).map(|i| i as f64 / SHADING_SAMPLES as f64).collect(),
-        };
-        let mut ts = ts;
-        ts.sort_by(f64::total_cmp);
-        ts.dedup_by(|a, b| (*a - *b).abs() < 1e-9);
-        let radial = kind == 3.0;
-        let c = |i: usize| coords.get(i).copied().unwrap_or(0.0);
-        let (r0, r1) = (c(2).max(0.0), c(5).max(1e-6));
-        let mut stops = Vec::with_capacity(ts.len());
-        let stop = |paint: Paint, offset: f64| match paint {
-            Paint::Solid { color, swatch, tint } => GradientStop { swatch, tint, ..GradientStop::new(offset as f32, color) },
-            _ => GradientStop::new(offset as f32, Color::BLACK),
-        };
-        for t in ts {
-            let comps = self.eval(&f, &[d0 + (d1 - d0) * t], 0)?;
-            let paint = self.paint_of(&space, &comps)?;
-            let offset = if radial { (r0 + (r1 - r0) * t) / r1 } else { t };
-            // At a bound of a stitched function the pieces need not meet (a hard colour change):
-            // the colour just before the bound is a stop at the same offset, ahead of the one
-            // after it.
-            if stitched && t > 0.0 && t < 1.0 {
-                let comps = self.eval(&f, &[d0 + (d1 - d0) * (t - 1e-9)], 0)?;
-                let before = stop(self.paint_of(&space, &comps)?, offset);
-                if before.color != stop(paint.clone(), offset).color {
-                    stops.push(before);
-                }
-            }
-            stops.push(stop(paint, offset));
-        }
-        let (gk, geom) = if radial {
-            let centre = Point::new(c(3), c(4));
-            let mut geom = GradientGeom { start: centre, end: centre + Vec2::new(r1, 0.0), aspect: 1.0, focal: None };
-            geom.set_focal(Some(Point::new(c(0), c(1))));
-            geom.transform(m, GradientKind::Radial);
-            (GradientKind::Radial, geom)
-        } else {
-            (GradientKind::Linear, GradientGeom { start: m * Point::new(c(0), c(1)), end: m * Point::new(c(2), c(3)), aspect: 1.0, focal: None })
-        };
-        let mut g = GradientPaint::new(Gradient::new(gk, stops));
-        g.geom = Some(geom);
-        Ok(Some(g))
-    }
-
-    /// A function (types 0, 2 and 3; an array of them, one per component) at `x` (types 2 and 3
-    /// take one input).
-    pub fn eval(&mut self, f: &Obj, x: &[f64], depth: u32) -> Res<Vec<f64>> {
-        self.eval_inner(f, x, depth, &mut 0)
-    }
-
-    /// [`Self::eval`], with `visits` (shared by the whole recursion, incremented on every call)
-    /// counting the functions visited against [`MAX_FUNCTION_VISITS`], as [`linear_points`] counts
-    /// its nodes. The depth limit alone stops a function that refers to itself, but not one that
-    /// fans out through shared arrays: when four levels of arrays each have 100 entries that all
-    /// refer to the same array of the level below (at the last level, the same function), one
-    /// evaluation would visit 101,010,101 functions. Each function visited also counts
-    /// [`FUNCTION_OPS`] against the operation budget.
-    fn eval_inner(&mut self, f: &Obj, x: &[f64], depth: u32, visits: &mut usize) -> Res<Vec<f64>> {
-        *visits += 1;
-        if depth > 8 || *visits > MAX_FUNCTION_VISITS {
-            return ps_err("limitcheck", "Function");
-        }
-        self.spend(FUNCTION_OPS)?;
-        let d = match f {
-            Obj::Dict(d) => d.clone(),
-            Obj::Array { items, .. } => {
-                // Each entry is at least one more function: an array with more entries than the
-                // visits left raises `limitcheck` before it is copied.
-                if items.len() > MAX_FUNCTION_VISITS - *visits {
-                    return ps_err("limitcheck", "Function");
-                }
-                let fs = items.to_vec();
-                let mut out = vec![];
-                for g in &fs {
-                    out.extend(self.eval_inner(g, x, depth + 1, visits)?.first().copied());
-                }
-                return Ok(out);
-            }
-            _ => return ps_err("typecheck", "Function"),
-        };
-        let get = |k: &str| d.borrow().get(&Key::name(k)).cloned();
-        let nums = |o: Option<Obj>| -> Vec<f64> {
-            o.and_then(|o| o.items().map(|i| i.borrow().iter().filter_map(Obj::as_num).collect())).unwrap_or_default()
-        };
-        let domain = nums(get("Domain"));
-        let t = x.first().copied().unwrap_or(0.0);
-        let t = match domain.as_slice() {
-            [a, b, ..] => clamp_between(t, *a, *b),
-            _ => t,
-        };
-        match get("FunctionType").and_then(|o| o.as_num()) {
-            Some(0.0) => self.sampled(&d, x),
-            Some(2.0) => {
-                let c0 = nums(get("C0"));
-                let c1 = nums(get("C1"));
-                let (c0, c1) = (if c0.is_empty() { vec![0.0] } else { c0 }, if c1.is_empty() { vec![1.0] } else { c1 });
-                let n = get("N").and_then(|o| o.as_num()).unwrap_or(1.0);
-                let x = t.max(0.0).powf(n);
-                Ok(c0.iter().zip(&c1).map(|(a, b)| a + x * (b - a)).collect())
-            }
-            Some(3.0) => {
-                // Read the pieces through the borrow and clone only the one we recurse into: a
-                // `Functions` array of millions (shared, or reached again through a cycle) must
-                // not be copied on every call and at every live recursion level.
-                let functions = get("Functions");
-                let fs = functions.as_ref().and_then(Obj::items);
-                let n = fs.map_or(0, Shared::len);
-                let bounds = nums(get("Bounds"));
-                let encode = nums(get("Encode"));
-                let (lo, hi) = (domain.first().copied().unwrap_or(0.0), domain.get(1).copied().unwrap_or(1.0));
-                let k = bounds.iter().take_while(|b| t >= **b).count().min(n.saturating_sub(1));
-                let a = if k == 0 { lo } else { bounds.get(k - 1).copied().unwrap_or(lo) };
-                let b = bounds.get(k).copied().unwrap_or(hi);
-                let (e0, e1) = (encode.get(2 * k).copied().unwrap_or(0.0), encode.get(2 * k + 1).copied().unwrap_or(1.0));
-                let u = if b != a { e0 + (t - a) / (b - a) * (e1 - e0) } else { e0 };
-                let g = fs.and_then(|fs| fs.get(k)).ok_or(PsError::Ps("rangecheck", "Functions".into()))?;
-                self.eval_inner(&g, &[u], depth + 1, visits)
-            }
-            _ => {
-                self.out.warn(UNKNOWN_FUNCTIONS);
-                let r = nums(get("Range"));
-                Ok(r.chunks(2).map(|p| p.iter().sum::<f64>() / 2.0).collect())
-            }
-        }
-    }
-
-    // ---------- the operators ----------
-
-    pub fn graphics_op(&mut self, op: Op) -> Res {
-        use Op::*;
-        match op {
-            Gsave => self.gsave()?,
-            Grestore => self.grestore(),
-            GrestoreAll => {
-                if let Some(g) = self.saved.first().cloned() {
-                    self.saved.clear();
-                    self.g = g;
-                }
-            }
-            InitGraphics => {
-                let font = self.g.font.take();
-                self.g = GState { font, null: self.g.null, ..GState::default() };
-            }
-            NullDevice => {
-                self.g.null = true;
-                self.g.ctm = Affine::IDENTITY;
-                self.g.clips.clear();
-            }
-            ExecForm => self.exec_form()?,
-            StrokePath => {
-                let bp = self.take_path();
-                let mut st = self.stroke_layer()?;
-                // A dash pattern far finer than the path would make countless pieces.
-                let period: f64 = st.dash.as_ref().map_or(0.0, |d| d.pattern.iter().sum());
-                let periods = if st.dash.is_some() && period > 0.0 { bp.perimeter(1e-3) / period } else { 0.0 };
-                if st.dash.is_some() && !(period > 0.0 && periods < MAX_DASHES) {
-                    st.dash = None;
-                }
-                let tol = (0.01 / self.scale().max(1e-9)).clamp(1e-4, 1.0);
-                let outline = vectorcraft_effects::stroke::line_outline(&bp, &st, st.width, tol);
-                // The path, each entry of the dash pattern in each period, and the outline count
-                // as elements.
-                let dashes = st.dash.as_ref().map_or(0.0, |d| periods * d.pattern.len() as f64) as usize;
-                self.spend_elements(bp.elements().len().saturating_add(dashes).saturating_add(outline.elements().len()))?;
-                if outline.elements().len() >= MAX_PATH {
-                    return Err(PsError::Limit("a path has too many points"));
-                }
-                self.g.cur = outline.elements().iter().rev().find_map(|e| e.end_point());
-                self.g.start = self.g.cur;
-                self.g.path = outline;
-            }
-            PathForAll => self.path_for_all()?,
-            UFill | UEoFill | UStroke => self.paint_user_path(op)?,
-            UAppend => {
-                let up = self.pop()?;
-                self.user_path(up)?;
-            }
-            UPath => self.upath()?,
-            SetBBox => {
-                self.nums::<4>()?;
-            }
-            CurrentHsbColor => {
-                let [r, g, b] = self.current_rgb();
-                let (max, min) = (r.max(g).max(b), r.min(g).min(b));
-                let d = max - min;
-                let h = if d <= 0.0 {
-                    0.0
-                } else if max == r {
-                    ((g - b) / d).rem_euclid(6.0) / 6.0
-                } else if max == g {
-                    ((b - r) / d + 2.0) / 6.0
-                } else {
-                    ((r - g) / d + 4.0) / 6.0
-                };
-                let s = if max > 0.0 { d / max } else { 0.0 };
-                for v in [h, s, max] {
-                    self.push_num(f64::from(v))?;
-                }
-            }
-            CurrentColorRendering => {
-                let d = super::obj::Dict::from([(Key::name("ColorRenderingType"), Obj::Int(1))]);
-                self.push(Obj::dict(d))?;
-            }
-            FindColorRendering => {
-                self.pop()?;
-                self.push(Obj::name("DefaultColorRendering"))?;
-                self.push(Obj::Bool(false))?;
-            }
-            CurrentColorScreen => {
-                for _ in 0..4 {
-                    self.push(Obj::Real(60.0))?;
-                    self.push(Obj::Real(45.0))?;
-                    self.push(Obj::proc(vec![]))?;
-                }
-            }
-            CurrentSmoothness => self.push(Obj::Real(0.02))?,
-            SetHalftonePhase => {
-                self.nums::<2>()?;
-            }
-            CurrentHalftonePhase => {
-                self.push(Obj::Int(0))?;
-                self.push(Obj::Int(0))?;
-            }
-            GStateNew => {
-                self.spend_elements(self.g.path.elements().len())?;
-                self.alloc(std::mem::size_of_val(self.g.path.elements()))?;
-                self.push(Obj::GState(Rc::new(self.g.clone())))?;
-            }
-            CurrentGState => {
-                self.pop()?;
-                self.spend_elements(self.g.path.elements().len())?;
-                self.alloc(std::mem::size_of_val(self.g.path.elements()))?;
-                self.push(Obj::GState(Rc::new(self.g.clone())))?;
-            }
-            SetGState => match self.pop()? {
-                Obj::GState(g) => {
-                    self.spend_elements(g.path.elements().len())?;
-                    self.g = (*g).clone();
-                }
-                _ => return ps_err("typecheck", ""),
-            },
-            SetLineWidth => self.g.width = self.pop_num()?.abs(),
-            CurrentLineWidth => self.push_num(self.g.width)?,
-            SetLineCap => {
-                self.g.cap = match self.pop_int()? {
-                    1 => LineCap::Round,
-                    2 => LineCap::Square,
-                    _ => LineCap::Butt,
-                }
-            }
-            CurrentLineCap => self.push(Obj::Int(self.g.cap as i64))?,
-            SetLineJoin => {
-                self.g.join = match self.pop_int()? {
-                    1 => LineJoin::Round,
-                    2 => LineJoin::Bevel,
-                    _ => LineJoin::Miter,
-                }
-            }
-            CurrentLineJoin => self.push(Obj::Int(self.g.join as i64))?,
-            SetMiterLimit => self.g.miter = self.pop_num()?,
-            CurrentMiterLimit => self.push_num(self.g.miter)?,
-            SetDash => {
-                let offset = self.pop_num()?;
-                let items = self.pop_array()?;
-                if items.len() > MAX_DASH_ENTRIES {
-                    return ps_err("limitcheck", "");
-                }
-                // Each entry read counts as an operation.
-                self.spend(items.len() as u64)?;
-                let v: Option<Vec<f64>> = items.borrow().iter().map(|o| o.as_num().filter(|v| v.is_finite() && *v >= 0.0)).collect();
-                self.g.dash = v.ok_or(PsError::Ps("typecheck", String::new()))?.into();
-                self.g.dash_offset = offset;
-            }
-            CurrentDash => {
-                // The array made counts against the memory budget.
-                self.alloc(self.g.dash.len() * std::mem::size_of::<Obj>())?;
-                let d = self.g.dash.iter().map(|v| Obj::Real(*v)).collect();
-                self.push(Obj::array(d))?;
-                self.push_num(self.g.dash_offset)?;
-            }
-            SetGray => {
-                let [g] = self.nums()?;
-                self.set_process(Space::Gray, "DeviceGray", vec![g])?;
-            }
-            SetRgbColor => {
-                let c = self.nums::<3>()?;
-                self.set_process(Space::Rgb, "DeviceRGB", c.to_vec())?;
-            }
-            SetHsbColor => {
-                let [h, s, b] = self.nums()?;
-                let [r, g, bl] =
-                    Color::from_hsb((h.rem_euclid(1.0) * 360.0) as f32, s.clamp(0.0, 1.0) as f32, b.clamp(0.0, 1.0) as f32).to_rgb_uncalibrated();
-                self.set_process(Space::Rgb, "DeviceRGB", vec![f64::from(r), f64::from(g), f64::from(bl)])?;
-            }
-            SetCmykColor => {
-                let c = self.nums::<4>()?;
-                self.set_process(Space::Cmyk, "DeviceCMYK", c.to_vec())?;
-            }
-            CurrentGray => {
-                let [r, g, b] = self.current_rgb();
-                self.push_num(f64::from(0.3 * r + 0.59 * g + 0.11 * b))?;
-            }
-            CurrentRgbColor => {
-                for v in self.current_rgb() {
-                    self.push_num(f64::from(v))?;
-                }
-            }
-            CurrentCmykColor => {
-                let c = self.g.paint.color().map_or([0.0, 0.0, 0.0, 1.0], |c| c.to_cmyk());
-                for v in c {
-                    self.push_num(f64::from(v))?;
-                }
-            }
-            SetColorSpace => {
-                let o = self.pop()?;
-                self.set_space(o)?;
-            }
-            CurrentColorSpace => {
-                let o = match &self.g.space_obj {
-                    o @ Obj::Array { .. } => o.clone(),
-                    o => Obj::array(vec![o.clone()]),
-                };
-                self.push(o)?;
-            }
-            SetColor => {
-                if let Space::Pattern(base) = &*self.g.space {
-                    self.set_pattern(base.clone())?;
-                } else {
-                    let n = self.g.space.n();
-                    let mut c = vec![0.0; n];
-                    for slot in c.iter_mut().rev() {
-                        *slot = self.pop_num()?;
-                    }
-                    self.set_comps(c)?;
-                }
-            }
-            CurrentColor => {
-                for v in self.g.comps.clone() {
-                    self.push_num(v)?;
-                }
-            }
-            // `[/Pattern <current space>] setcolorspace setcolor`, unless in a pattern space already.
-            SetPattern => {
-                if !matches!(*self.g.space, Space::Pattern(_)) {
-                    self.g.space = Rc::new(Space::Pattern(Some(self.g.space.clone())));
-                    self.g.space_obj = Obj::array(vec![Obj::name("Pattern"), self.g.space_obj.clone()]);
-                }
-                let Space::Pattern(base) = &*self.g.space else { return ps_err("typecheck", "") };
-                self.set_pattern(base.clone())?;
-            }
-            MakePattern => {
-                let m = self.pop_matrix()?;
-                let d = self.pop_dict()?;
-                let mut copy = d.borrow().clone();
-                copy.insert(Key::name("VCMatrix"), matrix_obj(self.g.ctm * m));
-                self.push(Obj::dict(copy))?;
-            }
-            SetOverprint => self.g.overprint = self.pop_bool()?,
-            CurrentOverprint => self.push(Obj::Bool(self.g.overprint))?,
-            SetFlat | SetHalftone | SetTransfer | SetBlackGeneration | SetUnderColorRemoval | SetColorRendering | SetSmoothness | SetStrokeAdjust
-            | SetPageDevice | SetUserParams | SetSystemParams => {
-                self.pop()?;
-            }
-            SetScreen => {
-                for _ in 0..3 {
-                    self.pop()?;
-                }
-            }
-            SetColorTransfer => {
-                for _ in 0..4 {
-                    self.pop()?;
-                }
-            }
-            SetColorScreen => {
-                for _ in 0..12 {
-                    self.pop()?;
-                }
-            }
-            SetCacheLimit => {
-                self.pop()?;
-            }
-            SetUCacheParams => {
-                let at = self.stack.iter().rposition(|o| matches!(o, Obj::Mark)).ok_or(PsError::Ps("unmatchedmark", String::new()))?;
-                self.stack.truncate(at);
-            }
-            UCache => {}
-            CurrentScreen => {
-                self.push(Obj::Real(60.0))?;
-                self.push(Obj::Real(45.0))?;
-                self.push(Obj::proc(vec![]))?;
-            }
-            CurrentTransfer | CurrentBlackGeneration | CurrentUnderColorRemoval => self.push(Obj::proc(vec![]))?,
-            CurrentColorTransfer => {
-                for _ in 0..4 {
-                    self.push(Obj::proc(vec![]))?;
-                }
-            }
-            CurrentHalftone => {
-                let mut d = super::obj::Dict::new();
-                d.insert(Key::name("HalftoneType"), Obj::Int(1));
-                d.insert(Key::name("Frequency"), Obj::Real(60.0));
-                d.insert(Key::name("Angle"), Obj::Real(45.0));
-                d.insert(Key::name("SpotFunction"), Obj::proc(vec![]));
-                self.push(Obj::dict(d))?;
-            }
-            FindEncoding => {
-                self.pop()?;
-                self.push(Obj::array(vec![Obj::name(".notdef"); 256]))?;
-            }
-            CurrentFlat => self.push(Obj::Real(1.0))?,
-            CurrentStrokeAdjust => self.push(Obj::Bool(false))?,
-            CurrentPageDevice => {
-                let mut d = super::obj::Dict::new();
-                let f = self.out.frame;
-                d.insert(Key::name("PageSize"), Obj::array(vec![Obj::Real(f.width()), Obj::Real(f.height())]));
-                self.push(Obj::dict(d))?;
-            }
-            // The cache and stack sizes programs read (they `get` them without asking first).
-            CurrentUserParams | CurrentSystemParams => {
-                let keys: &[&str] = if op == CurrentUserParams {
-                    &["MaxFontItem", "MaxFormItem", "MaxPatternItem", "MaxUPathItem", "MaxOpStack", "MaxDictStack", "MaxExecStack"]
-                } else {
-                    &["MaxFontCache", "MaxFormCache", "MaxPatternCache", "MaxUPathCache", "MaxScreenStorage", "MaxDisplayList"]
-                };
-                let d: super::obj::Dict = keys.iter().map(|k| (Key::name(k), Obj::Int(1 << 20))).collect();
-                self.push(Obj::dict(d))?;
-            }
-            ShowPage => return Err(PsError::Quit),
-            CopyPage | ErasePage => {}
-            Matrix => self.push(matrix_obj(Affine::IDENTITY))?,
-            IdentMatrix | DefaultMatrix => {
-                let items = self.pop_array()?;
-                self.put_matrix(items, Affine::IDENTITY)?;
-            }
-            CurrentMatrix => {
-                let items = self.pop_array()?;
-                self.put_matrix(items, self.g.ctm)?;
-            }
-            SetMatrix => self.g.ctm = self.pop_matrix()?,
-            InitMatrix => self.g.ctm = Affine::IDENTITY,
-            Concat => {
-                let m = self.pop_matrix()?;
-                self.g.ctm *= m;
-            }
-            ConcatMatrix => {
-                let out = self.pop_array()?;
-                let (m2, m1) = (self.pop_matrix()?, self.pop_matrix()?);
-                self.put_matrix(out, m2 * m1)?;
-            }
-            Translate | Scale | Rotate => {
-                let into = match self.stack.last() {
-                    Some(Obj::Array { .. }) => Some(self.pop_array()?),
-                    _ => None,
-                };
-                let m = match op {
-                    Rotate => Affine::rotate(self.pop_num()?.to_radians()),
-                    Translate => {
-                        let [x, y] = self.nums()?;
-                        Affine::translate((x, y))
-                    }
-                    _ => {
-                        let [x, y] = self.nums()?;
-                        Affine::scale_non_uniform(x, y)
-                    }
-                };
-                match into {
-                    Some(items) => self.put_matrix(items, m)?,
-                    None => self.g.ctm *= m,
-                }
-            }
-            Transform | ITransform | DTransform | IDTransform => {
-                let m = match self.stack.last() {
-                    Some(Obj::Array { .. }) => self.pop_matrix()?,
-                    _ => self.g.ctm,
-                };
-                let [x, y] = self.nums()?;
-                let inverse = matches!(op, ITransform | IDTransform);
-                if inverse && m.determinant().abs() < 1e-12 {
-                    return ps_err("undefinedresult", "");
-                }
-                let m = if inverse { m.inverse() } else { m };
-                let p = if matches!(op, DTransform | IDTransform) {
-                    let v = m * Point::new(x, y) - m * Point::ZERO;
-                    Point::new(v.x, v.y)
-                } else {
-                    m * Point::new(x, y)
-                };
-                self.push_num(p.x)?;
-                self.push_num(p.y)?;
-            }
-            InvertMatrix => {
-                let out = self.pop_array()?;
-                let m = self.pop_matrix()?;
-                if m.determinant().abs() < 1e-12 {
-                    return ps_err("undefinedresult", "");
-                }
-                self.put_matrix(out, m.inverse())?;
-            }
-            NewPath => {
-                self.take_path();
-            }
-            CurrentPoint => {
-                let p = self.user_point()?;
-                self.push_num(p.x)?;
-                self.push_num(p.y)?;
-            }
-            MoveTo => {
-                let [x, y] = self.nums()?;
-                let p = self.xf() * Point::new(x, y);
-                self.move_to(p)?;
-            }
-            RMoveTo => {
-                let [dx, dy] = self.nums()?;
-                let p = self.user_point()? + Vec2::new(dx, dy);
-                let p = self.xf() * p;
-                self.move_to(p)?;
-            }
-            LineTo => {
-                let [x, y] = self.nums()?;
-                self.line_to(self.xf() * Point::new(x, y))?;
-            }
-            RLineTo => {
-                let [dx, dy] = self.nums()?;
-                let p = self.user_point()? + Vec2::new(dx, dy);
-                self.line_to(self.xf() * p)?;
-            }
-            CurveTo | RCurveTo => {
-                let v = self.nums::<6>()?;
-                let o = if op == RCurveTo { self.user_point()?.to_vec2() } else { Vec2::ZERO };
-                if self.g.cur.is_none() {
-                    return ps_err("nocurrentpoint", "");
-                }
-                let xf = self.xf();
-                let [a, b, p] = [0, 2, 4].map(|i| xf * (Point::new(v[i], v[i + 1]) + o));
-                self.grow()?;
-                self.g.path.curve_to(a, b, p);
-                self.g.cur = Some(p);
-            }
-            Arc | Arcn => {
-                let [x, y, r, a1, a2] = self.nums()?;
-                self.arc(Point::new(x, y), r, a1, a2, op == Arc)?;
-            }
-            Arct | Arcto => {
-                let [x1, y1, x2, y2, r] = self.nums()?;
-                let [t1, t2] = self.arct(Point::new(x1, y1), Point::new(x2, y2), r)?;
-                if op == Arcto {
-                    for v in [t1.x, t1.y, t2.x, t2.y] {
-                        self.push_num(v)?;
-                    }
-                }
-            }
-            ClosePath => {
-                if self.g.cur.is_some() {
-                    self.grow()?;
-                    self.g.path.close_path();
-                    self.g.cur = self.g.start;
-                }
-            }
-            FlattenPath | ReversePath => {}
-            PathBBox => {
-                if self.g.path.elements().is_empty() {
-                    return ps_err("nocurrentpoint", "");
-                }
-                let xf = self.xf();
-                if xf.determinant().abs() < 1e-12 {
-                    return ps_err("undefinedresult", "");
-                }
-                self.spend_elements(self.g.path.elements().len())?;
-                let b = xf.inverse().transform_rect_bbox(self.g.path.bounding_box());
-                for v in [b.x0, b.y0, b.x1, b.y1] {
-                    self.push_num(v)?;
-                }
-            }
-            ClipPath => {
-                let b = self.clip_bounds()?;
-                self.take_path();
-                self.g.path = b.to_path(0.1);
-                self.g.cur = Some(b.origin());
-                self.g.start = self.g.cur;
-            }
-            InitClip => self.g.clips.clear(),
-            ClipSave => {
-                if self.g.saved_clips.len() >= MAX_GSAVE {
-                    return Err(PsError::Limit("too many saved clips"));
-                }
-                self.alloc(std::mem::size_of_val(self.g.clips.as_slice()))?;
-                let clips = self.g.clips.as_slice().into();
-                self.g.saved_clips.push(clips);
-            }
-            ClipRestore => {
-                if let Some(clips) = self.g.saved_clips.pop() {
-                    self.g.clips = clips.to_vec();
-                }
-            }
-            Clip | EoClip => {
-                self.spend_elements(self.g.path.elements().len())?;
-                let bp = self.g.path.clone();
-                self.clip_with(bp, if op == EoClip { FillRule::EvenOdd } else { FillRule::NonZero });
-            }
-            RectClip => {
-                let bp = self.rects()?;
-                self.take_path();
-                self.clip_with(bp, FillRule::NonZero);
-            }
-            Fill | EoFill => {
-                let bp = self.take_path();
-                self.fill_path(bp, if op == EoFill { FillRule::EvenOdd } else { FillRule::NonZero })?;
-            }
-            Stroke => {
-                let bp = self.take_path();
-                self.stroke_path(bp)?;
-            }
-            RectFill => {
-                let bp = self.rects()?;
-                self.fill_path(bp, FillRule::NonZero)?;
-            }
-            RectStroke => {
-                let m = match self.stack.last() {
-                    Some(Obj::Array { items, .. }) if items.len() == 6 => Some(self.pop_matrix()?),
-                    _ => None,
-                };
-                let mut bp = self.rects()?;
-                if let Some(m) = m {
-                    let xf = self.xf();
-                    bp.apply_affine(xf * m * xf.inverse());
-                }
-                self.stroke_path(bp)?;
-            }
-            ShFill => {
-                let d = self.pop_dict()?;
-                if self.g.null {
-                    return Ok(());
-                }
-                if is_mesh(&d) {
-                    let m = self.xf();
-                    return self.mesh_fill(&d, m);
-                }
-                let m = self.xf();
-                if let Some(g) = self.gradient(&d, m)? {
-                    let area = self.clip_bounds()?;
-                    let paint = Paint::Gradient(Box::new(g));
-                    let clips = self.g.clips.clone();
-                    self.out.fill(area.to_path(0.1), FillRule::NonZero, paint, self.g.overprint, &clips);
-                    if let Some((_, n)) = self.out.drawn.last() {
-                        let id = n.id;
-                        self.out.shadings.insert(id);
-                    }
-                }
-            }
-            _ => self.data_op(op)?,
-        }
-        Ok(())
-    }
-}
-
-/// Is shading `sh` axial or radial (a gradient)?
-fn is_gradient(sh: &DictRef) -> bool {
-    matches!(sh.borrow().get(&Key::name("ShadingType")).and_then(Obj::as_num), Some(2.0 | 3.0))
-}
-
-/// Is shading `sh` one [`Interp::mesh_fill`] paints?
-fn is_mesh(sh: &DictRef) -> bool {
-    matches!(sh.borrow().get(&Key::name("ShadingType")).and_then(Obj::as_num), Some(1.0 | 4.0 | 5.0 | 6.0 | 7.0))
-}
-
-/// Where a stitched function of linear interpolations changes slope (its bounds), when it is
-/// one; `None` for functions that must be sampled. `depth` bounds the nesting the same way
-/// [`Interp::eval`] does (`> 8`) and `visits` (shared by the whole recursion, incremented on
-/// every call) bounds the total nodes looked at. Both are needed: the depth limit alone stops a
-/// function that refers to itself in a cycle, but not one that fans out through shared children
-/// (1025 references to a child a few levels deep is 1025^levels nodes without the visit cap). A
-/// well-formed stitch of linear pieces is one level, at most `MAX_STITCH_STOPS + 1` pieces, so it
-/// costs at most `MAX_STITCH_STOPS + 2` visits and is never cut off.
-fn linear_points(f: &Obj, depth: u32, visits: &mut usize) -> Option<Vec<f64>> {
-    *visits += 1;
-    if depth > 8 || *visits > 2 * (MAX_STITCH_STOPS + 1) {
-        return None;
-    }
-    let Obj::Dict(d) = f else { return None };
-    let d = d.borrow();
-    let num = |k: &str| d.get(&Key::name(k)).and_then(Obj::as_num);
-    match num("FunctionType")? {
-        2.0 if num("N").unwrap_or(1.0) == 1.0 => Some(vec![]),
-        3.0 => {
-            let items = d.get(&Key::name("Functions"))?.items()?;
-            // More pieces than the stop cap allows: sample the function instead (tested before
-            // `to_vec`, so a huge `Functions` array is not copied only to be rejected). Each stop
-            // runs [`Interp::eval`], which reads one piece, so a short `Bounds` with a huge
-            // `Functions` would still be O(stops * Functions) to find each piece without this.
-            if items.len() > MAX_STITCH_STOPS + 1 {
-                return None;
-            }
-            let fs = items.to_vec();
-            if !fs.iter().all(|g| linear_points(g, depth + 1, visits).is_some_and(|p| p.is_empty())) {
-                return None;
-            }
-            d.get(&Key::name("Bounds"))?.items().map(|i| i.borrow().iter().filter_map(Obj::as_num).collect())
-        }
-        _ => None,
-    }
-}
-
-/// The clip path a clipping group of one shading rectangle (`shfill` through a clip) can be
-/// filled with instead.
-pub(crate) fn collapse(nodes: &mut [Arc<Node>], shadings: &HashSet<NodeId>) {
-    for n in nodes.iter_mut() {
-        let NodeKind::Group { children, clip: true } = &n.kind else {
-            if let Some(c) = Arc::make_mut(n).children_mut() {
-                collapse(c, shadings);
-            }
-            continue;
-        };
-        if let [clip, fill] = children.as_slice()
-            && shadings.contains(&fill.id)
-            && let (NodeKind::Path { path, rule, clipping: true, .. }, NodeKind::Path { .. }) = (&clip.kind, &fill.kind)
-        {
-            let mut p = Node::path(fill.id, path.clone(), (*fill.appearance).clone());
-            if let NodeKind::Path { rule: r, .. } = &mut p.kind {
-                *r = *rule;
-            }
-            *n = Arc::new(p);
-            continue;
-        }
-        if let Some(c) = Arc::make_mut(n).children_mut() {
-            collapse(c, shadings);
-        }
-    }
-}
diff --git a/crates/eps/src/import/graphics/ops.rs b/crates/eps/src/import/graphics/ops.rs
new file mode 100644
index 000000000..608a62413
--- /dev/null
+++ b/crates/eps/src/import/graphics/ops.rs
@@ -0,0 +1,533 @@
+use super::paint::is_mesh;
+use super::state::{GState, Space};
+use super::*;
+
+impl Interp<'_> {
+    // ---------- the operators ----------
+
+    pub fn graphics_op(&mut self, op: Op) -> Res {
+        use Op::*;
+        match op {
+            Gsave => self.gsave()?,
+            Grestore => self.grestore(),
+            GrestoreAll => {
+                if let Some(g) = self.saved.first().cloned() {
+                    self.saved.clear();
+                    self.g = g;
+                }
+            }
+            InitGraphics => {
+                let font = self.g.font.take();
+                self.g = GState { font, null: self.g.null, ..GState::default() };
+            }
+            NullDevice => {
+                self.g.null = true;
+                self.g.ctm = Affine::IDENTITY;
+                self.g.clips.clear();
+            }
+            ExecForm => self.exec_form()?,
+            StrokePath => {
+                let bp = self.take_path();
+                let mut st = self.stroke_layer()?;
+                // A dash pattern far finer than the path would make countless pieces.
+                let period: f64 = st.dash.as_ref().map_or(0.0, |d| d.pattern.iter().sum());
+                let periods = if st.dash.is_some() && period > 0.0 { bp.perimeter(1e-3) / period } else { 0.0 };
+                if st.dash.is_some() && !(period > 0.0 && periods < MAX_DASHES) {
+                    st.dash = None;
+                }
+                let tol = (0.01 / self.scale().max(1e-9)).clamp(1e-4, 1.0);
+                let outline = vectorcraft_effects::stroke::line_outline(&bp, &st, st.width, tol);
+                // The path, each entry of the dash pattern in each period, and the outline count
+                // as elements.
+                let dashes = st.dash.as_ref().map_or(0.0, |d| periods * d.pattern.len() as f64) as usize;
+                self.spend_elements(bp.elements().len().saturating_add(dashes).saturating_add(outline.elements().len()))?;
+                if outline.elements().len() >= MAX_PATH {
+                    return Err(PsError::Limit("a path has too many points"));
+                }
+                self.g.cur = outline.elements().iter().rev().find_map(|e| e.end_point());
+                self.g.start = self.g.cur;
+                self.g.path = outline;
+            }
+            PathForAll => self.path_for_all()?,
+            UFill | UEoFill | UStroke => self.paint_user_path(op)?,
+            UAppend => {
+                let up = self.pop()?;
+                self.user_path(up)?;
+            }
+            UPath => self.upath()?,
+            SetBBox => {
+                self.nums::<4>()?;
+            }
+            CurrentHsbColor => {
+                let [r, g, b] = self.current_rgb();
+                let (max, min) = (r.max(g).max(b), r.min(g).min(b));
+                let d = max - min;
+                let h = if d <= 0.0 {
+                    0.0
+                } else if max == r {
+                    ((g - b) / d).rem_euclid(6.0) / 6.0
+                } else if max == g {
+                    ((b - r) / d + 2.0) / 6.0
+                } else {
+                    ((r - g) / d + 4.0) / 6.0
+                };
+                let s = if max > 0.0 { d / max } else { 0.0 };
+                for v in [h, s, max] {
+                    self.push_num(f64::from(v))?;
+                }
+            }
+            CurrentColorRendering => {
+                let d = crate::import::obj::Dict::from([(Key::name("ColorRenderingType"), Obj::Int(1))]);
+                self.push(Obj::dict(d))?;
+            }
+            FindColorRendering => {
+                self.pop()?;
+                self.push(Obj::name("DefaultColorRendering"))?;
+                self.push(Obj::Bool(false))?;
+            }
+            CurrentColorScreen => {
+                for _ in 0..4 {
+                    self.push(Obj::Real(60.0))?;
+                    self.push(Obj::Real(45.0))?;
+                    self.push(Obj::proc(vec![]))?;
+                }
+            }
+            CurrentSmoothness => self.push(Obj::Real(0.02))?,
+            SetHalftonePhase => {
+                self.nums::<2>()?;
+            }
+            CurrentHalftonePhase => {
+                self.push(Obj::Int(0))?;
+                self.push(Obj::Int(0))?;
+            }
+            GStateNew => {
+                self.spend_elements(self.g.path.elements().len())?;
+                self.alloc(std::mem::size_of_val(self.g.path.elements()))?;
+                self.push(Obj::GState(Rc::new(self.g.clone())))?;
+            }
+            CurrentGState => {
+                self.pop()?;
+                self.spend_elements(self.g.path.elements().len())?;
+                self.alloc(std::mem::size_of_val(self.g.path.elements()))?;
+                self.push(Obj::GState(Rc::new(self.g.clone())))?;
+            }
+            SetGState => match self.pop()? {
+                Obj::GState(g) => {
+                    self.spend_elements(g.path.elements().len())?;
+                    self.g = (*g).clone();
+                }
+                _ => return ps_err("typecheck", ""),
+            },
+            SetLineWidth => self.g.width = self.pop_num()?.abs(),
+            CurrentLineWidth => self.push_num(self.g.width)?,
+            SetLineCap => {
+                self.g.cap = match self.pop_int()? {
+                    1 => LineCap::Round,
+                    2 => LineCap::Square,
+                    _ => LineCap::Butt,
+                }
+            }
+            CurrentLineCap => self.push(Obj::Int(self.g.cap as i64))?,
+            SetLineJoin => {
+                self.g.join = match self.pop_int()? {
+                    1 => LineJoin::Round,
+                    2 => LineJoin::Bevel,
+                    _ => LineJoin::Miter,
+                }
+            }
+            CurrentLineJoin => self.push(Obj::Int(self.g.join as i64))?,
+            SetMiterLimit => self.g.miter = self.pop_num()?,
+            CurrentMiterLimit => self.push_num(self.g.miter)?,
+            SetDash => {
+                let offset = self.pop_num()?;
+                let items = self.pop_array()?;
+                if items.len() > MAX_DASH_ENTRIES {
+                    return ps_err("limitcheck", "");
+                }
+                // Each entry read counts as an operation.
+                self.spend(items.len() as u64)?;
+                let v: Option<Vec<f64>> = items.borrow().iter().map(|o| o.as_num().filter(|v| v.is_finite() && *v >= 0.0)).collect();
+                self.g.dash = v.ok_or(PsError::Ps("typecheck", String::new()))?.into();
+                self.g.dash_offset = offset;
+            }
+            CurrentDash => {
+                // The array made counts against the memory budget.
+                self.alloc(self.g.dash.len() * std::mem::size_of::<Obj>())?;
+                let d = self.g.dash.iter().map(|v| Obj::Real(*v)).collect();
+                self.push(Obj::array(d))?;
+                self.push_num(self.g.dash_offset)?;
+            }
+            SetGray => {
+                let [g] = self.nums()?;
+                self.set_process(Space::Gray, "DeviceGray", vec![g])?;
+            }
+            SetRgbColor => {
+                let c = self.nums::<3>()?;
+                self.set_process(Space::Rgb, "DeviceRGB", c.to_vec())?;
+            }
+            SetHsbColor => {
+                let [h, s, b] = self.nums()?;
+                let [r, g, bl] =
+                    Color::from_hsb((h.rem_euclid(1.0) * 360.0) as f32, s.clamp(0.0, 1.0) as f32, b.clamp(0.0, 1.0) as f32).to_rgb_uncalibrated();
+                self.set_process(Space::Rgb, "DeviceRGB", vec![f64::from(r), f64::from(g), f64::from(bl)])?;
+            }
+            SetCmykColor => {
+                let c = self.nums::<4>()?;
+                self.set_process(Space::Cmyk, "DeviceCMYK", c.to_vec())?;
+            }
+            CurrentGray => {
+                let [r, g, b] = self.current_rgb();
+                self.push_num(f64::from(0.3 * r + 0.59 * g + 0.11 * b))?;
+            }
+            CurrentRgbColor => {
+                for v in self.current_rgb() {
+                    self.push_num(f64::from(v))?;
+                }
+            }
+            CurrentCmykColor => {
+                let c = self.g.paint.color().map_or([0.0, 0.0, 0.0, 1.0], |c| c.to_cmyk());
+                for v in c {
+                    self.push_num(f64::from(v))?;
+                }
+            }
+            SetColorSpace => {
+                let o = self.pop()?;
+                self.set_space(o)?;
+            }
+            CurrentColorSpace => {
+                let o = match &self.g.space_obj {
+                    o @ Obj::Array { .. } => o.clone(),
+                    o => Obj::array(vec![o.clone()]),
+                };
+                self.push(o)?;
+            }
+            SetColor => {
+                if let Space::Pattern(base) = &*self.g.space {
+                    self.set_pattern(base.clone())?;
+                } else {
+                    let n = self.g.space.n();
+                    let mut c = vec![0.0; n];
+                    for slot in c.iter_mut().rev() {
+                        *slot = self.pop_num()?;
+                    }
+                    self.set_comps(c)?;
+                }
+            }
+            CurrentColor => {
+                for v in self.g.comps.clone() {
+                    self.push_num(v)?;
+                }
+            }
+            // `[/Pattern <current space>] setcolorspace setcolor`, unless in a pattern space already.
+            SetPattern => {
+                if !matches!(*self.g.space, Space::Pattern(_)) {
+                    self.g.space = Rc::new(Space::Pattern(Some(self.g.space.clone())));
+                    self.g.space_obj = Obj::array(vec![Obj::name("Pattern"), self.g.space_obj.clone()]);
+                }
+                let Space::Pattern(base) = &*self.g.space else { return ps_err("typecheck", "") };
+                self.set_pattern(base.clone())?;
+            }
+            MakePattern => {
+                let m = self.pop_matrix()?;
+                let d = self.pop_dict()?;
+                let mut copy = d.borrow().clone();
+                copy.insert(Key::name("VCMatrix"), matrix_obj(self.g.ctm * m));
+                self.push(Obj::dict(copy))?;
+            }
+            SetOverprint => self.g.overprint = self.pop_bool()?,
+            CurrentOverprint => self.push(Obj::Bool(self.g.overprint))?,
+            SetFlat | SetHalftone | SetTransfer | SetBlackGeneration | SetUnderColorRemoval | SetColorRendering | SetSmoothness | SetStrokeAdjust
+            | SetPageDevice | SetUserParams | SetSystemParams => {
+                self.pop()?;
+            }
+            SetScreen => {
+                for _ in 0..3 {
+                    self.pop()?;
+                }
+            }
+            SetColorTransfer => {
+                for _ in 0..4 {
+                    self.pop()?;
+                }
+            }
+            SetColorScreen => {
+                for _ in 0..12 {
+                    self.pop()?;
+                }
+            }
+            SetCacheLimit => {
+                self.pop()?;
+            }
+            SetUCacheParams => {
+                let at = self.stack.iter().rposition(|o| matches!(o, Obj::Mark)).ok_or(PsError::Ps("unmatchedmark", String::new()))?;
+                self.stack.truncate(at);
+            }
+            UCache => {}
+            CurrentScreen => {
+                self.push(Obj::Real(60.0))?;
+                self.push(Obj::Real(45.0))?;
+                self.push(Obj::proc(vec![]))?;
+            }
+            CurrentTransfer | CurrentBlackGeneration | CurrentUnderColorRemoval => self.push(Obj::proc(vec![]))?,
+            CurrentColorTransfer => {
+                for _ in 0..4 {
+                    self.push(Obj::proc(vec![]))?;
+                }
+            }
+            CurrentHalftone => {
+                let mut d = crate::import::obj::Dict::new();
+                d.insert(Key::name("HalftoneType"), Obj::Int(1));
+                d.insert(Key::name("Frequency"), Obj::Real(60.0));
+                d.insert(Key::name("Angle"), Obj::Real(45.0));
+                d.insert(Key::name("SpotFunction"), Obj::proc(vec![]));
+                self.push(Obj::dict(d))?;
+            }
+            FindEncoding => {
+                self.pop()?;
+                self.push(Obj::array(vec![Obj::name(".notdef"); 256]))?;
+            }
+            CurrentFlat => self.push(Obj::Real(1.0))?,
+            CurrentStrokeAdjust => self.push(Obj::Bool(false))?,
+            CurrentPageDevice => {
+                let mut d = crate::import::obj::Dict::new();
+                let f = self.out.frame;
+                d.insert(Key::name("PageSize"), Obj::array(vec![Obj::Real(f.width()), Obj::Real(f.height())]));
+                self.push(Obj::dict(d))?;
+            }
+            // The cache and stack sizes programs read (they `get` them without asking first).
+            CurrentUserParams | CurrentSystemParams => {
+                let keys: &[&str] = if op == CurrentUserParams {
+                    &["MaxFontItem", "MaxFormItem", "MaxPatternItem", "MaxUPathItem", "MaxOpStack", "MaxDictStack", "MaxExecStack"]
+                } else {
+                    &["MaxFontCache", "MaxFormCache", "MaxPatternCache", "MaxUPathCache", "MaxScreenStorage", "MaxDisplayList"]
+                };
+                let d: crate::import::obj::Dict = keys.iter().map(|k| (Key::name(k), Obj::Int(1 << 20))).collect();
+                self.push(Obj::dict(d))?;
+            }
+            ShowPage => return Err(PsError::Quit),
+            CopyPage | ErasePage => {}
+            Matrix => self.push(matrix_obj(Affine::IDENTITY))?,
+            IdentMatrix | DefaultMatrix => {
+                let items = self.pop_array()?;
+                self.put_matrix(items, Affine::IDENTITY)?;
+            }
+            CurrentMatrix => {
+                let items = self.pop_array()?;
+                self.put_matrix(items, self.g.ctm)?;
+            }
+            SetMatrix => self.g.ctm = self.pop_matrix()?,
+            InitMatrix => self.g.ctm = Affine::IDENTITY,
+            Concat => {
+                let m = self.pop_matrix()?;
+                self.g.ctm *= m;
+            }
+            ConcatMatrix => {
+                let out = self.pop_array()?;
+                let (m2, m1) = (self.pop_matrix()?, self.pop_matrix()?);
+                self.put_matrix(out, m2 * m1)?;
+            }
+            Translate | Scale | Rotate => {
+                let into = match self.stack.last() {
+                    Some(Obj::Array { .. }) => Some(self.pop_array()?),
+                    _ => None,
+                };
+                let m = match op {
+                    Rotate => Affine::rotate(self.pop_num()?.to_radians()),
+                    Translate => {
+                        let [x, y] = self.nums()?;
+                        Affine::translate((x, y))
+                    }
+                    _ => {
+                        let [x, y] = self.nums()?;
+                        Affine::scale_non_uniform(x, y)
+                    }
+                };
+                match into {
+                    Some(items) => self.put_matrix(items, m)?,
+                    None => self.g.ctm *= m,
+                }
+            }
+            Transform | ITransform | DTransform | IDTransform => {
+                let m = match self.stack.last() {
+                    Some(Obj::Array { .. }) => self.pop_matrix()?,
+                    _ => self.g.ctm,
+                };
+                let [x, y] = self.nums()?;
+                let inverse = matches!(op, ITransform | IDTransform);
+                if inverse && m.determinant().abs() < 1e-12 {
+                    return ps_err("undefinedresult", "");
+                }
+                let m = if inverse { m.inverse() } else { m };
+                let p = if matches!(op, DTransform | IDTransform) {
+                    let v = m * Point::new(x, y) - m * Point::ZERO;
+                    Point::new(v.x, v.y)
+                } else {
+                    m * Point::new(x, y)
+                };
+                self.push_num(p.x)?;
+                self.push_num(p.y)?;
+            }
+            InvertMatrix => {
+                let out = self.pop_array()?;
+                let m = self.pop_matrix()?;
+                if m.determinant().abs() < 1e-12 {
+                    return ps_err("undefinedresult", "");
+                }
+                self.put_matrix(out, m.inverse())?;
+            }
+            NewPath => {
+                self.take_path();
+            }
+            CurrentPoint => {
+                let p = self.user_point()?;
+                self.push_num(p.x)?;
+                self.push_num(p.y)?;
+            }
+            MoveTo => {
+                let [x, y] = self.nums()?;
+                let p = self.xf() * Point::new(x, y);
+                self.move_to(p)?;
+            }
+            RMoveTo => {
+                let [dx, dy] = self.nums()?;
+                let p = self.user_point()? + Vec2::new(dx, dy);
+                let p = self.xf() * p;
+                self.move_to(p)?;
+            }
+            LineTo => {
+                let [x, y] = self.nums()?;
+                self.line_to(self.xf() * Point::new(x, y))?;
+            }
+            RLineTo => {
+                let [dx, dy] = self.nums()?;
+                let p = self.user_point()? + Vec2::new(dx, dy);
+                self.line_to(self.xf() * p)?;
+            }
+            CurveTo | RCurveTo => {
+                let v = self.nums::<6>()?;
+                let o = if op == RCurveTo { self.user_point()?.to_vec2() } else { Vec2::ZERO };
+                if self.g.cur.is_none() {
+                    return ps_err("nocurrentpoint", "");
+                }
+                let xf = self.xf();
+                let [a, b, p] = [0, 2, 4].map(|i| xf * (Point::new(v[i], v[i + 1]) + o));
+                self.grow()?;
+                self.g.path.curve_to(a, b, p);
+                self.g.cur = Some(p);
+            }
+            Arc | Arcn => {
+                let [x, y, r, a1, a2] = self.nums()?;
+                self.arc(Point::new(x, y), r, a1, a2, op == Arc)?;
+            }
+            Arct | Arcto => {
+                let [x1, y1, x2, y2, r] = self.nums()?;
+                let [t1, t2] = self.arct(Point::new(x1, y1), Point::new(x2, y2), r)?;
+                if op == Arcto {
+                    for v in [t1.x, t1.y, t2.x, t2.y] {
+                        self.push_num(v)?;
+                    }
+                }
+            }
+            ClosePath => {
+                if self.g.cur.is_some() {
+                    self.grow()?;
+                    self.g.path.close_path();
+                    self.g.cur = self.g.start;
+                }
+            }
+            FlattenPath | ReversePath => {}
+            PathBBox => {
+                if self.g.path.elements().is_empty() {
+                    return ps_err("nocurrentpoint", "");
+                }
+                let xf = self.xf();
+                if xf.determinant().abs() < 1e-12 {
+                    return ps_err("undefinedresult", "");
+                }
+                self.spend_elements(self.g.path.elements().len())?;
+                let b = xf.inverse().transform_rect_bbox(self.g.path.bounding_box());
+                for v in [b.x0, b.y0, b.x1, b.y1] {
+                    self.push_num(v)?;
+                }
+            }
+            ClipPath => {
+                let b = self.clip_bounds()?;
+                self.take_path();
+                self.g.path = b.to_path(0.1);
+                self.g.cur = Some(b.origin());
+                self.g.start = self.g.cur;
+            }
+            InitClip => self.g.clips.clear(),
+            ClipSave => {
+                if self.g.saved_clips.len() >= MAX_GSAVE {
+                    return Err(PsError::Limit("too many saved clips"));
+                }
+                self.alloc(std::mem::size_of_val(self.g.clips.as_slice()))?;
+                let clips = self.g.clips.as_slice().into();
+                self.g.saved_clips.push(clips);
+            }
+            ClipRestore => {
+                if let Some(clips) = self.g.saved_clips.pop() {
+                    self.g.clips = clips.to_vec();
+                }
+            }
+            Clip | EoClip => {
+                self.spend_elements(self.g.path.elements().len())?;
+                let bp = self.g.path.clone();
+                self.clip_with(bp, if op == EoClip { FillRule::EvenOdd } else { FillRule::NonZero });
+            }
+            RectClip => {
+                let bp = self.rects()?;
+                self.take_path();
+                self.clip_with(bp, FillRule::NonZero);
+            }
+            Fill | EoFill => {
+                let bp = self.take_path();
+                self.fill_path(bp, if op == EoFill { FillRule::EvenOdd } else { FillRule::NonZero })?;
+            }
+            Stroke => {
+                let bp = self.take_path();
+                self.stroke_path(bp)?;
+            }
+            RectFill => {
+                let bp = self.rects()?;
+                self.fill_path(bp, FillRule::NonZero)?;
+            }
+            RectStroke => {
+                let m = match self.stack.last() {
+                    Some(Obj::Array { items, .. }) if items.len() == 6 => Some(self.pop_matrix()?),
+                    _ => None,
+                };
+                let mut bp = self.rects()?;
+                if let Some(m) = m {
+                    let xf = self.xf();
+                    bp.apply_affine(xf * m * xf.inverse());
+                }
+                self.stroke_path(bp)?;
+            }
+            ShFill => {
+                let d = self.pop_dict()?;
+                if self.g.null {
+                    return Ok(());
+                }
+                if is_mesh(&d) {
+                    let m = self.xf();
+                    return self.mesh_fill(&d, m);
+                }
+                let m = self.xf();
+                if let Some(g) = self.gradient(&d, m)? {
+                    let area = self.clip_bounds()?;
+                    let paint = Paint::Gradient(Box::new(g));
+                    let clips = self.g.clips.clone();
+                    self.out.fill(area.to_path(0.1), FillRule::NonZero, paint, self.g.overprint, &clips);
+                    if let Some((_, n)) = self.out.drawn.last() {
+                        let id = n.id;
+                        self.out.shadings.insert(id);
+                    }
+                }
+            }
+            _ => self.data_op(op)?,
+        }
+        Ok(())
+    }
+}
diff --git a/crates/eps/src/import/graphics/paint.rs b/crates/eps/src/import/graphics/paint.rs
new file mode 100644
index 000000000..f2e343858
--- /dev/null
+++ b/crates/eps/src/import/graphics/paint.rs
@@ -0,0 +1,495 @@
+use super::state::{GState, Space, process, tiling_hash};
+use super::*;
+
+impl Interp<'_> {
+    // ---------- colour ----------
+
+    /// A colour space operand.
+    pub(in super::super) fn space_of(&mut self, o: &Obj, depth: u32) -> Res<Space> {
+        if depth > 4 {
+            return ps_err("limitcheck", "setcolorspace");
+        }
+        let (family, items) = match o {
+            Obj::Name(n) | Obj::Exec(n) => (n.clone(), vec![]),
+            Obj::Array { items, .. } => {
+                let v = items.to_vec();
+                let n = v.first().and_then(Obj::text).ok_or(PsError::Ps("typecheck", "setcolorspace".into()))?;
+                (n, v)
+            }
+            _ => return ps_err("typecheck", "setcolorspace"),
+        };
+        let arg = |i: usize| items.get(i).cloned().ok_or(PsError::Ps("rangecheck", "setcolorspace".into()));
+        Ok(match &*family {
+            "DeviceGray" | "CIEBasedA" | "CalGray" => Space::Gray,
+            "DeviceRGB" | "CIEBasedABC" | "CalRGB" | "Lab" | "CIEBasedDEF" => Space::Rgb,
+            "DeviceCMYK" | "CIEBasedDEFG" => Space::Cmyk,
+            "Pattern" => Space::Pattern(match items.get(1) {
+                Some(base) => Some(Rc::new(self.space_of(base, depth + 1)?)),
+                None => None,
+            }),
+            "ICCBased" => match arg(1)? {
+                Obj::Dict(d) => match d.borrow().get(&Key::name("N")).and_then(Obj::as_num) {
+                    Some(1.0) => Space::Gray,
+                    Some(4.0) => Space::Cmyk,
+                    _ => Space::Rgb,
+                },
+                _ => Space::Rgb,
+            },
+            "Separation" | "DeviceN" => {
+                let names: Vec<Rc<str>> = match arg(1)? {
+                    Obj::Array { items, .. } => items.borrow().iter().filter_map(Obj::text).collect(),
+                    o => o.text().into_iter().collect(),
+                };
+                if names.len() > MAX_INKS {
+                    return ps_err("limitcheck", "DeviceN");
+                }
+                let alt = self.space_of(&arg(2)?, depth + 1)?;
+                Space::Inks { names, alt: Rc::new(alt), tint: arg(3)? }
+            }
+            "Indexed" => {
+                let base = self.space_of(&arg(1)?, depth + 1)?;
+                let hival =
+                    arg(2)?.as_num().filter(|v| (0.0..=MAX_HIVAL as f64).contains(v)).ok_or(PsError::Ps("rangecheck", "Indexed".into()))? as usize;
+                let n = base.n();
+                let table: Vec<f64> = match arg(3)? {
+                    Obj::Str(s) => s.borrow().iter().map(|b| f64::from(*b) / 255.0).collect(),
+                    p @ Obj::Array { .. } => {
+                        let mut t = Vec::with_capacity((hival + 1) * n);
+                        for i in 0..=hival {
+                            self.push(Obj::Int(i as i64))?;
+                            self.call(p.clone())?;
+                            let mut c = vec![0.0; n];
+                            for slot in c.iter_mut().rev() {
+                                *slot = self.pop_num()?;
+                            }
+                            t.extend(c);
+                        }
+                        t
+                    }
+                    _ => return ps_err("typecheck", "Indexed"),
+                };
+                Space::Indexed { base: Rc::new(base), table: Rc::new(table) }
+            }
+            _ => return ps_err("undefined", &family),
+        })
+    }
+
+    pub(super) fn set_space(&mut self, o: Obj) -> Res {
+        let space = self.space_of(&o, 0)?;
+        let comps = space.initial();
+        self.g.space = Rc::new(space);
+        self.g.space_obj = o;
+        self.set_comps(comps)
+    }
+
+    /// Set the colour to `comps` in the current space.
+    pub(super) fn set_comps(&mut self, comps: Vec<f64>) -> Res {
+        let space = self.g.space.clone();
+        self.g.mesh = None;
+        self.g.paint = self.paint_of(&space, &comps)?;
+        self.g.comps = comps;
+        Ok(())
+    }
+
+    /// Set a process colour, its space with it.
+    pub(super) fn set_process(&mut self, space: Space, name: &str, comps: Vec<f64>) -> Res {
+        self.g.space = Rc::new(space);
+        self.g.space_obj = Obj::name(name);
+        self.set_comps(comps)
+    }
+
+    /// The paint of colour `comps` in `space`: a spot ink links to its swatch at the tint.
+    pub fn paint_of(&mut self, space: &Space, comps: &[f64]) -> Res<Paint> {
+        Ok(match space {
+            Space::Inks { names, alt, tint } => {
+                let t = comps.first().copied().unwrap_or(1.0).clamp(0.0, 1.0) as f32;
+                match names.as_slice() {
+                    [one] if &**one == "None" => Paint::None,
+                    [one] if &**one == "All" => {
+                        Paint::Solid { color: Color::cmyk(1.0, 1.0, 1.0, 1.0).tinted(t), swatch: Some(REGISTRATION.into()), tint: t }
+                    }
+                    [one] => {
+                        let full = match self.out.spot_colors.get(one) {
+                            Some(c) => *c,
+                            None => {
+                                let c = self.tint_color(alt, tint, &[1.0])?;
+                                self.out.spots.push((one.to_string(), c));
+                                // The tint transform may have listed this ink already: the color
+                                // listed first stays.
+                                self.out.spot_colors.entry(one.clone()).or_insert(c);
+                                c
+                            }
+                        };
+                        Paint::Solid { color: full.tinted(t), swatch: Some(one.to_string()), tint: t }
+                    }
+                    _ => Paint::solid(self.tint_color(alt, tint, comps)?),
+                }
+            }
+            Space::Indexed { base, table } => {
+                let n = base.n();
+                let i = comps.first().copied().unwrap_or(0.0).round().max(0.0) as usize;
+                let c = table.get(i * n..i * n + n).ok_or(PsError::Ps("rangecheck", "setcolor".into()))?.to_vec();
+                Paint::solid(process(base, &c).unwrap_or(Color::BLACK))
+            }
+            Space::Pattern(_) => Paint::None,
+            s => Paint::solid(process(s, comps).unwrap_or(Color::BLACK)),
+        })
+    }
+
+    /// The alternate colour of inks at `comps`, through the tint transform.
+    pub fn tint_color(&mut self, alt: &Space, tint: &Obj, comps: &[f64]) -> Res<Color> {
+        let base = self.stack.len();
+        for c in comps {
+            self.push_num(*c)?;
+        }
+        self.call(tint.clone())?;
+        let n = alt.n();
+        let at = self.stack.len().checked_sub(n).filter(|a| *a >= base).ok_or(PsError::Ps("stackunderflow", "tint transform".into()))?;
+        let v: Vec<f64> = self.stack.split_off(at).iter().map(|o| o.as_num().unwrap_or(0.0)).collect();
+        self.stack.truncate(base);
+        Ok(process(alt, &v).unwrap_or(Color::BLACK))
+    }
+
+    /// The current colour as grey, RGB or CMYK components (`currentgray` …).
+    pub(super) fn current_rgb(&self) -> [f32; 3] {
+        self.g.paint.color().map_or([0.0; 3], |c| c.to_rgb_uncalibrated())
+    }
+
+    /// `setcolor` in a pattern space: the pattern operand, and before it an uncoloured
+    /// pattern's colour in the underlying space.
+    pub(super) fn set_pattern(&mut self, base: Option<Rc<Space>>) -> Res {
+        let Obj::Dict(d) = self.pop()? else { return ps_err("typecheck", "") };
+        let uncoloured = d.borrow().get(&Key::name("PaintType")).and_then(Obj::as_num) == Some(2.0);
+        let under = match base.filter(|_| uncoloured) {
+            Some(base) => {
+                let mut c = vec![0.0; base.n()];
+                for slot in c.iter_mut().rev() {
+                    *slot = self.pop_num()?;
+                }
+                Some(self.paint_of(&base, &c)?)
+            }
+            None => None,
+        };
+        self.g.mesh = None;
+        self.g.paint = self.pattern_paint(&d, under)?;
+        Ok(())
+    }
+
+    /// A pattern colour: a shading pattern's gradient, a tiling pattern's swatch (`under`: the
+    /// colour an uncoloured one paints in).
+    fn pattern_paint(&mut self, d: &DictRef, under: Option<Paint>) -> Res<Paint> {
+        let kind = d.borrow().get(&Key::name("PatternType")).and_then(Obj::as_num);
+        let sh = d.borrow().get(&Key::name("Shading")).cloned();
+        let m = d.borrow().get(&Key::name("VCMatrix")).and_then(|o| o.items().and_then(|i| crate::import::interp::matrix_of(&i.borrow())));
+        // Pattern space → the document.
+        let m = self.out.page * m.unwrap_or(self.g.ctm);
+        match (kind, sh) {
+            (Some(2.0), Some(Obj::Dict(sh))) if is_mesh(&sh) => {
+                self.g.mesh = Some((sh, m));
+                Ok(Paint::None)
+            }
+            (Some(2.0), Some(Obj::Dict(sh))) => Ok(self.gradient(&sh, m)?.map_or(Paint::None, |g| Paint::Gradient(Box::new(g)))),
+            (Some(2.0), _) => ps_err("typecheck", "Shading"),
+            _ => self.tiling(d, under, m),
+        }
+    }
+
+    /// A tiling pattern as a pattern swatch (made the first time): its `PaintProc` drawn in
+    /// pattern space, one cell of `XStep` × `YStep` from the corner of its `BBox`; `m` maps pattern
+    /// space onto the document.
+    fn tiling(&mut self, d: &DictRef, under: Option<Paint>, m: Affine) -> Res<Paint> {
+        let get = |k: &str| d.borrow().get(&Key::name(k)).cloned();
+        let bbox: Vec<f64> = get("BBox").and_then(|o| o.items().map(|i| i.borrow().iter().filter_map(Obj::as_num).collect())).unwrap_or_default();
+        let [x0, y0, x1, y1] = bbox[..] else { return ps_err("rangecheck", "BBox") };
+        let step = |k: &str| get(k).and_then(|o| o.as_num()).map(f64::abs).filter(|v| v.is_finite() && *v > 1e-9 && *v < LIMIT);
+        let (Some(xs), Some(ys)) = (step("XStep"), step("YStep")) else { return ps_err("rangecheck", "XStep") };
+        let tile = Rect::from_origin_size((x0.min(x1), y0.min(y1)), (xs, ys));
+        let xf = m * Affine::translate(tile.origin().to_vec2());
+        let proc = get("PaintProc").ok_or(PsError::Ps("undefined", "PaintProc".into()))?;
+        let key = proc.items().cloned().ok_or(PsError::Ps("typecheck", "PaintProc".into()))?;
+        let hash = tiling_hash(&key, tile, under.as_ref());
+        let made = self.out.tilings.get(&hash).and_then(|list| list.iter().find(|(p, t, u, _)| p.same(&key) && *t == tile && *u == under));
+        if let Some((.., name)) = made {
+            return Ok(Paint::Pattern { pattern: name.clone(), xf });
+        }
+        if self.out.apart >= MAX_APART {
+            self.out.warn(NESTED_PATTERNS);
+            return Ok(Paint::solid(Color::gray(0.5)));
+        }
+        let paint = under.clone();
+        let art = self.draw_apart(Rect::new(x0, y0, x1, y1).abs(), |it| {
+            if let Some(p) = paint {
+                it.g.paint = p;
+            }
+            it.push(Obj::Dict(d.clone()))?;
+            it.call(proc)
+        })?;
+        if art.is_empty() {
+            return Ok(Paint::None);
+        }
+        // The document gets its patterns only here, so the n made so far are Pattern 1 to
+        // Pattern n.
+        let name = format!("Pattern {}", self.out.doc.patterns.len() + 1);
+        let mut def = PatternDef::new(&name, art);
+        def.tile = tile;
+        self.out.doc.patterns.push(def);
+        // A cell with a NaN corner equals no cell, so the lookup above could never find it.
+        if !tile.is_nan() {
+            self.out.tilings.entry(hash).or_insert_with(|| Vec::with_capacity(1)).push((key, tile, under, name.clone()));
+        }
+        Ok(Paint::Pattern { pattern: name, xf })
+    }
+
+    /// The art `draw` draws on its own, in its own space (user space is the document's, the page
+    /// `frame`), from a fresh graphics state with the current font: a pattern's cell, a glyph.
+    pub fn draw_apart(&mut self, frame: Rect, draw: impl FnOnce(&mut Self) -> Res) -> Res<Vec<Arc<Node>>> {
+        let fresh = GState { font: self.g.font.clone(), ..GState::default() };
+        let g = std::mem::replace(&mut self.g, fresh);
+        let saved = std::mem::take(&mut self.saved);
+        let drawn = std::mem::take(&mut self.out.drawn);
+        let page = std::mem::replace(&mut self.out.page, Affine::IDENTITY);
+        let frame = std::mem::replace(&mut self.out.frame, frame);
+        let merge = self.out.merge.take();
+        // The art isn't in the groups open around it.
+        let groups = std::mem::take(&mut self.out.groups);
+        let too_deep = std::mem::take(&mut self.out.too_deep);
+        self.out.apart += 1;
+        let r = draw(self);
+        self.out.apart -= 1;
+        let art = std::mem::replace(&mut self.out.drawn, drawn);
+        (self.out.page, self.out.frame, self.out.merge) = (page, frame, merge);
+        (self.out.groups, self.out.too_deep) = (groups, too_deep);
+        (self.g, self.saved) = (g, saved);
+        r?;
+        let mut nodes = vectorcraft_doc::clipnest::nest(&mut self.out.doc, art);
+        if !self.out.shadings.is_empty() {
+            collapse(&mut nodes, &self.out.shadings);
+        }
+        Ok(nodes)
+    }
+
+    /// An axial or radial shading as a gradient, `m` mapping its space onto the document.
+    pub(super) fn gradient(&mut self, sh: &DictRef, m: Affine) -> Res<Option<GradientPaint>> {
+        let get = |k: &str| sh.borrow().get(&Key::name(k)).cloned();
+        let kind = get("ShadingType").and_then(|o| o.as_num()).unwrap_or(0.0);
+        if !is_gradient(sh) {
+            self.out.warn(UNKNOWN_SHADINGS);
+            return Ok(None);
+        }
+        let space = self.space_of(&get("ColorSpace").ok_or(PsError::Ps("undefined", "ColorSpace".into()))?, 0)?;
+        let nums = |o: Option<Obj>| -> Vec<f64> {
+            o.and_then(|o| o.items().map(|i| i.borrow().iter().filter_map(Obj::as_num).collect())).unwrap_or_default()
+        };
+        let coords = nums(get("Coords"));
+        let domain = nums(get("Domain"));
+        let (d0, d1) = (domain.first().copied().unwrap_or(0.0), domain.get(1).copied().unwrap_or(1.0));
+        let f = get("Function").ok_or(PsError::Ps("undefined", "Function".into()))?;
+        // Where the colour changes: the ends, and the bounds of stitched linear functions (unless
+        // there are too many).
+        let mut visits = 0;
+        let points = linear_points(&f, 0, &mut visits).filter(|p| p.len() <= MAX_STITCH_STOPS);
+        let stitched = points.is_some();
+        let ts: Vec<f64> = match points {
+            Some(mut pts) => {
+                pts.retain(|t| (d0.min(d1)..=d0.max(d1)).contains(t));
+                pts.iter().map(|t| if d1 != d0 { (t - d0) / (d1 - d0) } else { 0.0 }).chain([0.0, 1.0]).collect()
+            }
+            None => (0..=SHADING_SAMPLES).map(|i| i as f64 / SHADING_SAMPLES as f64).collect(),
+        };
+        let mut ts = ts;
+        ts.sort_by(f64::total_cmp);
+        ts.dedup_by(|a, b| (*a - *b).abs() < 1e-9);
+        let radial = kind == 3.0;
+        let c = |i: usize| coords.get(i).copied().unwrap_or(0.0);
+        let (r0, r1) = (c(2).max(0.0), c(5).max(1e-6));
+        let mut stops = Vec::with_capacity(ts.len());
+        let stop = |paint: Paint, offset: f64| match paint {
+            Paint::Solid { color, swatch, tint } => GradientStop { swatch, tint, ..GradientStop::new(offset as f32, color) },
+            _ => GradientStop::new(offset as f32, Color::BLACK),
+        };
+        for t in ts {
+            let comps = self.eval(&f, &[d0 + (d1 - d0) * t], 0)?;
+            let paint = self.paint_of(&space, &comps)?;
+            let offset = if radial { (r0 + (r1 - r0) * t) / r1 } else { t };
+            // At a bound of a stitched function the pieces need not meet (a hard colour change):
+            // the colour just before the bound is a stop at the same offset, ahead of the one
+            // after it.
+            if stitched && t > 0.0 && t < 1.0 {
+                let comps = self.eval(&f, &[d0 + (d1 - d0) * (t - 1e-9)], 0)?;
+                let before = stop(self.paint_of(&space, &comps)?, offset);
+                if before.color != stop(paint.clone(), offset).color {
+                    stops.push(before);
+                }
+            }
+            stops.push(stop(paint, offset));
+        }
+        let (gk, geom) = if radial {
+            let centre = Point::new(c(3), c(4));
+            let mut geom = GradientGeom { start: centre, end: centre + Vec2::new(r1, 0.0), aspect: 1.0, focal: None };
+            geom.set_focal(Some(Point::new(c(0), c(1))));
+            geom.transform(m, GradientKind::Radial);
+            (GradientKind::Radial, geom)
+        } else {
+            (GradientKind::Linear, GradientGeom { start: m * Point::new(c(0), c(1)), end: m * Point::new(c(2), c(3)), aspect: 1.0, focal: None })
+        };
+        let mut g = GradientPaint::new(Gradient::new(gk, stops));
+        g.geom = Some(geom);
+        Ok(Some(g))
+    }
+
+    /// A function (types 0, 2 and 3; an array of them, one per component) at `x` (types 2 and 3
+    /// take one input).
+    pub fn eval(&mut self, f: &Obj, x: &[f64], depth: u32) -> Res<Vec<f64>> {
+        self.eval_inner(f, x, depth, &mut 0)
+    }
+
+    /// [`Self::eval`], with `visits` (shared by the whole recursion, incremented on every call)
+    /// counting the functions visited against [`MAX_FUNCTION_VISITS`], as [`linear_points`] counts
+    /// its nodes. The depth limit alone stops a function that refers to itself, but not one that
+    /// fans out through shared arrays: when four levels of arrays each have 100 entries that all
+    /// refer to the same array of the level below (at the last level, the same function), one
+    /// evaluation would visit 101,010,101 functions. Each function visited also counts
+    /// [`FUNCTION_OPS`] against the operation budget.
+    fn eval_inner(&mut self, f: &Obj, x: &[f64], depth: u32, visits: &mut usize) -> Res<Vec<f64>> {
+        *visits += 1;
+        if depth > 8 || *visits > MAX_FUNCTION_VISITS {
+            return ps_err("limitcheck", "Function");
+        }
+        self.spend(FUNCTION_OPS)?;
+        let d = match f {
+            Obj::Dict(d) => d.clone(),
+            Obj::Array { items, .. } => {
+                // Each entry is at least one more function: an array with more entries than the
+                // visits left raises `limitcheck` before it is copied.
+                if items.len() > MAX_FUNCTION_VISITS - *visits {
+                    return ps_err("limitcheck", "Function");
+                }
+                let fs = items.to_vec();
+                let mut out = vec![];
+                for g in &fs {
+                    out.extend(self.eval_inner(g, x, depth + 1, visits)?.first().copied());
+                }
+                return Ok(out);
+            }
+            _ => return ps_err("typecheck", "Function"),
+        };
+        let get = |k: &str| d.borrow().get(&Key::name(k)).cloned();
+        let nums = |o: Option<Obj>| -> Vec<f64> {
+            o.and_then(|o| o.items().map(|i| i.borrow().iter().filter_map(Obj::as_num).collect())).unwrap_or_default()
+        };
+        let domain = nums(get("Domain"));
+        let t = x.first().copied().unwrap_or(0.0);
+        let t = match domain.as_slice() {
+            [a, b, ..] => clamp_between(t, *a, *b),
+            _ => t,
+        };
+        match get("FunctionType").and_then(|o| o.as_num()) {
+            Some(0.0) => self.sampled(&d, x),
+            Some(2.0) => {
+                let c0 = nums(get("C0"));
+                let c1 = nums(get("C1"));
+                let (c0, c1) = (if c0.is_empty() { vec![0.0] } else { c0 }, if c1.is_empty() { vec![1.0] } else { c1 });
+                let n = get("N").and_then(|o| o.as_num()).unwrap_or(1.0);
+                let x = t.max(0.0).powf(n);
+                Ok(c0.iter().zip(&c1).map(|(a, b)| a + x * (b - a)).collect())
+            }
+            Some(3.0) => {
+                // Read the pieces through the borrow and clone only the one we recurse into: a
+                // `Functions` array of millions (shared, or reached again through a cycle) must
+                // not be copied on every call and at every live recursion level.
+                let functions = get("Functions");
+                let fs = functions.as_ref().and_then(Obj::items);
+                let n = fs.map_or(0, Shared::len);
+                let bounds = nums(get("Bounds"));
+                let encode = nums(get("Encode"));
+                let (lo, hi) = (domain.first().copied().unwrap_or(0.0), domain.get(1).copied().unwrap_or(1.0));
+                let k = bounds.iter().take_while(|b| t >= **b).count().min(n.saturating_sub(1));
+                let a = if k == 0 { lo } else { bounds.get(k - 1).copied().unwrap_or(lo) };
+                let b = bounds.get(k).copied().unwrap_or(hi);
+                let (e0, e1) = (encode.get(2 * k).copied().unwrap_or(0.0), encode.get(2 * k + 1).copied().unwrap_or(1.0));
+                let u = if b != a { e0 + (t - a) / (b - a) * (e1 - e0) } else { e0 };
+                let g = fs.and_then(|fs| fs.get(k)).ok_or(PsError::Ps("rangecheck", "Functions".into()))?;
+                self.eval_inner(&g, &[u], depth + 1, visits)
+            }
+            _ => {
+                self.out.warn(UNKNOWN_FUNCTIONS);
+                let r = nums(get("Range"));
+                Ok(r.chunks(2).map(|p| p.iter().sum::<f64>() / 2.0).collect())
+            }
+        }
+    }
+}
+
+/// Is shading `sh` axial or radial (a gradient)?
+fn is_gradient(sh: &DictRef) -> bool {
+    matches!(sh.borrow().get(&Key::name("ShadingType")).and_then(Obj::as_num), Some(2.0 | 3.0))
+}
+
+/// Is shading `sh` one [`Interp::mesh_fill`] paints?
+pub(super) fn is_mesh(sh: &DictRef) -> bool {
+    matches!(sh.borrow().get(&Key::name("ShadingType")).and_then(Obj::as_num), Some(1.0 | 4.0 | 5.0 | 6.0 | 7.0))
+}
+
+/// Where a stitched function of linear interpolations changes slope (its bounds), when it is
+/// one; `None` for functions that must be sampled. `depth` bounds the nesting the same way
+/// [`Interp::eval`] does (`> 8`) and `visits` (shared by the whole recursion, incremented on
+/// every call) bounds the total nodes looked at. Both are needed: the depth limit alone stops a
+/// function that refers to itself in a cycle, but not one that fans out through shared children
+/// (1025 references to a child a few levels deep is 1025^levels nodes without the visit cap). A
+/// well-formed stitch of linear pieces is one level, at most `MAX_STITCH_STOPS + 1` pieces, so it
+/// costs at most `MAX_STITCH_STOPS + 2` visits and is never cut off.
+fn linear_points(f: &Obj, depth: u32, visits: &mut usize) -> Option<Vec<f64>> {
+    *visits += 1;
+    if depth > 8 || *visits > 2 * (MAX_STITCH_STOPS + 1) {
+        return None;
+    }
+    let Obj::Dict(d) = f else { return None };
+    let d = d.borrow();
+    let num = |k: &str| d.get(&Key::name(k)).and_then(Obj::as_num);
+    match num("FunctionType")? {
+        2.0 if num("N").unwrap_or(1.0) == 1.0 => Some(vec![]),
+        3.0 => {
+            let items = d.get(&Key::name("Functions"))?.items()?;
+            // More pieces than the stop cap allows: sample the function instead (tested before
+            // `to_vec`, so a huge `Functions` array is not copied only to be rejected). Each stop
+            // runs [`Interp::eval`], which reads one piece, so a short `Bounds` with a huge
+            // `Functions` would still be O(stops * Functions) to find each piece without this.
+            if items.len() > MAX_STITCH_STOPS + 1 {
+                return None;
+            }
+            let fs = items.to_vec();
+            if !fs.iter().all(|g| linear_points(g, depth + 1, visits).is_some_and(|p| p.is_empty())) {
+                return None;
+            }
+            d.get(&Key::name("Bounds"))?.items().map(|i| i.borrow().iter().filter_map(Obj::as_num).collect())
+        }
+        _ => None,
+    }
+}
+
+/// The clip path a clipping group of one shading rectangle (`shfill` through a clip) can be
+/// filled with instead.
+pub(crate) fn collapse(nodes: &mut [Arc<Node>], shadings: &HashSet<NodeId>) {
+    for n in nodes.iter_mut() {
+        let NodeKind::Group { children, clip: true } = &n.kind else {
+            if let Some(c) = Arc::make_mut(n).children_mut() {
+                collapse(c, shadings);
+            }
+            continue;
+        };
+        if let [clip, fill] = children.as_slice()
+            && shadings.contains(&fill.id)
+            && let (NodeKind::Path { path, rule, clipping: true, .. }, NodeKind::Path { .. }) = (&clip.kind, &fill.kind)
+        {
+            let mut p = Node::path(fill.id, path.clone(), (*fill.appearance).clone());
+            if let NodeKind::Path { rule: r, .. } = &mut p.kind {
+                *r = *rule;
+            }
+            *n = Arc::new(p);
+            continue;
+        }
+        if let Some(c) = Arc::make_mut(n).children_mut() {
+            collapse(c, shadings);
+        }
+    }
+}
diff --git a/crates/eps/src/import/graphics/path.rs b/crates/eps/src/import/graphics/path.rs
new file mode 100644
index 000000000..3403e9add
--- /dev/null
+++ b/crates/eps/src/import/graphics/path.rs
@@ -0,0 +1,428 @@
+use super::state::{ccw_turn, turn};
+use super::*;
+
+impl Interp<'_> {
+    /// User space → document space.
+    pub fn xf(&self) -> Affine {
+        self.out.page * self.g.ctm
+    }
+
+    /// How much user-space lengths grow in the document.
+    pub fn scale(&self) -> f64 {
+        let s = self.xf().determinant().abs().sqrt();
+        if s.is_finite() { s } else { 0.0 }
+    }
+
+    /// The current point in user space.
+    pub fn user_point(&self) -> Res<Point> {
+        let p = self.g.cur.ok_or(PsError::Ps("nocurrentpoint", String::new()))?;
+        let inv = self.xf();
+        if inv.determinant().abs() < 1e-12 {
+            return ps_err("undefinedresult", "");
+        }
+        Ok(inv.inverse() * p)
+    }
+
+    pub fn gsave(&mut self) -> Res {
+        if self.saved.len() >= MAX_GSAVE {
+            return Err(PsError::Limit("too many saved graphics states"));
+        }
+        self.alloc(std::mem::size_of_val(self.g.path.elements()))?;
+        self.saved.push(self.g.clone());
+        Ok(())
+    }
+
+    pub fn grestore(&mut self) {
+        if let Some(g) = self.saved.pop() {
+            self.g = g;
+        }
+    }
+
+    // ---------- paths ----------
+
+    /// Room for one more element in the current path.
+    pub fn grow(&self) -> Res {
+        if self.g.path.elements().len() >= MAX_PATH {
+            return Err(PsError::Limit("a path has too many points"));
+        }
+        Ok(())
+    }
+
+    /// Count `n` path elements an operator makes, reads or copies against the operation budget,
+    /// an operation each: making or reading an element takes up to about as long as an operation,
+    /// and copying one takes less (measured).
+    pub(super) fn spend_elements(&mut self, n: usize) -> Res {
+        self.spend(n as u64)
+    }
+
+    pub(super) fn move_to(&mut self, p: Point) -> Res {
+        self.grow()?;
+        // Consecutive movetos: the last one counts.
+        if let Some(PathEl::MoveTo(_)) = self.g.path.elements().last() {
+            self.g.path.pop();
+        }
+        self.g.path.move_to(p);
+        self.g.cur = Some(p);
+        self.g.start = Some(p);
+        Ok(())
+    }
+
+    pub(super) fn line_to(&mut self, p: Point) -> Res {
+        self.grow()?;
+        if self.g.cur.is_none() {
+            return ps_err("nocurrentpoint", "");
+        }
+        self.g.path.line_to(p);
+        self.g.cur = Some(p);
+        Ok(())
+    }
+
+    /// Path elements in user space appended (the first move a line when there is a current point),
+    /// each counted against the operation budget.
+    fn append_user(&mut self, els: impl Iterator<Item = PathEl>) -> Res {
+        let xf = self.xf();
+        for el in els {
+            self.spend_elements(1)?;
+            match el {
+                PathEl::MoveTo(p) => {
+                    let p = xf * p;
+                    if self.g.cur.is_some() { self.line_to(p)? } else { self.move_to(p)? }
+                }
+                PathEl::LineTo(p) => self.line_to(xf * p)?,
+                PathEl::QuadTo(a, p) => {
+                    self.grow()?;
+                    self.g.path.quad_to(xf * a, xf * p);
+                    self.g.cur = Some(xf * p);
+                }
+                PathEl::CurveTo(a, b, p) => {
+                    self.grow()?;
+                    self.g.path.curve_to(xf * a, xf * b, xf * p);
+                    self.g.cur = Some(xf * p);
+                }
+                PathEl::ClosePath => {
+                    self.grow()?;
+                    self.g.path.close_path();
+                }
+            }
+        }
+        Ok(())
+    }
+
+    /// `arc` / `arcn`: from angle `a1` to `a2` (degrees, counter-clockwise or clockwise).
+    pub(super) fn arc(&mut self, c: Point, r: f64, a1: f64, a2: f64, ccw: bool) -> Res {
+        // `arc` raises `a2` by multiples of 360 until it is at least `a1`, and `arcn` lowers it
+        // until it is at most `a1` (PLRM 3rd ed., `arc` and `arcn` in chapter 8). Those sweeps,
+        // and the first endpoint, are worked out from what is left of each angle after whole turns.
+        let sweep = if ccw && a2 < a1 {
+            ccw_turn(a1, a2)
+        } else if !ccw && a2 > a1 {
+            -ccw_turn(a2, a1)
+        } else {
+            a2 - a1
+        };
+        let tau = std::f64::consts::TAU;
+        let sweep = sweep.to_radians().clamp(-tau * 4.0, tau * 4.0);
+        let a1 = (a1 % 360.0).to_radians();
+        let start = c + Vec2::new(r * a1.cos(), r * a1.sin());
+        self.append_user(std::iter::once(PathEl::MoveTo(start)))?;
+        let arc = kurbo::Arc::new(c, Vec2::new(r, r), a1, sweep, 0.0);
+        let tol = (0.01 / self.scale().max(1e-9)).max(1e-9);
+        self.append_user(arc.append_iter(tol))
+    }
+
+    /// `arct` / `arcto`: a line towards `p1` rounded with radius `r` into the line to `p2`; the
+    /// tangent points (user space).
+    pub(super) fn arct(&mut self, p1: Point, p2: Point, r: f64) -> Res<[Point; 2]> {
+        let p0 = self.user_point()?;
+        let (u, v) = (p0 - p1, p2 - p1);
+        let (lu, lv) = (u.hypot(), v.hypot());
+        let cross = u.cross(v);
+        if lu < 1e-12 || lv < 1e-12 || cross.abs() < 1e-12 || r <= 0.0 {
+            self.append_user(std::iter::once(PathEl::LineTo(p1)))?;
+            return Ok([p1, p1]);
+        }
+        let (u, v) = (u / lu, v / lv);
+        let half = u.dot(v).clamp(-1.0, 1.0).acos() / 2.0;
+        let dist = r / half.tan();
+        let (t1, t2) = (p1 + u * dist, p1 + v * dist);
+        let bis = (u + v).normalize();
+        let c = p1 + bis * (r / half.sin());
+        let (a1, a2) = ((t1 - c).atan2(), (t2 - c).atan2());
+        self.append_user(std::iter::once(PathEl::LineTo(t1)))?;
+        let tol = (0.01 / self.scale().max(1e-9)).max(1e-9);
+        let arc = kurbo::Arc::new(c, Vec2::new(r, r), a1, turn(a1, a2), 0.0);
+        self.append_user(arc.append_iter(tol))?;
+        Ok([t1, t2])
+    }
+
+    fn rect_path(&self, x: f64, y: f64, w: f64, h: f64) -> BezPath {
+        let xf = self.xf();
+        let mut bp = BezPath::new();
+        bp.move_to(xf * Point::new(x, y));
+        bp.line_to(xf * Point::new(x + w, y));
+        bp.line_to(xf * Point::new(x + w, y + h));
+        bp.line_to(xf * Point::new(x, y + h));
+        bp.close_path();
+        bp
+    }
+
+    /// The rectangles of `rectfill`, `rectstroke` and `rectclip`: `x y w h` or an array of them.
+    pub(super) fn rects(&mut self) -> Res<BezPath> {
+        let nums: Vec<f64> = match self.stack.last() {
+            Some(Obj::Array { .. }) => {
+                let items = self.pop_array()?;
+                // Five elements a rectangle, counted before the array is read.
+                self.spend_elements(items.len() / 4 * 5)?;
+                let v: Option<Vec<f64>> = items.borrow().iter().map(Obj::as_num).collect();
+                v.ok_or(PsError::Ps("typecheck", String::new()))?
+            }
+            _ => self.nums::<4>()?.to_vec(),
+        };
+        if nums.len() / 4 * 5 >= MAX_PATH {
+            return Err(PsError::Limit("a path has too many points"));
+        }
+        let mut bp = BezPath::new();
+        for [x, y, w, h] in nums.as_chunks::<4>().0 {
+            bp.extend(self.rect_path(*x, *y, *w, *h));
+        }
+        Ok(bp)
+    }
+
+    // ---------- painting ----------
+
+    pub(super) fn fill_path(&mut self, bp: BezPath, rule: FillRule) -> Res {
+        if bp.elements().is_empty() || self.g.null {
+            return Ok(());
+        }
+        // A mesh pattern paints its shading inside the path.
+        if let Some((sh, m)) = self.g.mesh.clone() {
+            let clips = self.g.clips.clone();
+            self.clip_with(bp, rule);
+            let r = self.mesh_fill(&sh, m);
+            self.g.clips = clips;
+            return r;
+        }
+        if self.g.paint.is_none() {
+            return Ok(());
+        }
+        let (paint, overprint) = (self.g.paint.clone(), self.g.overprint);
+        self.out.fill(bp, rule, paint, overprint, &self.g.clips);
+        Ok(())
+    }
+
+    pub(super) fn stroke_path(&mut self, bp: BezPath) -> Res {
+        if bp.elements().is_empty() || self.g.paint.is_none() || self.g.null {
+            return Ok(());
+        }
+        let st = self.stroke_layer()?;
+        self.out.stroke(bp, st, &self.g.clips);
+        Ok(())
+    }
+
+    /// The stroke the graphics state draws, in document space. Each entry of the dash pattern it
+    /// copies counts as an operation.
+    pub(super) fn stroke_layer(&mut self) -> Res<StrokeLayer> {
+        self.spend(self.g.dash.len() as u64)?;
+        let k = self.scale();
+        let w = self.g.width * k;
+        let mut st = StrokeLayer::new(self.g.paint.clone(), if w > 0.0 && w.is_finite() { w } else { HAIRLINE });
+        st.cap = self.g.cap;
+        st.join = self.g.join;
+        st.miter_limit = self.g.miter.clamp(1.0, 500.0);
+        st.overprint = self.g.overprint;
+        let pattern: Vec<f64> = self.g.dash.iter().map(|d| d * k).collect();
+        let dash = Dash { pattern, offset: self.g.dash_offset * k, align_corners: false };
+        st.dash = dash.is_dashed().then_some(dash);
+        Ok(st)
+    }
+
+    /// The current path in user space, each element as its operator and points (quadratic
+    /// segments as cubic ones).
+    fn user_elements(&self) -> Res<Vec<(Op, Vec<Point>)>> {
+        let xf = self.xf();
+        if xf.determinant().abs() < 1e-12 {
+            return ps_err("undefinedresult", "");
+        }
+        let inv = xf.inverse();
+        let mut last = Point::ZERO;
+        let mut out = Vec::with_capacity(self.g.path.elements().len());
+        for el in self.g.path.elements() {
+            let (op, pts) = match *el {
+                PathEl::MoveTo(p) => (Op::MoveTo, vec![p]),
+                PathEl::LineTo(p) => (Op::LineTo, vec![p]),
+                PathEl::QuadTo(a, p) => (Op::CurveTo, vec![last + (a - last) * (2.0 / 3.0), p + (a - p) * (2.0 / 3.0), p]),
+                PathEl::CurveTo(a, b, p) => (Op::CurveTo, vec![a, b, p]),
+                PathEl::ClosePath => (Op::ClosePath, vec![]),
+            };
+            last = pts.last().copied().unwrap_or(last);
+            out.push((op, pts.into_iter().map(|p| inv * p).collect()));
+        }
+        Ok(out)
+    }
+
+    /// `pathforall`: the current path in user space, each element through its procedure.
+    pub(super) fn path_for_all(&mut self) -> Res {
+        let close = self.pop_proc()?;
+        let curve = self.pop_proc()?;
+        let line = self.pop_proc()?;
+        let mv = self.pop_proc()?;
+        self.spend_elements(self.g.path.elements().len())?;
+        for (op, pts) in self.user_elements()? {
+            for p in pts {
+                self.push_num(p.x)?;
+                self.push_num(p.y)?;
+            }
+            let proc = match op {
+                Op::MoveTo => &mv,
+                Op::LineTo => &line,
+                Op::CurveTo => &curve,
+                _ => &close,
+            };
+            if !self.body(proc)? {
+                break;
+            }
+        }
+        Ok(())
+    }
+
+    /// Append user path `up` to the current path: a procedure of path operators, or the encoded
+    /// form (numbers and a string of operator codes).
+    pub(super) fn user_path(&mut self, up: Obj) -> Res {
+        let items = up.items().cloned().ok_or(PsError::Ps("typecheck", "a user path".into()))?;
+        let encoded = match (items.get(0), items.get(1), items.len()) {
+            (Some(nums @ (Obj::Array { .. } | Obj::Str(_))), Some(Obj::Str(ops)), 2) => Some((nums, ops.to_vec())),
+            _ => None,
+        };
+        let Some((nums, ops)) = encoded else { return self.call(Obj::Array { items, exec: true }) };
+        // The operators by code, with how many operands each takes.
+        const OPS: [(Op, usize); 12] = [
+            (Op::SetBBox, 4),
+            (Op::MoveTo, 2),
+            (Op::RMoveTo, 2),
+            (Op::LineTo, 2),
+            (Op::RLineTo, 2),
+            (Op::CurveTo, 6),
+            (Op::RCurveTo, 6),
+            (Op::Arc, 5),
+            (Op::Arcn, 5),
+            (Op::Arct, 5),
+            (Op::ClosePath, 0),
+            (Op::UCache, 0),
+        ];
+        let nums: Vec<f64> = match nums {
+            Obj::Array { items, .. } => {
+                // Each entry of the data array and each byte of the operator string counts as an
+                // element read.
+                self.spend_elements(items.len().saturating_add(ops.len()))?;
+                items.borrow().iter().filter_map(Obj::as_num).collect()
+            }
+            _ => return ps_err("typecheck", "an encoded user path"),
+        };
+        let mut next = nums.into_iter();
+        let mut repeat = 1usize;
+        for code in ops {
+            if code >= 32 {
+                repeat = usize::from(code - 32);
+                continue;
+            }
+            let &(op, n) = OPS.get(usize::from(code)).ok_or(PsError::Ps("rangecheck", "a user path".into()))?;
+            for _ in 0..std::mem::replace(&mut repeat, 1) {
+                for _ in 0..n {
+                    let v = next.next().ok_or(PsError::Ps("rangecheck", "a user path".into()))?;
+                    self.push_num(v)?;
+                }
+                // Each operator run counts as an operation.
+                self.spend(1)?;
+                self.op(op)?;
+            }
+        }
+        Ok(())
+    }
+
+    /// `ufill`, `ueofill`, `ustroke` (with an optional matrix): paint a user path, keeping the
+    /// current path.
+    pub(super) fn paint_user_path(&mut self, op: Op) -> Res {
+        let m = match (op, self.stack.last()) {
+            (Op::UStroke, Some(Obj::Array { items, exec: false })) if items.len() == 6 && self.stack.len() >= 2 => Some(self.pop_matrix()?),
+            _ => None,
+        };
+        let up = self.pop()?;
+        self.gsave()?;
+        let depth = self.saved.len();
+        self.take_path();
+        let r = self.user_path(up).and_then(|()| {
+            if let Some(m) = m {
+                self.g.ctm *= m;
+            }
+            let bp = self.take_path();
+            match op {
+                Op::UStroke => self.stroke_path(bp),
+                _ => self.fill_path(bp, if op == Op::UEoFill { FillRule::EvenOdd } else { FillRule::NonZero }),
+            }
+        });
+        self.saved.truncate(depth);
+        self.grestore();
+        r
+    }
+
+    /// `upath`: the current path as a user path (a procedure, in user space).
+    pub(super) fn upath(&mut self) -> Res {
+        self.pop_bool()?;
+        let elements = self.user_elements()?;
+        let b = self.xf().inverse().transform_rect_bbox(self.g.path.bounding_box());
+        let mut items: Vec<Obj> = [b.x0, b.y0, b.x1, b.y1].into_iter().map(Obj::Real).collect();
+        items.push(Obj::Op(Op::SetBBox));
+        for (op, pts) in elements {
+            items.extend(pts.iter().flat_map(|p| [Obj::Real(p.x), Obj::Real(p.y)]));
+            items.push(Obj::Op(op));
+        }
+        self.alloc(items.len() * std::mem::size_of::<Obj>())?;
+        self.push(Obj::proc(items))
+    }
+
+    /// `execform`: the form's `PaintProc` run with its matrix, clipped to its box.
+    pub(super) fn exec_form(&mut self) -> Res {
+        let d = self.pop_dict()?;
+        let get = |k: &str| d.borrow().get(&Key::name(k)).cloned();
+        let m = get("Matrix").and_then(|o| o.items().and_then(|i| crate::import::interp::matrix_of(&i.borrow()))).unwrap_or(Affine::IDENTITY);
+        let bbox: Vec<f64> = get("BBox").and_then(|o| o.items().map(|i| i.borrow().iter().filter_map(Obj::as_num).collect())).unwrap_or_default();
+        let paint = get("PaintProc").ok_or(PsError::Ps("undefined", "PaintProc".into()))?;
+        self.gsave()?;
+        let depth = self.saved.len();
+        self.g.ctm *= m;
+        if let [x0, y0, x1, y1] = bbox[..] {
+            let bp = self.rect_path(x0, y0, x1 - x0, y1 - y0);
+            self.take_path();
+            self.clip_with(bp, FillRule::NonZero);
+        }
+        self.push(Obj::Dict(d))?;
+        let r = self.call(paint);
+        self.saved.truncate(depth);
+        self.grestore();
+        r
+    }
+
+    pub(in super::super) fn take_path(&mut self) -> BezPath {
+        self.g.cur = None;
+        self.g.start = None;
+        std::mem::take(&mut self.g.path)
+    }
+
+    pub(super) fn clip_with(&mut self, path: BezPath, rule: FillRule) {
+        let Some(c) = self.out.clip(path, rule) else { return };
+        if self.g.clips.len() < MAX_NEST {
+            self.g.clips.push(c);
+        } else {
+            self.out.warn(&deep_clips());
+        }
+    }
+
+    /// The area the clip leaves, in document space (the page without a clip). The clip path read
+    /// counts against the operation budget.
+    pub(super) fn clip_bounds(&mut self) -> Res<Rect> {
+        let (bounds, len) =
+            self.g.clips.iter().rev().find_map(|c| c.region.as_ref()).map_or((self.out.frame, 0), |(p, _)| (p.bounding_box(), p.elements().len()));
+        self.spend_elements(len)?;
+        Ok(bounds)
+    }
+}
diff --git a/crates/eps/src/import/graphics/state.rs b/crates/eps/src/import/graphics/state.rs
new file mode 100644
index 000000000..6aa25d5a9
--- /dev/null
+++ b/crates/eps/src/import/graphics/state.rs
@@ -0,0 +1,328 @@
+use super::*;
+
+/// A colour space.
+#[derive(Clone, Debug)]
+pub(crate) enum Space {
+    Gray,
+    Rgb,
+    Cmyk,
+    /// Separation and DeviceN: the ink names, the alternate space and the tint transform.
+    Inks {
+        names: Vec<Rc<str>>,
+        alt: Rc<Space>,
+        tint: Obj,
+    },
+    Indexed {
+        base: Rc<Space>,
+        table: Rc<Vec<f64>>,
+    },
+    /// Patterns; an uncoloured one paints in a colour of the underlying space.
+    Pattern(Option<Rc<Space>>),
+}
+
+impl Space {
+    /// Components a colour has in it.
+    pub fn n(&self) -> usize {
+        match self {
+            Self::Gray | Self::Indexed { .. } | Self::Pattern(_) => 1,
+            Self::Rgb => 3,
+            Self::Cmyk => 4,
+            Self::Inks { names, .. } => names.len().max(1),
+        }
+    }
+
+    /// The colour `setcolorspace` starts with.
+    pub(super) fn initial(&self) -> Vec<f64> {
+        match self {
+            Self::Cmyk => vec![0.0, 0.0, 0.0, 1.0],
+            Self::Inks { names, .. } => vec![1.0; names.len().max(1)],
+            s => vec![0.0; s.n()],
+        }
+    }
+}
+
+/// A process colour from components in `space` (grey, RGB or CMYK), each clamped to 0–1.
+pub(crate) fn process(space: &Space, c: &[f64]) -> Option<Color> {
+    let v = |i: usize| c.get(i).map_or(0.0, |x| if x.is_finite() { x.clamp(0.0, 1.0) as f32 } else { 0.0 });
+    Some(match space {
+        Space::Gray => Color::gray(1.0 - v(0)),
+        Space::Rgb => Color::rgb(v(0), v(1), v(2)),
+        Space::Cmyk => Color::cmyk(v(0), v(1), v(2), v(3)),
+        _ => return None,
+    })
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct GState {
+    /// User space → PostScript's default space.
+    pub ctm: Affine,
+    pub space: Rc<Space>,
+    /// The `setcolorspace` operand, for `currentcolorspace`.
+    pub space_obj: Obj,
+    pub comps: Vec<f64>,
+    pub paint: Paint,
+    pub width: f64,
+    pub cap: LineCap,
+    pub join: LineJoin,
+    pub miter: f64,
+    /// The dash pattern, shared by the states saved or copied from this one.
+    pub dash: Rc<[f64]>,
+    pub dash_offset: f64,
+    /// The current path, in document space.
+    pub path: BezPath,
+    pub cur: Option<Point>,
+    pub start: Option<Point>,
+    pub clips: Vec<Arc<Clip>>,
+    /// The clips `clipsave` saved, for `cliprestore`.
+    pub saved_clips: Vec<Rc<[Arc<Clip>]>>,
+    pub overprint: bool,
+    pub font: Option<DictRef>,
+    /// `nulldevice`: painting draws nothing.
+    pub null: bool,
+    /// The colour is a shading pattern whose shading is a mesh: a fill paints it (the shading
+    /// and pattern space → the document).
+    pub mesh: Option<(DictRef, Affine)>,
+}
+
+impl Default for GState {
+    fn default() -> Self {
+        Self {
+            ctm: Affine::IDENTITY,
+            space: Rc::new(Space::Gray),
+            space_obj: Obj::name("DeviceGray"),
+            comps: vec![0.0],
+            paint: Paint::solid(Color::gray(1.0)),
+            width: 1.0,
+            cap: LineCap::Butt,
+            join: LineJoin::Miter,
+            miter: 10.0,
+            dash: Rc::from([]),
+            dash_offset: 0.0,
+            path: BezPath::new(),
+            cur: None,
+            start: None,
+            clips: vec![],
+            saved_clips: vec![],
+            overprint: false,
+            font: None,
+            null: false,
+            mesh: None,
+        }
+    }
+}
+
+/// What the program draws.
+pub(crate) struct Out {
+    /// The document being made: ids, images and swatches.
+    pub doc: Document,
+    pub drawn: Drawn,
+    pub warnings: Vec<String>,
+    /// PostScript's default space → document space.
+    pub page: Affine,
+    /// The page (the bounding box) in document space.
+    pub frame: Rect,
+    /// Clip and group ids are given in the order they open, so a chain of both sorts by id.
+    next_clip: u32,
+    /// The groups open (outermost first), and how many more opened past [`MAX_NEST`] (their art
+    /// goes in the innermost group kept).
+    pub(super) groups: Vec<Arc<Clip>>,
+    pub(super) too_deep: usize,
+    /// Path elements (and the clips and groups of each object) drawn so far (see [`MAX_DRAWN`]).
+    elements: usize,
+    /// The path the last object was filled with: a stroke of the same path right after joins it.
+    pub(super) merge: Option<BezPath>,
+    /// Process colours painted, by model (the document opens in CMYK when most are).
+    pub cmyk: usize,
+    pub rgb: usize,
+    /// Spot inks used: name and colour at full tint.
+    pub spots: Vec<(String, Color)>,
+    /// The color at full tint of each spot ink in [`Self::spots`], by name.
+    pub(super) spot_colors: HashMap<Rc<str>, Color>,
+    /// Rectangles painted with a shading (`shfill`): a clipping group of one is the clip path
+    /// filled with it.
+    pub shadings: HashSet<NodeId>,
+    /// Tiling patterns made into pattern swatches: the pattern's `PaintProc` (a pattern made
+    /// again with `makepattern` shares it) and cell, the colour an uncoloured one painted in, and
+    /// the swatch's name. Each list holds the patterns of one [`tiling_hash`]; a pattern whose
+    /// cell has a NaN corner is left out.
+    pub(super) tilings: HashMap<u64, Vec<Tiling>>,
+    /// How deep art drawn apart (a pattern's cell, a Type 3 glyph) is nested.
+    pub apart: u32,
+}
+
+fn sane(r: Rect) -> bool {
+    [r.x0, r.y0, r.x1, r.y1].iter().all(|v| v.is_finite() && v.abs() <= LIMIT)
+}
+
+/// A tiling pattern made into a pattern swatch, as [`Out::tilings`] lists it.
+pub(super) type Tiling = (Shared<Obj>, Rect, Option<Paint>, String);
+
+/// A hash of what tells tiling patterns apart in [`Out::tilings`]. Patterns that compare equal
+/// hash alike: each number goes in by its bits, and −0 goes in as 0.
+pub(super) fn tiling_hash(proc: &Shared<Obj>, tile: Rect, under: Option<&Paint>) -> u64 {
+    let mut h = DefaultHasher::new();
+    proc.hash(&mut h);
+    [tile.x0, tile.y0, tile.x1, tile.y1].map(|v| (v + 0.0).to_bits()).hash(&mut h);
+    if let Some(Paint::Solid { color, swatch, tint }) = under {
+        let c = match *color {
+            Color::Rgb { r, g, b } => [r, g, b, 0.0],
+            Color::Cmyk { c, m, y, k } => [c, m, y, k],
+            Color::Gray { k } => [k, 0.0, 0.0, 0.0],
+            Color::Lab { l, a, b } => [l, a, b, 0.0],
+        };
+        c.map(|v| (v + 0.0).to_bits()).hash(&mut h);
+        swatch.hash(&mut h);
+        (tint + 0.0).to_bits().hash(&mut h);
+    }
+    h.finish()
+}
+
+impl Out {
+    pub fn new(doc: Document, page: Affine, frame: Rect) -> Self {
+        Self {
+            doc,
+            drawn: vec![],
+            warnings: vec![],
+            page,
+            frame,
+            next_clip: 0,
+            groups: vec![],
+            too_deep: 0,
+            elements: 0,
+            merge: None,
+            cmyk: 0,
+            rgb: 0,
+            spots: vec![],
+            spot_colors: HashMap::new(),
+            shadings: HashSet::new(),
+            tilings: HashMap::new(),
+            apart: 0,
+        }
+    }
+
+    pub fn warn(&mut self, w: &str) {
+        if !self.warnings.iter().any(|x| x == w) {
+            self.warnings.push(w.to_string());
+        }
+    }
+
+    /// Open a group: what is drawn until it ends ([`Self::end_group`]) goes in it.
+    pub fn begin_group(&mut self) {
+        if self.groups.len() >= MAX_NEST {
+            self.too_deep += 1;
+            self.warn(&format!("groups nested more than {MAX_NEST} deep were read as part of the group around them"));
+            return;
+        }
+        self.next_clip += 1;
+        self.groups.push(Arc::new(Clip { id: self.next_clip, region: None }));
+    }
+
+    /// End the innermost group open (an end without a beginning ends nothing).
+    pub fn end_group(&mut self) {
+        if self.too_deep > 0 {
+            self.too_deep -= 1;
+        } else {
+            self.groups.pop();
+        }
+    }
+
+    /// The chain an object drawn under `clips` is drawn in: the clips and the groups open, in the
+    /// order they opened.
+    pub fn chain(&self, clips: &[Arc<Clip>]) -> Vec<Arc<Clip>> {
+        if self.groups.is_empty() {
+            return clips.to_vec();
+        }
+        let mut chain = Vec::with_capacity(clips.len() + self.groups.len());
+        let (mut a, mut b) = (clips.iter().peekable(), self.groups.iter().peekable());
+        while let (Some(x), Some(y)) = (a.peek(), b.peek()) {
+            let next = if x.id < y.id { a.next() } else { b.next() };
+            chain.extend(next.cloned());
+        }
+        chain.extend(a.chain(b).cloned());
+        chain
+    }
+
+    /// Add `node` under `clips` (in the groups open); `None` when it was left out.
+    pub fn push(&mut self, mut node: Node, clips: &[Arc<Clip>]) -> Option<NodeId> {
+        self.merge = None;
+        let chain = self.chain(clips);
+        let size = node.path_data().map_or(1, |p| p.subpaths.iter().map(|s| s.anchors.len()).sum()) + chain.len();
+        self.elements = self.elements.saturating_add(size);
+        if self.drawn.len() >= MAX_NODES || self.elements > MAX_DRAWN {
+            self.warn(TOO_MUCH);
+            return None;
+        }
+        if !node.visual_bounds().is_none_or(sane) {
+            self.warn(FAR_AWAY);
+            return None;
+        }
+        node.id = self.doc.alloc_id();
+        let id = node.id;
+        self.drawn.push((chain, node));
+        Some(id)
+    }
+
+    /// Count a paint's colour model.
+    fn count(&mut self, p: &Paint) {
+        match p {
+            Paint::Solid { color: Color::Cmyk { .. }, swatch: None, .. } => self.cmyk += 1,
+            Paint::Solid { color: Color::Rgb { .. }, swatch: None, .. } => self.rgb += 1,
+            _ => {}
+        }
+    }
+
+    /// Fill `bp` with `paint`.
+    pub(super) fn fill(&mut self, bp: BezPath, rule: FillRule, paint: Paint, overprint: bool, clips: &[Arc<Clip>]) {
+        self.count(&paint);
+        let item = AppearanceItem::Fill(FillLayer { overprint, ..FillLayer::new(paint) });
+        let mut n = Node::path(NodeId(0), PathData::from_bezpath(&bp), Appearance { items: vec![item], ..Appearance::default() });
+        if let NodeKind::Path { rule: r, .. } = &mut n.kind {
+            *r = rule;
+        }
+        if self.push(n, clips).is_some() {
+            self.merge = Some(bp);
+        }
+    }
+
+    /// Stroke `bp` with `st`: joins the object just filled with the same path, under the same
+    /// clips (`gsave fill grestore stroke`).
+    pub(super) fn stroke(&mut self, bp: BezPath, st: StrokeLayer, clips: &[Arc<Clip>]) {
+        self.count(&st.paint);
+        if self.merge.as_ref() == Some(&bp) {
+            let here = self.chain(clips);
+            if let Some((chain, last)) = self.drawn.last_mut()
+                && chain.iter().map(|c| c.id).eq(here.iter().map(|c| c.id))
+            {
+                last.appearance.items.push(AppearanceItem::Stroke(st));
+                self.merge = None;
+                return;
+            }
+        }
+        let n = Node::path(NodeId(0), PathData::from_bezpath(&bp), Appearance { items: vec![AppearanceItem::Stroke(st)], ..Appearance::default() });
+        self.push(n, clips);
+    }
+
+    /// A new clip of `path` inside `clips`; `None` for a rectangle around the whole page, which
+    /// clips nothing.
+    pub(super) fn clip(&mut self, path: BezPath, rule: FillRule) -> Option<Arc<Clip>> {
+        // Only a polygon that really covers the page: a diamond touching its edges has the page as
+        // its bounding box but cuts its corners away (#1542).
+        if path.elements().len() <= 6 && vectorcraft_geom::hit::polygon_covers_rect(&path, self.frame, 0.5) {
+            return None;
+        }
+        self.next_clip += 1;
+        Some(Arc::new(Clip { id: self.next_clip, region: Some((path, rule)) }))
+    }
+}
+
+/// The smallest angle from `a` to `b` (radians, −π to π).
+pub(super) fn turn(a: f64, b: f64) -> f64 {
+    let d = (b - a).rem_euclid(std::f64::consts::TAU);
+    if d > std::f64::consts::PI { d - std::f64::consts::TAU } else { d }
+}
+
+/// The angle from `a` counterclockwise to `b` (degrees, 0 to 360), worked out from what is left
+/// of each after whole turns.
+pub(super) fn ccw_turn(a: f64, b: f64) -> f64 {
+    (b % 360.0 - a % 360.0).rem_euclid(360.0)
+}