From 81723da90058ec74035691f9f07bd3c674fc05fb Mon Sep 17 00:00:00 2001
From: Mathias Amnell <104110+Amnell@users.noreply.github.com>
Date: Sat, 23 May 2026 17:20:59 +0200
Subject: [PATCH 1/9] Convert tests to swift testing

---
 Tests/SVGViewTests/BaseTestCase.swift   | 98 ++-----------------------
 Tests/SVGViewTests/SVGCustomTests.swift |  2 +-
 2 files changed, 6 insertions(+), 94 deletions(-)

diff --git a/Tests/SVGViewTests/BaseTestCase.swift b/Tests/SVGViewTests/BaseTestCase.swift
index 07362d10..cba49d3d 100644
--- a/Tests/SVGViewTests/BaseTestCase.swift
+++ b/Tests/SVGViewTests/BaseTestCase.swift
@@ -9,10 +9,6 @@ import Foundation
 import Testing
 @testable import SVGView
 
-#if canImport(SwiftUI)
-import SwiftUI
-#endif
-
 protocol SVGTestHelper {
     var dir: String { get }
 }
@@ -21,107 +17,23 @@ extension SVGTestHelper {
 
     var dir: String { "1.2T" }
 
-    func compareToReference(_ fileName: String) async throws {
+    func compareToReference(_ fileName: String) throws {
         let bundle = Bundle.module
         let svgURL = try #require(bundle.url(forResource: fileName, withExtension: "svg", subdirectory: "w3c/\(dir)/svg/"))
         let refURL = try #require(bundle.url(forResource: fileName, withExtension: "ref", subdirectory: "w3c/\(dir)/refs/"))
 
-        let svgSource = try String(contentsOf: svgURL)
         let node = try #require(SVGParser.parse(contentsOf: svgURL))
-        let content = Serializer.serialize(node)
+        let content = try #require(Serializer.serialize(node))
         let reference = try String(contentsOf: refURL)
 
-        Attachment.record(Attachment(svgSource, named: "\(fileName).svg"))
-        Attachment.record(Attachment(content, named: "\(fileName)-actual.txt"))
-        Attachment.record(Attachment(reference, named: "\(fileName)-expected.txt"))
-        Attachment.record(Attachment(unifiedDiff(actual: content, expected: reference), named: "\(fileName)-diff.txt"))
-        await renderedPNGAttachment(node: node, named: "\(fileName)-rendered.png")
-
-        #expect(content == reference, "nodeContent is not equal to referenceContent. \(prettyFirstDifferenceBetweenStrings(s1: content, s2: reference))")
+        let nodeContent = content
+        let referenceContent = reference
+        #expect(nodeContent == referenceContent, "nodeContent is not equal to referenceContent. \(prettyFirstDifferenceBetweenStrings(s1: nodeContent, s2: referenceContent))")
     }
 
     func prettyFirstDifferenceBetweenStrings(s1: String, s2: String) -> String {
         return prettyFirstDifferenceBetweenNSStrings(s1: s1 as NSString, s2: s2 as NSString) as String
     }
-
-    func unifiedDiff(actual: String, expected: String) -> String {
-        let actualLines = actual.components(separatedBy: "\n")
-        let expectedLines = expected.components(separatedBy: "\n")
-        var result = "--- expected\n+++ actual\n"
-        let lcs = longestCommonSubsequence(actualLines, expectedLines)
-        var i = 0, j = 0, k = 0
-        while i < actualLines.count || j < expectedLines.count {
-            if i < actualLines.count && j < expectedLines.count && k < lcs.count && actualLines[i] == lcs[k] && expectedLines[j] == lcs[k] {
-                result += " \(actualLines[i])\n"
-                i += 1; j += 1; k += 1
-            } else if j < expectedLines.count && (k >= lcs.count || expectedLines[j] != lcs[k]) {
-                result += "-\(expectedLines[j])\n"
-                j += 1
-            } else {
-                result += "+\(actualLines[i])\n"
-                i += 1
-            }
-        }
-        return result
-    }
-
-    private func longestCommonSubsequence(_ a: [String], _ b: [String]) -> [String] {
-        let m = a.count, n = b.count
-        var dp = Array(repeating: Array(repeating: 0, count: n + 1), count: m + 1)
-        for i in 1...m {
-            for j in 1...n {
-                dp[i][j] = a[i-1] == b[j-1] ? dp[i-1][j-1] + 1 : max(dp[i-1][j], dp[i][j-1])
-            }
-        }
-        var result: [String] = []
-        var i = m, j = n
-        while i > 0 && j > 0 {
-            if a[i-1] == b[j-1] { result.append(a[i-1]); i -= 1; j -= 1 }
-            else if dp[i-1][j] > dp[i][j-1] { i -= 1 }
-            else { j -= 1 }
-        }
-        return result.reversed()
-    }
-
-    /// Renders `node` to a PNG using `ImageRenderer` and records it as a test attachment.
-    /// Only runs on platforms that support `ImageRenderer` (macOS 13+, iOS 16+, watchOS 9+).
-    /// Failures are silently ignored — the render is a diagnostic aid, not part of correctness.
-    func renderedPNGAttachment(node: SVGNode, named name: String) async {
-#if canImport(SwiftUI)
-        if #available(macOS 13, iOS 16, watchOS 9, *) {
-            let size = renderSize(for: node)
-            let png = await MainActor.run { () -> Data? in
-                let renderer = ImageRenderer(content: SVGView(svg: node).frame(width: size.width, height: size.height))
-                renderer.scale = 1.0
-#if os(macOS)
-                guard let nsImage = renderer.nsImage,
-                      let tiff = nsImage.tiffRepresentation,
-                      let rep = NSBitmapImageRep(data: tiff) else { return nil }
-                return rep.representation(using: .png, properties: [:])
-#elseif os(iOS)
-                return renderer.uiImage?.pngData()
-#else
-                return nil
-#endif
-            }
-            if let png {
-                Attachment.record(Attachment(png, named: name))
-            }
-        }
-#endif
-    }
-
-    private func renderSize(for node: SVGNode) -> CGSize {
-        if let viewport = node as? SVGViewport {
-            if let box = viewport.viewBox, box.width > 0, box.height > 0 {
-                return CGSize(width: box.width, height: box.height)
-            }
-            if let w = viewport.width.ideal, let h = viewport.height.ideal, w > 0, h > 0 {
-                return CGSize(width: w, height: h)
-            }
-        }
-        return CGSize(width: 480, height: 360)
-    }
 }
 
 /// Find first differing character between two strings
diff --git a/Tests/SVGViewTests/SVGCustomTests.swift b/Tests/SVGViewTests/SVGCustomTests.swift
index dc454f19..2c960b2b 100644
--- a/Tests/SVGViewTests/SVGCustomTests.swift
+++ b/Tests/SVGViewTests/SVGCustomTests.swift
@@ -21,4 +21,4 @@ struct SVGCustomTests: SVGTestHelper {
         try await compareToReference("viewport-02")
     }
 
-}
\ No newline at end of file
+}

From 4dbc0a97418a33345e664cbc6d82c41608b5834d Mon Sep 17 00:00:00 2001
From: Mathias Amnell <104110+Amnell@users.noreply.github.com>
Date: Sun, 24 May 2026 13:21:57 +0200
Subject: [PATCH 2/9] Improve our test helper

---
 Tests/SVGViewTests/BaseTestCase.swift | 49 ++++++++++++++++++++++++---
 1 file changed, 45 insertions(+), 4 deletions(-)

diff --git a/Tests/SVGViewTests/BaseTestCase.swift b/Tests/SVGViewTests/BaseTestCase.swift
index cba49d3d..2b3a4025 100644
--- a/Tests/SVGViewTests/BaseTestCase.swift
+++ b/Tests/SVGViewTests/BaseTestCase.swift
@@ -23,17 +23,58 @@ extension SVGTestHelper {
         let refURL = try #require(bundle.url(forResource: fileName, withExtension: "ref", subdirectory: "w3c/\(dir)/refs/"))
 
         let node = try #require(SVGParser.parse(contentsOf: svgURL))
-        let content = try #require(Serializer.serialize(node))
+        let content = Serializer.serialize(node)
         let reference = try String(contentsOf: refURL)
 
-        let nodeContent = content
-        let referenceContent = reference
-        #expect(nodeContent == referenceContent, "nodeContent is not equal to referenceContent. \(prettyFirstDifferenceBetweenStrings(s1: nodeContent, s2: referenceContent))")
+        Attachment.record(Attachment(content, named: "\(fileName)-actual.txt"))
+        Attachment.record(Attachment(reference, named: "\(fileName)-expected.txt"))
+        Attachment.record(Attachment(unifiedDiff(actual: content, expected: reference), named: "\(fileName)-diff.txt"))
+
+        #expect(content == reference, "nodeContent is not equal to referenceContent. \(prettyFirstDifferenceBetweenStrings(s1: content, s2: reference))")
     }
 
     func prettyFirstDifferenceBetweenStrings(s1: String, s2: String) -> String {
         return prettyFirstDifferenceBetweenNSStrings(s1: s1 as NSString, s2: s2 as NSString) as String
     }
+
+    func unifiedDiff(actual: String, expected: String) -> String {
+        let actualLines = actual.components(separatedBy: "\n")
+        let expectedLines = expected.components(separatedBy: "\n")
+        var result = "--- expected\n+++ actual\n"
+        let lcs = longestCommonSubsequence(actualLines, expectedLines)
+        var i = 0, j = 0, k = 0
+        while i < actualLines.count || j < expectedLines.count {
+            if i < actualLines.count && j < expectedLines.count && k < lcs.count && actualLines[i] == lcs[k] && expectedLines[j] == lcs[k] {
+                result += " \(actualLines[i])\n"
+                i += 1; j += 1; k += 1
+            } else if j < expectedLines.count && (k >= lcs.count || expectedLines[j] != lcs[k]) {
+                result += "-\(expectedLines[j])\n"
+                j += 1
+            } else {
+                result += "+\(actualLines[i])\n"
+                i += 1
+            }
+        }
+        return result
+    }
+
+    private func longestCommonSubsequence(_ a: [String], _ b: [String]) -> [String] {
+        let m = a.count, n = b.count
+        var dp = Array(repeating: Array(repeating: 0, count: n + 1), count: m + 1)
+        for i in 1...m {
+            for j in 1...n {
+                dp[i][j] = a[i-1] == b[j-1] ? dp[i-1][j-1] + 1 : max(dp[i-1][j], dp[i][j-1])
+            }
+        }
+        var result: [String] = []
+        var i = m, j = n
+        while i > 0 && j > 0 {
+            if a[i-1] == b[j-1] { result.append(a[i-1]); i -= 1; j -= 1 }
+            else if dp[i-1][j] > dp[i][j-1] { i -= 1 }
+            else { j -= 1 }
+        }
+        return result.reversed()
+    }
 }
 
 /// Find first differing character between two strings

From 209623adf03995dbfe117de967b5563bbbb3c606 Mon Sep 17 00:00:00 2001
From: Mathias Amnell <104110+Amnell@users.noreply.github.com>
Date: Sun, 24 May 2026 13:56:25 +0200
Subject: [PATCH 3/9] Add generated png and source svg as test attachments to
 more easily debug

---
 Tests/SVGViewTests/BaseTestCase.swift | 49 ++++++++++++++++++++++++++-
 1 file changed, 48 insertions(+), 1 deletion(-)

diff --git a/Tests/SVGViewTests/BaseTestCase.swift b/Tests/SVGViewTests/BaseTestCase.swift
index 2b3a4025..07362d10 100644
--- a/Tests/SVGViewTests/BaseTestCase.swift
+++ b/Tests/SVGViewTests/BaseTestCase.swift
@@ -9,6 +9,10 @@ import Foundation
 import Testing
 @testable import SVGView
 
+#if canImport(SwiftUI)
+import SwiftUI
+#endif
+
 protocol SVGTestHelper {
     var dir: String { get }
 }
@@ -17,18 +21,21 @@ extension SVGTestHelper {
 
     var dir: String { "1.2T" }
 
-    func compareToReference(_ fileName: String) throws {
+    func compareToReference(_ fileName: String) async throws {
         let bundle = Bundle.module
         let svgURL = try #require(bundle.url(forResource: fileName, withExtension: "svg", subdirectory: "w3c/\(dir)/svg/"))
         let refURL = try #require(bundle.url(forResource: fileName, withExtension: "ref", subdirectory: "w3c/\(dir)/refs/"))
 
+        let svgSource = try String(contentsOf: svgURL)
         let node = try #require(SVGParser.parse(contentsOf: svgURL))
         let content = Serializer.serialize(node)
         let reference = try String(contentsOf: refURL)
 
+        Attachment.record(Attachment(svgSource, named: "\(fileName).svg"))
         Attachment.record(Attachment(content, named: "\(fileName)-actual.txt"))
         Attachment.record(Attachment(reference, named: "\(fileName)-expected.txt"))
         Attachment.record(Attachment(unifiedDiff(actual: content, expected: reference), named: "\(fileName)-diff.txt"))
+        await renderedPNGAttachment(node: node, named: "\(fileName)-rendered.png")
 
         #expect(content == reference, "nodeContent is not equal to referenceContent. \(prettyFirstDifferenceBetweenStrings(s1: content, s2: reference))")
     }
@@ -75,6 +82,46 @@ extension SVGTestHelper {
         }
         return result.reversed()
     }
+
+    /// Renders `node` to a PNG using `ImageRenderer` and records it as a test attachment.
+    /// Only runs on platforms that support `ImageRenderer` (macOS 13+, iOS 16+, watchOS 9+).
+    /// Failures are silently ignored — the render is a diagnostic aid, not part of correctness.
+    func renderedPNGAttachment(node: SVGNode, named name: String) async {
+#if canImport(SwiftUI)
+        if #available(macOS 13, iOS 16, watchOS 9, *) {
+            let size = renderSize(for: node)
+            let png = await MainActor.run { () -> Data? in
+                let renderer = ImageRenderer(content: SVGView(svg: node).frame(width: size.width, height: size.height))
+                renderer.scale = 1.0
+#if os(macOS)
+                guard let nsImage = renderer.nsImage,
+                      let tiff = nsImage.tiffRepresentation,
+                      let rep = NSBitmapImageRep(data: tiff) else { return nil }
+                return rep.representation(using: .png, properties: [:])
+#elseif os(iOS)
+                return renderer.uiImage?.pngData()
+#else
+                return nil
+#endif
+            }
+            if let png {
+                Attachment.record(Attachment(png, named: name))
+            }
+        }
+#endif
+    }
+
+    private func renderSize(for node: SVGNode) -> CGSize {
+        if let viewport = node as? SVGViewport {
+            if let box = viewport.viewBox, box.width > 0, box.height > 0 {
+                return CGSize(width: box.width, height: box.height)
+            }
+            if let w = viewport.width.ideal, let h = viewport.height.ideal, w > 0, h > 0 {
+                return CGSize(width: w, height: h)
+            }
+        }
+        return CGSize(width: 480, height: 360)
+    }
 }
 
 /// Find first differing character between two strings

From 3666bb0643330b322df09a975628cde908a38906 Mon Sep 17 00:00:00 2001
From: Mathias Amnell <104110+Amnell@users.noreply.github.com>
Date: Sun, 24 May 2026 15:22:23 +0200
Subject: [PATCH 4/9] Implement SVG pattern paint server with xlink:href
 inheritance (pservers-grad-03-b)

- Add SVGPattern model (SVGPaint subclass) with CGBitmapContext tile rendering
- Add draw(in: CGContext) to SVGNode (no-op), SVGRect, and SVGGroup
- Add SVGParser.parseElements(_:index:) internal helper for pattern tile parsing
- Register <pattern> elements as paint servers in SVGIndex with xlink:href inheritance
- Wire SVGPattern into SVGPaint.apply(paint:model:) switch
- Add pserversGrad03B test and reference file
---
 GenerateReferencesCLI/cli.swift               |  1 +
 Source/Model/Nodes/SVGGroup.swift             | 11 +++
 Source/Model/Nodes/SVGNode.swift              |  6 ++
 Source/Model/Primitives/SVGPaint.swift        |  2 +
 Source/Model/Primitives/SVGPattern.swift      | 77 +++++++++++++++++++
 Source/Model/Shapes/SVGRect.swift             | 17 +++-
 Source/Parser/SVG/SVGIndex.swift              | 40 +++++++++-
 Source/Parser/SVG/SVGParser.swift             | 12 +++
 Tests/SVGViewTests/SVG11Tests.swift           |  1 +
 .../w3c/1.1F2/refs/pservers-grad-03-b.ref     | 46 +++++++++++
 10 files changed, 211 insertions(+), 2 deletions(-)
 create mode 100644 Source/Model/Primitives/SVGPattern.swift
 create mode 100644 Tests/SVGViewTests/w3c/1.1F2/refs/pservers-grad-03-b.ref

diff --git a/GenerateReferencesCLI/cli.swift b/GenerateReferencesCLI/cli.swift
index 770c4fba..203f4256 100644
--- a/GenerateReferencesCLI/cli.swift
+++ b/GenerateReferencesCLI/cli.swift
@@ -76,6 +76,7 @@ struct cli: ParsableCommand {
         "paths-data-20-f",
         "pservers-grad-01-b",
         "pservers-grad-02-b",
+        "pservers-grad-03-b",
         "pservers-grad-04-b",
         "pservers-grad-05-b",
         "pservers-grad-07-b",
diff --git a/Source/Model/Nodes/SVGGroup.swift b/Source/Model/Nodes/SVGGroup.swift
index ce143cc7..4fef4e1b 100644
--- a/Source/Model/Nodes/SVGGroup.swift
+++ b/Source/Model/Nodes/SVGGroup.swift
@@ -44,6 +44,17 @@ public class SVGGroup: SVGNode {
         serializer.add("contents", contents)
     }
 
+    #if !os(WASI) && !os(Linux)
+    override func draw(in context: CGContext) {
+        context.saveGState()
+        context.concatenate(transform)
+        for node in contents {
+            node.draw(in: context)
+        }
+        context.restoreGState()
+    }
+    #endif
+
     #if canImport(SwiftUI)
     public func contentView() -> some View {
         SVGGroupView(model: self)
diff --git a/Source/Model/Nodes/SVGNode.swift b/Source/Model/Nodes/SVGNode.swift
index 1476a92c..f9602b4a 100644
--- a/Source/Model/Nodes/SVGNode.swift
+++ b/Source/Model/Nodes/SVGNode.swift
@@ -86,6 +86,12 @@ public class SVGNode: SerializableElement {
         return String(describing: type(of: self))
     }
 
+    #if !os(WASI) && !os(Linux)
+    func draw(in context: CGContext) {
+        // default: no-op
+    }
+    #endif
+
 }
 
 #if canImport(SwiftUI)
diff --git a/Source/Model/Primitives/SVGPaint.swift b/Source/Model/Primitives/SVGPaint.swift
index 19076133..8c775cc2 100644
--- a/Source/Model/Primitives/SVGPaint.swift
+++ b/Source/Model/Primitives/SVGPaint.swift
@@ -34,6 +34,8 @@ extension View {
                 linearGradient.apply(view: self, model: model)
             case let radialGradient as SVGRadialGradient:
                 radialGradient.apply(view: self, model: model)
+            case let pattern as SVGPattern:
+                pattern.apply(view: self, model: model)
             case let color as SVGColor:
                 color.apply(view: self, model: model)
             default:
diff --git a/Source/Model/Primitives/SVGPattern.swift b/Source/Model/Primitives/SVGPattern.swift
new file mode 100644
index 00000000..378bdc92
--- /dev/null
+++ b/Source/Model/Primitives/SVGPattern.swift
@@ -0,0 +1,77 @@
+//
+//  SVGPattern.swift
+//  SVGView
+//
+
+#if os(WASI) || os(Linux)
+import Foundation
+#else
+import SwiftUI
+#endif
+
+public class SVGPattern: SVGPaint {
+
+    public let x: CGFloat
+    public let y: CGFloat
+    public let width: CGFloat
+    public let height: CGFloat
+    public let userSpace: Bool
+    public let patternTransform: CGAffineTransform
+    public let contents: [SVGNode]
+
+    public init(x: CGFloat = 0, y: CGFloat = 0, width: CGFloat = 0, height: CGFloat = 0,
+                userSpace: Bool = true, patternTransform: CGAffineTransform = .identity,
+                contents: [SVGNode] = []) {
+        self.x = x
+        self.y = y
+        self.width = width
+        self.height = height
+        self.userSpace = userSpace
+        self.patternTransform = patternTransform
+        self.contents = contents
+    }
+
+    #if canImport(SwiftUI)
+    @ViewBuilder
+    func apply<S: View>(view: S, model: SVGShape? = nil) -> some View {
+        if width > 0, height > 0, !contents.isEmpty, let cgImage = renderTile() {
+            let image = Image(decorative: cgImage, scale: 1.0)
+            let bounds = model?.bounds() ?? .zero
+            view
+                .foregroundColor(.clear)
+                .overlay(
+                    Rectangle()
+                        .fill(ImagePaint(image: image, scale: 1.0))
+                        .frame(width: bounds.width, height: bounds.height)
+                        .offset(x: bounds.minX, y: bounds.minY)
+                        .mask(view)
+                )
+        } else {
+            view.foregroundColor(.clear)
+        }
+    }
+
+    private func renderTile() -> CGImage? {
+        let w = Int(ceil(width))
+        let h = Int(ceil(height))
+        guard w > 0, h > 0 else { return nil }
+        let colorSpace = CGColorSpaceCreateDeviceRGB()
+        guard let context = CGContext(
+            data: nil,
+            width: w,
+            height: h,
+            bitsPerComponent: 8,
+            bytesPerRow: 0,
+            space: colorSpace,
+            bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue
+        ) else { return nil }
+        // Flip coordinate system to match SVG (y increases downward)
+        context.translateBy(x: 0, y: CGFloat(h))
+        context.scaleBy(x: 1, y: -1)
+        for node in contents {
+            node.draw(in: context)
+        }
+        return context.makeImage()
+    }
+    #endif
+}
diff --git a/Source/Model/Shapes/SVGRect.swift b/Source/Model/Shapes/SVGRect.swift
index 0179896c..36cc6b8c 100644
--- a/Source/Model/Shapes/SVGRect.swift
+++ b/Source/Model/Shapes/SVGRect.swift
@@ -47,7 +47,22 @@ public class SVGRect: SVGShape {
         serializer.add("rx", rx, 0).add("ry", ry, 0)
         super.serialize(serializer)
     }
-    
+
+    #if !os(WASI) && !os(Linux)
+    override func draw(in context: CGContext) {
+        guard let color = fill as? SVGColor else { return }
+        context.saveGState()
+        context.setFillColor(CGColor(
+            red: CGFloat(color.r) / 255,
+            green: CGFloat(color.g) / 255,
+            blue: CGFloat(color.b) / 255,
+            alpha: CGFloat(color.opacity)
+        ))
+        context.fill(CGRect(x: x, y: y, width: width, height: height))
+        context.restoreGState()
+    }
+    #endif
+
     #if canImport(SwiftUI)
     public func contentView() -> some View {
         SVGRectView(model: self)
diff --git a/Source/Parser/SVG/SVGIndex.swift b/Source/Parser/SVG/SVGIndex.swift
index b1a3d188..6c7f5ecd 100644
--- a/Source/Parser/SVG/SVGIndex.swift
+++ b/Source/Parser/SVG/SVGIndex.swift
@@ -37,7 +37,7 @@ class SVGIndex {
         if let id = SVGHelper.parseId(element.attributes) {
             elements[id] = element
             switch element.name {
-            case "linearGradient", "radialGradient", "fill":
+            case "linearGradient", "radialGradient", "fill", "pattern":
                 paints[id] = parseFill(element)
             default:
                 elements[id] = element
@@ -60,11 +60,49 @@ class SVGIndex {
             return parseLinearGradient(element)
         case "radialGradient":
             return parseRadialGradient(element)
+        case "pattern":
+            return parsePattern(element)
         default:
             return .none
         }
     }
 
+    private func getParentPattern(_ element: XMLElement) -> SVGPattern? {
+        if let link = element.attributes["xlink:href"]?.replacingOccurrences(of: " ", with: ""), link.hasPrefix("#") {
+            let id = link.replacingOccurrences(of: "#", with: "")
+            return paints[id] as? SVGPattern
+        }
+        return nil
+    }
+
+    private func parsePattern(_ element: XMLElement) -> SVGPattern? {
+        let parent = getParentPattern(element)
+        let childElements = element.contents.compactMap { $0 as? XMLElement }
+        let contents: [SVGNode]
+        if childElements.isEmpty {
+            contents = parent?.contents ?? []
+        } else {
+            contents = SVGParser.parseElements(childElements, index: self)
+        }
+        guard !contents.isEmpty else { return nil }
+        let x = SVGHelper.parseCGFloat(element.attributes, "x", defaultValue: parent?.x ?? 0)
+        let y = SVGHelper.parseCGFloat(element.attributes, "y", defaultValue: parent?.y ?? 0)
+        let width = SVGHelper.parseCGFloat(element.attributes, "width", defaultValue: parent?.width ?? 0)
+        let height = SVGHelper.parseCGFloat(element.attributes, "height", defaultValue: parent?.height ?? 0)
+        guard width > 0, height > 0 else { return nil }
+        var userSpace = parent?.userSpace ?? false
+        if let patternUnits = element.attributes["patternUnits"] {
+            userSpace = patternUnits == "userSpaceOnUse"
+        }
+        var patternTransform = parent?.patternTransform ?? .identity
+        if let transformStr = element.attributes["patternTransform"] {
+            patternTransform = SVGHelper.parseTransform(transformStr)
+        }
+        return SVGPattern(x: x, y: y, width: width, height: height,
+                          userSpace: userSpace, patternTransform: patternTransform,
+                          contents: contents)
+    }
+
     private func getParentGradient(_ element: XMLElement) -> SVGGradient? {
         if let link = element.attributes["xlink:href"]?.replacingOccurrences(of: " ", with: ""), link.hasPrefix("#") {
 
diff --git a/Source/Parser/SVG/SVGParser.swift b/Source/Parser/SVG/SVGParser.swift
index 74a72efb..e799d44f 100644
--- a/Source/Parser/SVG/SVGParser.swift
+++ b/Source/Parser/SVG/SVGParser.swift
@@ -50,6 +50,18 @@ public struct SVGParser {
         return parse(context: context)
     }
 
+    /// Parses a list of XML elements using the given index. Used for pattern tile content.
+    static func parseElements(_ elements: [XMLElement], index: SVGIndex) -> [SVGNode] {
+        let context = SVGRootContext(
+            logger: SVGLogger.console,
+            linker: SVGLinker.none,
+            screen: SVGScreen.main(ppi: 96),
+            index: index,
+            defaultFontSize: 16
+        )
+        return elements.compactMap { parse(element: $0, parentContext: context) }
+    }
+
     private static let parsers: [String:SVGElementParser] = [
         "svg": SVGViewportParser(),
         "g": SVGGroupParser(),
diff --git a/Tests/SVGViewTests/SVG11Tests.swift b/Tests/SVGViewTests/SVG11Tests.swift
index 41756562..77c6023e 100644
--- a/Tests/SVGViewTests/SVG11Tests.swift
+++ b/Tests/SVGViewTests/SVG11Tests.swift
@@ -104,6 +104,7 @@ struct SVG11Tests {
 
         @Test func pserversGrad01B() async throws { try await compareToReference("pservers-grad-01-b") }
         @Test func pserversGrad02B() async throws { try await compareToReference("pservers-grad-02-b") }
+        @Test func pserversGrad03B() async throws { try await compareToReference("pservers-grad-03-b") }
         @Test func pserversGrad04B() async throws { try await compareToReference("pservers-grad-04-b") }
         @Test func pserversGrad05B() async throws { try await compareToReference("pservers-grad-05-b") }
         @Test func pserversGrad07B() async throws { try await compareToReference("pservers-grad-07-b") }
diff --git a/Tests/SVGViewTests/w3c/1.1F2/refs/pservers-grad-03-b.ref b/Tests/SVGViewTests/w3c/1.1F2/refs/pservers-grad-03-b.ref
new file mode 100644
index 00000000..1a33c524
--- /dev/null
+++ b/Tests/SVGViewTests/w3c/1.1F2/refs/pservers-grad-03-b.ref
@@ -0,0 +1,46 @@
+SVGViewport {
+	id: "svg-root",
+	viewBox: { width: 480, height: 360 },
+	scaling: "none",
+	contents: [
+		SVGDefs {  },
+		SVGGroup {
+			id: "test-body-content",
+			contents: [
+				SVGRect { x: 20, y: 20, width: 440, height: 80 },
+				SVGText {
+					text: "Pattern fill.",
+					font: { name: "SVGFreeSansASCII,sans-serif", size: 30 },
+					fill: "black",
+					transform: [1, 0, 0, 1, 20, 130]
+				},
+				SVGRect { x: 20, y: 160, width: 440, height: 80 },
+				SVGText {
+					text: "Referencing pattern fill below.",
+					font: { name: "SVGFreeSansASCII,sans-serif", size: 30 },
+					fill: "black",
+					transform: [1, 0, 0, 1, 20, 270]
+				}
+			]
+		},
+		SVGGroup {
+			contents: [
+				SVGText {
+					id: "revision",
+					text: "$Revision: 1.8 $",
+					font: { name: "SVGFreeSansASCII,sans-serif", size: 32 },
+					fill: "black",
+					transform: [1, 0, 0, 1, 10, 340]
+				}
+			]
+		},
+		SVGRect {
+			id: "test-frame",
+			x: 1,
+			y: 1,
+			width: 478,
+			height: 358,
+			stroke: { fill: "black" }
+		}
+	]
+}

From 891990eaef4e901522acb419d5e3827a5f1f136f Mon Sep 17 00:00:00 2001
From: Mathias Amnell <104110+Amnell@users.noreply.github.com>
Date: Sun, 24 May 2026 15:26:38 +0200
Subject: [PATCH 5/9] Add AGENTS.md and architecture/feature reference docs

---
 .github/docs/architecture.md          |  82 ++++++++++++++++++
 .github/docs/implementing-features.md | 116 ++++++++++++++++++++++++++
 AGENTS.md                             |  35 ++++++++
 3 files changed, 233 insertions(+)
 create mode 100644 .github/docs/architecture.md
 create mode 100644 .github/docs/implementing-features.md
 create mode 100644 AGENTS.md

diff --git a/.github/docs/architecture.md b/.github/docs/architecture.md
new file mode 100644
index 00000000..e2590169
--- /dev/null
+++ b/.github/docs/architecture.md
@@ -0,0 +1,82 @@
+# Architecture & Parsing Pipeline
+
+## Overview
+
+```
+SVGParser.parse(xml:)
+  │
+  ├─ SVGIndex(element:)          ← traverses full XML tree FIRST
+  │    ├─ elements[id] = XMLElement
+  │    ├─ paints[id]  = SVGPaint  ← linearGradient, radialGradient, pattern
+  │    └─ CSSParser               ← <style> blocks
+  │
+  └─ parse(element:parentContext:)  ← depth-first node tree construction
+       └─ SVGNodeContext            ← merges style + property attributes
+            └─ parsers[tag]?.parse() → SVGNode
+```
+
+`SVGIndex` is built before any `SVGNode` objects exist. Element parsers receive an `SVGNodeContext` that holds the completed index.
+
+## Platform Guards
+
+```swift
+#if os(WASI) || os(Linux)          // polyfill only — no SwiftUI, no CoreGraphics
+#else
+import SwiftUI                     // Apple platforms
+#endif
+
+#if canImport(SwiftUI)             // SwiftUI view code
+#endif
+
+#if !os(WASI) && !os(Linux)       // CoreGraphics (CGContext, CGColor, etc.)
+#endif
+```
+
+Always use these guards when touching model, parser, or rendering code.
+
+## Paint Server Resolution
+
+When a shape has `fill="url(#someId)"`:
+
+1. `SVGHelper.parseFill(_:index:)` → `parseFillInternal`
+2. `index.paint(by: "someId")` → returns the pre-built `SVGPaint`
+3. At render time, `view.apply(paint: model.fill, model: model)` dispatches on type:
+   - `SVGLinearGradient` → `LinearGradient` overlay
+   - `SVGRadialGradient` → `RadialGradient` overlay
+   - `SVGPattern` → `CGBitmapContext` tile → `ImagePaint` overlay
+   - `SVGColor` → `.foregroundColor`
+
+`xlink:href` on a paint server (e.g. a gradient or pattern referencing another) is resolved inside `SVGIndex` using `getParentGradient()` / `getParentPattern()`. Property lookup falls back to the parent when an attribute is absent on the child element. Content (stops / tile nodes) is inherited when the child element has no children of its own.
+
+## SVGNode Rendering
+
+Each model class provides its own SwiftUI view inside `#if canImport(SwiftUI)`:
+
+```swift
+public class SVGRect: SVGShape {
+    public func contentView() -> some View { SVGRectView(model: self) }
+}
+
+struct SVGRectView: View {
+    @ObservedObject var model: SVGRect
+    var body: some View {
+        RoundedRectangle(...)
+            .applySVGStroke(stroke: model.stroke)
+            .applyShapeAttributes(model: model)   // fill + node attributes
+            .frame(...).position(...).offset(...)
+    }
+}
+```
+
+`SVGNode.toSwiftUI()` dispatches to the right view via a type switch — add new cases there when adding new node types.
+
+## CGContext Tile Rendering (Patterns)
+
+`SVGPattern` renders its tile using `CGBitmapContext` (thread-safe, no `@MainActor`):
+
+1. Create `CGBitmapContext` at `ceil(width) × ceil(height)` pixels.
+2. Flip coordinate system: `translateBy(x:0, y:h); scaleBy(x:1, y:-1)` so y increases downward (matching SVG).
+3. Call `node.draw(in: context)` for each tile child — default is no-op; `SVGRect` and `SVGGroup` override it.
+4. `context.makeImage()` → `CGImage` → `Image(decorative:scale:1.0)` → `ImagePaint`.
+
+To support additional shapes inside patterns, override `draw(in context: CGContext)` in the shape class under `#if !os(WASI) && !os(Linux)`.
diff --git a/.github/docs/implementing-features.md b/.github/docs/implementing-features.md
new file mode 100644
index 00000000..2f0654d7
--- /dev/null
+++ b/.github/docs/implementing-features.md
@@ -0,0 +1,116 @@
+# Implementing New SVG Features
+
+## Adding a New SVG Element
+
+A renderable element (e.g. `<ellipse>`) needs three things:
+
+### 1. Model class — `Source/Model/Shapes/SVGFoo.swift`
+
+Subclass `SVGShape` (for shapes with fill/stroke) or `SVGNode`. Follow `SVGRect.swift` as a template:
+- Store geometry properties under platform guards (`@Published` on Apple, plain `var` on WASI/Linux).
+- Override `frame() -> CGRect`.
+- Override `serialize(_ serializer:)`.
+- Implement `contentView()` + `SVGFooView: View` inside `#if canImport(SwiftUI)`.
+- If the element may appear inside a `<pattern>` tile, override `draw(in context: CGContext)` under `#if !os(WASI) && !os(Linux)`.
+
+### 2. Element parser — `Source/Parser/SVG/Elements/`
+
+Create or extend a parser file. Subclass `SVGBaseElementParser` and override `doParse(context:delegate:)`. Use `SVGShapeParser.swift` as a template for shapes. Parse attributes via `SVGHelper` and `context.properties` / `context.styles`.
+
+### 3. Register in `SVGParser.parsers`
+
+```swift
+// Source/Parser/SVG/SVGParser.swift
+private static let parsers: [String: SVGElementParser] = [
+    ...
+    "foo": SVGFooParser(),
+]
+```
+
+Also add a case to `SVGNode.toSwiftUI()` if the new type is a distinct node class.
+
+---
+
+## Adding a New Paint Server
+
+A paint server is resolved from `fill="url(#id)"` or `stroke="url(#id)"`. Follow `SVGPattern` as the most recent example.
+
+### 1. Model class — `Source/Model/Primitives/SVGFooPaint.swift`
+
+Subclass `SVGPaint`. Implement `apply<S>(view: S, model: SVGShape?) -> some View` inside `#if canImport(SwiftUI)` using `@ViewBuilder`. The pattern for overlay masking:
+
+```swift
+view
+    .foregroundColor(.clear)
+    .overlay(
+        <fill view>
+            .frame(width: bounds.width, height: bounds.height)
+            .offset(x: bounds.minX, y: bounds.minY)
+            .mask(view)
+    )
+```
+
+### 2. Register in `SVGIndex`
+
+In `Source/Parser/SVG/SVGIndex.swift`:
+
+```swift
+// fill(from:) switch:
+case "linearGradient", "radialGradient", "pattern", "myNewType":
+    paints[id] = parseFill(element)
+
+// parseFill() switch:
+case "myNewType":
+    return parseMyNewType(element)
+```
+
+Add `parseMyNewType(_ element: XMLElement) -> SVGPaint?`. For `xlink:href` inheritance, look up `paints[id]` and cast — see `getParentGradient()` / `getParentPattern()` for the pattern.
+
+### 3. Wire into `SVGPaint.apply(paint:model:)`
+
+```swift
+// Source/Model/Primitives/SVGPaint.swift
+case let foo as SVGFooPaint:
+    foo.apply(view: self, model: model)
+```
+
+---
+
+## Test Workflow
+
+1. **Add the test** to the relevant suite in `Tests/SVGViewTests/SVG11Tests.swift` (or `SVG12Tests.swift` / `SVGCustomTests.swift`):
+   ```swift
+   @Test func myFeatureTest() async throws { try await compareToReference("my-test-name") }
+   ```
+
+2. **Add to the CLI list** in `GenerateReferencesCLI/cli.swift` under `v11Refs` (or `v12Refs` / `customRefs`).
+
+3. **Generate the reference file** — this snapshots the current parser output as the accepted result:
+   ```bash
+   swift run GenerateReferencesCLI Tests/SVGViewTests/w3c
+   ```
+   The `.ref` file is written to `Tests/SVGViewTests/w3c/<version>/refs/<name>.ref`.
+
+4. **Run the test** to confirm it passes:
+   ```bash
+   swift test --filter <TestFunctionName>
+   ```
+
+5. **Update `w3c-coverage.md`** — change `❌` to `✅` for the test entry:
+   ```bash
+   ./w3c-coverage.sh
+   ```
+
+> The test compares `Serializer.serialize(node)` text output — it validates the parsed node structure, not pixel output. The rendered PNG is recorded as an attachment for manual inspection but does not assert.
+
+---
+
+## Key Helpers
+
+| Helper | Location | Purpose |
+|--------|----------|---------|
+| `SVGHelper.parseCGFloat(_:_:defaultValue:)` | `SVGParserBasics.swift` | Parse numeric attribute |
+| `SVGHelper.parseFill(_:index:)` | `SVGParserBasics.swift` | Resolve fill paint (color or `url(#...)`) |
+| `SVGHelper.parseTransform(_:)` | `SVGParserPrimitives.swift` | Parse `transform` / `*Transform` attribute |
+| `SVGHelper.parseColor(_:_:)` | `SVGParserBasics.swift` | Parse color string to `SVGColor` |
+| `SVGParser.parseElements(_:index:)` | `SVGParser.swift` | Parse `XMLElement[]` into `SVGNode[]` (used by pattern tile parsing) |
diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 00000000..1ba06640
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,35 @@
+# SVGView — Agent Guidelines
+
+SVGView is a Swift Package that parses SVG files into a model tree (`SVGNode` subclasses) and renders them with SwiftUI. It targets iOS, macOS, tvOS, and watchOS; WASI/Linux builds exclude all SwiftUI/CoreGraphics code.
+
+## Build & Test
+
+```bash
+swift build
+swift test
+swift test --filter <TestName>          # run a single test
+swift run GenerateReferencesCLI Tests/SVGViewTests/w3c   # regenerate .ref snapshots
+```
+
+Tests are snapshot-based: the parsed node tree is serialized to text and compared against a `.ref` file. The visual render is recorded as an attachment only — it does not assert.
+
+## Key Directories
+
+| Path | Purpose |
+|------|---------|
+| `Source/Model/` | SVGNode model classes (shapes, groups, primitives) |
+| `Source/Parser/SVG/` | Parser pipeline — `SVGParser`, `SVGIndex`, element parsers, context |
+| `Source/Model/Primitives/` | Paint servers: `SVGColor`, `SVGLinearGradient`, `SVGRadialGradient`, `SVGPattern` |
+| `Source/UI/` | Platform-specific extensions (`MBezierPath`) |
+| `Tests/SVGViewTests/` | Snapshot tests + W3C test SVGs and `.ref` files |
+| `GenerateReferencesCLI/` | CLI tool to regenerate `.ref` snapshot files |
+| `w3c-coverage.md` | ✅/❌ table of W3C test pass/fail status |
+
+## W3C Test Coverage
+
+`w3c-coverage.md` tracks which W3C conformance tests pass. `w3c-coverage.sh` regenerates it by running the test suite. When a new feature is implemented, add a test to `SVG11Tests.swift` and regenerate the corresponding `.ref` file.
+
+## Reference Docs
+
+- [Architecture & parsing pipeline](.github/docs/architecture.md)
+- [Implementing new SVG features](.github/docs/implementing-features.md)

From 47e6a891cf073c95d1d43546a935b078e295a100 Mon Sep 17 00:00:00 2001
From: Mathias Amnell <104110+Amnell@users.noreply.github.com>
Date: Sun, 24 May 2026 15:38:19 +0200
Subject: [PATCH 6/9] =?UTF-8?q?Implement=20patternTransform=20support;=20a?=
 =?UTF-8?q?dd=20pservers-grad-06-b=20(=E2=9C=85)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- SVGPattern.apply() now uses Canvas-based tiling when patternTransform != .identity
  Computes inverse-transform bounds to determine exact tile coverage; falls back
  to cheaper ImagePaint path for identity transforms
- Add pserversGrad06B test and reference file
---
 GenerateReferencesCLI/cli.swift               |  1 +
 Source/Model/Primitives/SVGPattern.swift      | 52 ++++++++++++++++--
 Tests/SVGViewTests/SVG11Tests.swift           |  1 +
 .../w3c/1.1F2/refs/pservers-grad-06-b.ref     | 53 +++++++++++++++++++
 4 files changed, 102 insertions(+), 5 deletions(-)
 create mode 100644 Tests/SVGViewTests/w3c/1.1F2/refs/pservers-grad-06-b.ref

diff --git a/GenerateReferencesCLI/cli.swift b/GenerateReferencesCLI/cli.swift
index 203f4256..e2ea79f2 100644
--- a/GenerateReferencesCLI/cli.swift
+++ b/GenerateReferencesCLI/cli.swift
@@ -77,6 +77,7 @@ struct cli: ParsableCommand {
         "pservers-grad-01-b",
         "pservers-grad-02-b",
         "pservers-grad-03-b",
+        "pservers-grad-06-b",
         "pservers-grad-04-b",
         "pservers-grad-05-b",
         "pservers-grad-07-b",
diff --git a/Source/Model/Primitives/SVGPattern.swift b/Source/Model/Primitives/SVGPattern.swift
index 378bdc92..6a1365af 100644
--- a/Source/Model/Primitives/SVGPattern.swift
+++ b/Source/Model/Primitives/SVGPattern.swift
@@ -35,15 +35,12 @@ public class SVGPattern: SVGPaint {
     @ViewBuilder
     func apply<S: View>(view: S, model: SVGShape? = nil) -> some View {
         if width > 0, height > 0, !contents.isEmpty, let cgImage = renderTile() {
-            let image = Image(decorative: cgImage, scale: 1.0)
             let bounds = model?.bounds() ?? .zero
+            let image = Image(decorative: cgImage, scale: 1.0)
             view
                 .foregroundColor(.clear)
                 .overlay(
-                    Rectangle()
-                        .fill(ImagePaint(image: image, scale: 1.0))
-                        .frame(width: bounds.width, height: bounds.height)
-                        .offset(x: bounds.minX, y: bounds.minY)
+                    tileView(image: image, bounds: bounds)
                         .mask(view)
                 )
         } else {
@@ -51,6 +48,51 @@ public class SVGPattern: SVGPaint {
         }
     }
 
+    @ViewBuilder
+    private func tileView(image: Image, bounds: CGRect) -> some View {
+        if patternTransform.isIdentity {
+            Rectangle()
+                .fill(ImagePaint(image: image, scale: 1.0))
+                .frame(width: bounds.width, height: bounds.height)
+                .offset(x: bounds.minX, y: bounds.minY)
+        } else {
+            // Canvas-based tiling: apply patternTransform to the drawing context so
+            // the tile grid is rendered in the transformed coordinate space.
+            Canvas { ctx, size in
+                ctx.concatenate(self.patternTransform)
+                // Compute how many tiles are needed to cover the shape bounds after
+                // the inverse transform is applied. Over-estimating is safe.
+                let inv = self.patternTransform.inverted()
+                let corners = [
+                    CGPoint(x: 0, y: 0),
+                    CGPoint(x: size.width, y: 0),
+                    CGPoint(x: 0, y: size.height),
+                    CGPoint(x: size.width, y: size.height),
+                ]
+                let transformed = corners.map { $0.applying(inv) }
+                let minX = transformed.map(\.x).min() ?? 0
+                let maxX = transformed.map(\.x).max() ?? size.width
+                let minY = transformed.map(\.y).min() ?? 0
+                let maxY = transformed.map(\.y).max() ?? size.height
+                let startCol = Int(floor(minX / self.width)) - 1
+                let endCol   = Int(ceil(maxX  / self.width)) + 1
+                let startRow = Int(floor(minY / self.height)) - 1
+                let endRow   = Int(ceil(maxY  / self.height)) + 1
+                let resolved = ctx.resolve(image)
+                for row in startRow...endRow {
+                    for col in startCol...endCol {
+                        ctx.draw(resolved, at: CGPoint(
+                            x: CGFloat(col) * self.width,
+                            y: CGFloat(row) * self.height
+                        ), anchor: .topLeading)
+                    }
+                }
+            }
+            .frame(width: bounds.width, height: bounds.height)
+            .offset(x: bounds.minX, y: bounds.minY)
+        }
+    }
+
     private func renderTile() -> CGImage? {
         let w = Int(ceil(width))
         let h = Int(ceil(height))
diff --git a/Tests/SVGViewTests/SVG11Tests.swift b/Tests/SVGViewTests/SVG11Tests.swift
index 77c6023e..ea7d30bd 100644
--- a/Tests/SVGViewTests/SVG11Tests.swift
+++ b/Tests/SVGViewTests/SVG11Tests.swift
@@ -106,6 +106,7 @@ struct SVG11Tests {
         @Test func pserversGrad02B() async throws { try await compareToReference("pservers-grad-02-b") }
         @Test func pserversGrad03B() async throws { try await compareToReference("pservers-grad-03-b") }
         @Test func pserversGrad04B() async throws { try await compareToReference("pservers-grad-04-b") }
+        @Test func pserversGrad06B() async throws { try await compareToReference("pservers-grad-06-b") }
         @Test func pserversGrad05B() async throws { try await compareToReference("pservers-grad-05-b") }
         @Test func pserversGrad07B() async throws { try await compareToReference("pservers-grad-07-b") }
         @Test func pserversGrad09B() async throws { try await compareToReference("pservers-grad-09-b") }
diff --git a/Tests/SVGViewTests/w3c/1.1F2/refs/pservers-grad-06-b.ref b/Tests/SVGViewTests/w3c/1.1F2/refs/pservers-grad-06-b.ref
new file mode 100644
index 00000000..d953fd9e
--- /dev/null
+++ b/Tests/SVGViewTests/w3c/1.1F2/refs/pservers-grad-06-b.ref
@@ -0,0 +1,53 @@
+SVGViewport {
+	id: "svg-root",
+	viewBox: { width: 480, height: 360 },
+	scaling: "none",
+	contents: [
+		SVGDefs {  },
+		SVGGroup {
+			id: "test-body-content",
+			contents: [
+				SVGRect { x: 20, y: 20, width: 440, height: 50 },
+				SVGText {
+					text: "scale(0.5) on gradient",
+					font: { name: "SVGFreeSansASCII,sans-serif", size: 30 },
+					fill: "black",
+					transform: [1, 0, 0, 1, 20, 100]
+				},
+				SVGRect { x: 20, y: 110, width: 440, height: 50 },
+				SVGText {
+					text: "skewX(45) on gradient",
+					font: { name: "SVGFreeSansASCII,sans-serif", size: 30 },
+					fill: "black",
+					transform: [1, 0, 0, 1, 20, 190]
+				},
+				SVGRect { x: 20, y: 210, width: 440, height: 50 },
+				SVGText {
+					text: "scale(2), skewX(45) on pattern",
+					font: { name: "SVGFreeSansASCII,sans-serif", size: 30 },
+					fill: "black",
+					transform: [1, 0, 0, 1, 20, 290]
+				}
+			]
+		},
+		SVGGroup {
+			contents: [
+				SVGText {
+					id: "revision",
+					text: "$Revision: 1.9 $",
+					font: { name: "SVGFreeSansASCII,sans-serif", size: 32 },
+					fill: "black",
+					transform: [1, 0, 0, 1, 10, 340]
+				}
+			]
+		},
+		SVGRect {
+			id: "test-frame",
+			x: 1,
+			y: 1,
+			width: 478,
+			height: 358,
+			stroke: { fill: "black" }
+		}
+	]
+}

From 626d33fbc70e93f0680748088738404f63c28ed5 Mon Sep 17 00:00:00 2001
From: Mathias Amnell <104110+Amnell@users.noreply.github.com>
Date: Sun, 24 May 2026 16:13:10 +0200
Subject: [PATCH 7/9] Fix radialGradient gradientTransform: store transform,
 render via CGBitmapContext

Previously the parser baked gradientTransform into cx/cy/r, which only worked
for uniform scale+translate and silently dropped skew/rotation (shear).

Changes:
- SVGRadialGradient now stores gradientTransform: CGAffineTransform (default .identity)
- Parser no longer transforms the gradient points; raw gradient-space cx/cy/fx/fy/r
  are preserved and gradientTransform is passed directly to the model
- SVGRadialGradient.apply() uses a CGBitmapContext path when gradientTransform is
  non-identity: sets up y-flip + shape-offset CTM, concatenates gradientTransform,
  then calls drawRadialGradient in gradient space so CoreGraphics handles the full
  affine deformation (translate, scale, skewX/Y, rotate, arbitrary matrix)
- Falls back to the existing SwiftUI RadialGradient path for identity transforms

Fixes the pservers-grad-06-b skewX(45) radial gradient rendering.
---
 Source/Model/Primitives/SVGGradient.swift | 83 ++++++++++++++++++-----
 Source/Parser/SVG/SVGIndex.swift          | 23 ++-----
 2 files changed, 71 insertions(+), 35 deletions(-)

diff --git a/Source/Model/Primitives/SVGGradient.swift b/Source/Model/Primitives/SVGGradient.swift
index 184557bb..f48faed6 100644
--- a/Source/Model/Primitives/SVGGradient.swift
+++ b/Source/Model/Primitives/SVGGradient.swift
@@ -101,19 +101,22 @@ public class SVGRadialGradient: SVGGradient {
     public let fx: CGFloat
     public let fy: CGFloat
     public let r: CGFloat
+    public let gradientTransform: CGAffineTransform
 
-    public init(cx: CGFloat = 0.5, cy: CGFloat = 0.5, fx: CGFloat = 0.5, fy: CGFloat = 0.5, r: CGFloat = 0.5, userSpace: Bool = false, stops: [SVGStop] = []) {
+    public init(cx: CGFloat = 0.5, cy: CGFloat = 0.5, fx: CGFloat = 0.5, fy: CGFloat = 0.5, r: CGFloat = 0.5,
+                userSpace: Bool = false, gradientTransform: CGAffineTransform = .identity, stops: [SVGStop] = []) {
         self.cx = cx
         self.cy = cy
         self.fx = fx
         self.fy = fy
         self.r = r
+        self.gradientTransform = gradientTransform
         super.init(
             userSpace: userSpace,
             stops: stops
         )
     }
-    
+
     #if canImport(SwiftUI)
     public func toSwiftUI(rect: CGRect) -> RadialGradient {
         let suiStops = stops.map { stop in Gradient.Stop(color: stop.color.toSwiftUI(), location: stop.offset) }
@@ -123,21 +126,69 @@ public class SVGRadialGradient: SVGGradient {
         return RadialGradient(gradient: Gradient(stops: suiStops), center: UnitPoint(x: ncx, y: ncy), startRadius: 0, endRadius: userSpace ? r : r * s)
     }
 
-    func apply<S>(view: S, model: SVGShape? = nil) -> some View where S : View {
-        let frame = model?.frame() ?? CGRect()
+    @ViewBuilder
+    func apply<S>(view: S, model: SVGShape? = nil) -> some View where S: View {
         let bounds = model?.bounds() ?? CGRect()
-        let width = bounds.width
-        let height = bounds.height
-        let minimum = min(width, height)
-        return view
-            .foregroundColor(.clear)
-            .overlay(
-                toSwiftUI(rect: frame)
-                    .scaleEffect(CGSize(width: userSpace ? 1 : width/minimum,
-                                        height: userSpace ? 1 : height/minimum))
-                    .offset(x: bounds.minX, y: bounds.minY)
-                    .mask(view)
-            )
+        let frame = model?.frame() ?? CGRect()
+        if !gradientTransform.isIdentity, let cgImage = renderGradientImage(shapeFrame: frame) {
+            let image = Image(decorative: cgImage, scale: 1.0)
+            view
+                .foregroundColor(.clear)
+                .overlay(
+                    image
+                        .resizable()
+                        .frame(width: bounds.width, height: bounds.height)
+                        .offset(x: bounds.minX, y: bounds.minY)
+                        .mask(view)
+                )
+        } else {
+            let minimum = min(bounds.width, bounds.height)
+            view
+                .foregroundColor(.clear)
+                .overlay(
+                    toSwiftUI(rect: frame)
+                        .scaleEffect(CGSize(width: userSpace ? 1 : bounds.width / minimum,
+                                            height: userSpace ? 1 : bounds.height / minimum))
+                        .offset(x: bounds.minX, y: bounds.minY)
+                        .mask(view)
+                )
+        }
+    }
+
+    private func renderGradientImage(shapeFrame: CGRect) -> CGImage? {
+        let w = Int(ceil(shapeFrame.width))
+        let h = Int(ceil(shapeFrame.height))
+        guard w > 0, h > 0 else { return nil }
+        let colorSpace = CGColorSpaceCreateDeviceRGB()
+        guard let context = CGContext(
+            data: nil, width: w, height: h,
+            bitsPerComponent: 8, bytesPerRow: 0,
+            space: colorSpace,
+            bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue
+        ) else { return nil }
+        // Flip y-axis so that y increases downward (matches SVG coordinate space)
+        context.translateBy(x: 0, y: CGFloat(h))
+        context.scaleBy(x: 1, y: -1)
+        // Translate so that the shape's SVG origin maps to the bitmap origin
+        context.translateBy(x: -shapeFrame.minX, y: -shapeFrame.minY)
+        // Apply gradientTransform: maps gradient space → SVG user space
+        context.concatenate(gradientTransform)
+        // Build CGGradient from stops
+        let cgColors = stops.map { stop in
+            CGColor(red: CGFloat(stop.color.r) / 255.0,
+                    green: CGFloat(stop.color.g) / 255.0,
+                    blue: CGFloat(stop.color.b) / 255.0,
+                    alpha: CGFloat(stop.color.a) / 255.0)
+        } as CFArray
+        let locations: [CGFloat] = stops.map(\.offset)
+        guard let cg = CGGradient(colorsSpace: colorSpace, colors: cgColors, locations: locations) else { return nil }
+        context.drawRadialGradient(
+            cg,
+            startCenter: CGPoint(x: fx, y: fy), startRadius: 0,
+            endCenter: CGPoint(x: cx, y: cy), endRadius: r,
+            options: [.drawsAfterEndLocation, .drawsBeforeStartLocation]
+        )
+        return context.makeImage()
     }
     #endif
 
diff --git a/Source/Parser/SVG/SVGIndex.swift b/Source/Parser/SVG/SVGIndex.swift
index 6c7f5ecd..ca08b3ee 100644
--- a/Source/Parser/SVG/SVGIndex.swift
+++ b/Source/Parser/SVG/SVGIndex.swift
@@ -181,27 +181,12 @@ class SVGIndex {
             userSpace = p.userSpace
         }
 
-        if let gradientTransform = element.attributes["gradientTransform"] {
-            let transform = SVGHelper.parseTransform(gradientTransform)
-
-            let point1 = CGPoint(x: cx, y: cy).applying(transform)
-            cx = point1.x
-            cy = point1.y
-
-            let xScale = abs(transform.a)
-            let yScale = abs(transform.d)
-            if xScale == yScale {
-                r *= xScale
-            } else {
-                print("SVG parsing error. No oval radial gradients supported")
-            }
-
-            let point2 = CGPoint(x: fx, y: fy).applying(transform)
-            fx = point2.x
-            fy = point2.y
+        var gradientTransform: CGAffineTransform = .identity
+        if let gradientTransformAttr = element.attributes["gradientTransform"] {
+            gradientTransform = SVGHelper.parseTransform(gradientTransformAttr)
         }
 
-        return SVGRadialGradient(cx: cx, cy: cy, fx: fx, fy: fy, r: r, userSpace: userSpace, stops: stops)
+        return SVGRadialGradient(cx: cx, cy: cy, fx: fx, fy: fy, r: r, userSpace: userSpace, gradientTransform: gradientTransform, stops: stops)
     }
 
     private func parseStops(_ nodes: [XMLNode], _ style: [String: String]) -> [SVGStop] {

From 4ee3623f62f670e9af30a91b975936250b48ac2b Mon Sep 17 00:00:00 2001
From: Mathias Amnell <104110+Amnell@users.noreply.github.com>
Date: Sun, 24 May 2026 16:36:32 +0200
Subject: [PATCH 8/9] Guide agents in how to export rendered PNGs for debugging

---
 AGENTS.md | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/AGENTS.md b/AGENTS.md
index 1ba06640..2b41b6f3 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -13,6 +13,21 @@ swift run GenerateReferencesCLI Tests/SVGViewTests/w3c   # regenerate .ref snaps
 
 Tests are snapshot-based: the parsed node tree is serialized to text and compared against a `.ref` file. The visual render is recorded as an attachment only — it does not assert.
 
+### Exporting rendered PNGs for debugging
+
+Pass `--attachments-path <dir>` to write all test attachments (rendered PNG, actual/expected text, diff) to a directory on disk:
+
+```bash
+mkdir -p /tmp/svgout
+swift test --filter <TestName> --attachments-path /tmp/svgout
+# Files written: <TestName>-rendered.png, <TestName>-actual.txt, <TestName>-expected.txt, <TestName>-diff.txt
+```
+
+To compare a rendered PNG against the W3C reference image, open the reference URL in a browser:
+```
+https://www.w3.org/Graphics/SVG/Test/20110816/png/<test-name>.png
+```
+
 ## Key Directories
 
 | Path | Purpose |

From e77ab960971de3ad6380a2a18887ea19c6dac47f Mon Sep 17 00:00:00 2001
From: Mathias Amnell <104110+Amnell@users.noreply.github.com>
Date: Sun, 24 May 2026 17:07:07 +0200
Subject: [PATCH 9/9] Fix tiling vertical shift in pservers-grad-06-b

---
 Source/Model/Primitives/SVGPattern.swift | 24 ++++++++++++++++--------
 1 file changed, 16 insertions(+), 8 deletions(-)

diff --git a/Source/Model/Primitives/SVGPattern.swift b/Source/Model/Primitives/SVGPattern.swift
index 6a1365af..0944069d 100644
--- a/Source/Model/Primitives/SVGPattern.swift
+++ b/Source/Model/Primitives/SVGPattern.swift
@@ -36,11 +36,12 @@ public class SVGPattern: SVGPaint {
     func apply<S: View>(view: S, model: SVGShape? = nil) -> some View {
         if width > 0, height > 0, !contents.isEmpty, let cgImage = renderTile() {
             let bounds = model?.bounds() ?? .zero
+            let frame  = model?.frame()  ?? .zero
             let image = Image(decorative: cgImage, scale: 1.0)
             view
                 .foregroundColor(.clear)
                 .overlay(
-                    tileView(image: image, bounds: bounds)
+                    tileView(image: image, bounds: bounds, shapeOrigin: frame.origin)
                         .mask(view)
                 )
         } else {
@@ -49,20 +50,27 @@ public class SVGPattern: SVGPaint {
     }
 
     @ViewBuilder
-    private func tileView(image: Image, bounds: CGRect) -> some View {
+    private func tileView(image: Image, bounds: CGRect, shapeOrigin: CGPoint = .zero) -> some View {
         if patternTransform.isIdentity {
             Rectangle()
                 .fill(ImagePaint(image: image, scale: 1.0))
                 .frame(width: bounds.width, height: bounds.height)
                 .offset(x: bounds.minX, y: bounds.minY)
         } else {
-            // Canvas-based tiling: apply patternTransform to the drawing context so
-            // the tile grid is rendered in the transformed coordinate space.
+            // patternTransform uses SVG user-space coordinates, but the Canvas
+            // coordinate system has its origin at the shape's top-left corner.
+            // Subtract the shape origin so tile positions are in Canvas-local space.
+            let localTransform = CGAffineTransform(
+                a: patternTransform.a, b: patternTransform.b,
+                c: patternTransform.c, d: patternTransform.d,
+                tx: patternTransform.tx - shapeOrigin.x,
+                ty: patternTransform.ty - shapeOrigin.y
+            )
             Canvas { ctx, size in
-                ctx.concatenate(self.patternTransform)
-                // Compute how many tiles are needed to cover the shape bounds after
-                // the inverse transform is applied. Over-estimating is safe.
-                let inv = self.patternTransform.inverted()
+                ctx.concatenate(localTransform)
+                // Compute tile coverage by inverse-transforming the canvas corners
+                // back into tile space. Over-estimating is safe.
+                let inv = localTransform.inverted()
                 let corners = [
                     CGPoint(x: 0, y: 0),
                     CGPoint(x: size.width, y: 0),