Added missing features to SwiftDraw

.github/workflows/build.yml

@@ -27,6 +27,22 @@ jobs:
           token: ${{ secrets.CODECOV_TOKEN }}
           files: ./coverage_report.lcov
 
+  # Apps ship optimized builds: SD12's floods were transparent under -O while every Debug job passed
+  xcode_release:
+    runs-on: macos-26
+    timeout-minutes: 20
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Select the newest Xcode
+        run: echo "DEVELOPER_DIR=$(ls -d /Applications/Xcode_*.app | sort -V | tail -1)/Contents/Developer" >> "$GITHUB_ENV"
+      - name: Version
+        run: swift --version
+      - name: Build
+        run: swift build -c release --build-tests -Xswiftc -enable-testing
+      - name: Test
+        run: swift test -c release --skip-build -Xswiftc -enable-testing
+
   xcode_26_2:
     runs-on: macos-26
     env:

CLAUDE.md

@@ -0,0 +1,55 @@
+# CLAUDE.md — Misoservices/SwiftDraw (Backdrop's fork)
+
+This is a fork of [swhitty/SwiftDraw](https://github.com/swhitty/SwiftDraw) (zlib licence) kept by Misoservices
+for **Backdrop / MisoScape**, an Apple-platform app that draws user-placed SVG motifs through SwiftDraw's
+CoreGraphics renderer. The fork exists to render the SVG that real editors (Inkscape, Illustrator, Figma) emit
+and that SwiftDraw 0.29.0 drops or draws wrong. The work list is **[Backdrop/ROADMAP.md](Backdrop/ROADMAP.md)**;
+every session takes exactly one item from it.
+
+## Build and test
+
+- `swift build --build-tests && swift test --skip-build` — works on Linux (Swift 6.0–6.3) and macOS.
+- **Also run the tests optimized:** `swift test -c release -Xswiftc -enable-testing`. Apps ship Release builds,
+  and SD12's floods were transparent under `-O` while every Debug job passed; CI's `xcode_release` job runs it.
+- **Cloud sessions run on Linux, where CoreGraphics does not exist.** Everything under
+  `#if canImport(CoreGraphics)` is neither compiled nor tested there. The fork's GitHub Actions (`build.yml`)
+  runs macOS 26 / Xcode 26.6, four Linux toolchains and Windows on every push: **push your branch early and
+  treat a green macOS job as the only proof that CoreGraphics code compiles and passes.** If you cannot read the
+  CI result from the session, say so in the PR description rather than claiming it passed.
+- If `swift` is missing, install a Linux toolchain (swiftly, or the swift.org tarball for 6.2+) and report the
+  exact commands you used in the PR so the environment's setup script can adopt them.
+
+## How the code is laid out (read before changing anything)
+
+- `DOM/Sources/` — XML → `DOM.*` model (`Parser.XML.*.swift`). Platform-independent.
+- `SwiftDraw/Sources/LayerTree/` — DOM → `LayerTree` (`LayerTree.Builder*.swift`), then
+  `LayerTree.CommandGenerator` turns layers into a flat stream of `RendererCommand`s
+  (`SwiftDraw/Sources/Renderer/Renderer.swift`). Platform-independent and the best place to test.
+- Renderers execute commands: `Renderer.CoreGraphics.swift` (the one Backdrop uses), `Renderer.CGText*.swift`
+  (Swift code generation), `Renderer.SFSymbol*.swift`, `Renderer.SVG.swift`, `Renderer.LayerTree.swift`.
+  **A new `RendererCommand` case must be handled by every renderer**: implement it for CoreGraphics and CGText;
+  elsewhere implement it or degrade deliberately (and say which in the PR).
+- Tests: `SwiftDraw/Tests/` (XCTest; `Renderer/MockRenderer.swift` records command streams — assert on those so
+  the test runs on Linux), `DOM/Tests/`. `Samples.bundle/` holds sample SVGs.
+
+## Rules
+
+1. **One roadmap item per branch and PR.** Branch `sd<N>-<slug>` (e.g. `sd1-dasharray`) from `main`; open the PR
+   against `Misoservices/SwiftDraw` `main`, never against upstream. Keep the diff to the item: no reformatting, no
+   drive-by refactors, so each PR can later be offered upstream on its own.
+2. **Never fail the whole document for one bad attribute.** SwiftDraw today throws on many legal-but-unexpected
+   values and the entire drawing vanishes. The fork's direction: drop the attribute (use the spec default), keep
+   the document. Never introduce a new throw path for input an editor could plausibly produce.
+3. **Follow the SVG 1.1 spec (SVG 2 where editors already emit it), and cite the section** you implemented in
+   the PR description. When the spec and browsers disagree, match Chrome/Safari and say so.
+4. **Tests are the deliverable.** Every behaviour gets a test asserting on the DOM, the LayerTree or the
+   `MockRenderer` command stream (Linux-runnable), plus a CoreGraphics test where pixels matter (macOS CI).
+   Add a small sample SVG to `Samples.bundle/` for each visible feature.
+5. Match the surrounding code: 4-space indentation, upstream's naming and file layout, the existing licence
+   header on new files. Add new enum cases and `switch` arms at the end to keep parallel branches mergeable.
+6. **Do not edit `Backdrop/ROADMAP.md`** — several sessions run in parallel and it would conflict. Put status,
+   decisions, spec citations and anything left undone in the PR description; the integrator updates the roadmap.
+7. zlib licence clause 2: altered versions must be plainly marked. Keep the notice at the top of `README.md`;
+   never remove or alter the licence header of an existing file.
+8. Performance matters: Backdrop renders motifs while the user drags sliders. Anything that allocates an offscreen
+   bitmap (filters) must size it to the filter region in device pixels, not the whole canvas.

DOM/Sources/DOM.Color.swift

@@ -31,7 +31,7 @@
 
 package extension DOM {
 
-    enum Color: Equatable {
+    enum Color: Hashable {
         case none
         case currentColor
         case keyword(Keyword)
@@ -189,6 +189,8 @@ package extension DOM {
             case whitesmoke
             case yellow
             case yellowgreen
+            // CSS Color 4
+            case rebeccapurple
         }
     }
 }
@@ -345,6 +347,7 @@ package extension DOM.Color.Keyword {
         case .whitesmoke: return (245, 245, 245)
         case .yellow: return (255, 255, 0)
         case .yellowgreen: return (154, 205, 50)
+        case .rebeccapurple: return (102, 51, 153)
         }
     }
 }

DOM/Sources/DOM.Element.swift

@@ -50,6 +50,10 @@ package extension DOM {
 
         package var attributes = PresentationAttributes()
         package var style = PresentationAttributes()
+        // stylesheet declarations matched at parse time; nil for elements built in code
+        package var matchedStyle: StyleSheet.Matched?
+        // style="" declarations marked !important
+        package var importantStyle = PresentationAttributes()
     }
 
     final class Line: GraphicsElement {

DOM/Sources/DOM.Filter.swift

@@ -34,15 +34,141 @@ package extension DOM {
     final class Filter: Element {
         package var id: String
 
-        package var effects: [Effect]
+        // one per filter primitive, in document order (SD12)
+        package var primitives: [Primitive]
+
+        package var effects: [Effect] {
+            primitives.map(\.effect)
+        }
+
+        package var x: DOM.Coordinate?
+        package var y: DOM.Coordinate?
+        package var width: DOM.Coordinate?
+        package var height: DOM.Coordinate?
+        package var filterUnits: Units?
+        package var primitiveUnits: Units?
 
         package init(id: String) {
             self.id = id
-            self.effects = []
+            self.primitives = []
         }
 
         package enum Effect: Hashable {
-            case gaussianBlur(stdDeviation: DOM.Float)
+            // stdDeviationY is nil when stdDeviation has a single value
+            case gaussianBlur(stdDeviation: DOM.Float, stdDeviationY: DOM.Float? = nil)
+
+            // a filter primitive SwiftDraw cannot render yet
+            case unsupported(name: String)
+
+            // Filter Effects 1 §9.18 feOffset, in primitiveUnits
+            case offset(dx: DOM.Float, dy: DOM.Float)
+
+            // Filter Effects 1 §9.13 feFlood: currentColor is resolved while parsing
+            case flood(color: DOM.Color, opacity: DOM.Float)
+
+            // Filter Effects 1 §9.8 feComposite: `in` composited onto `in2`
+            case composite(CompositeOperator)
+
+            // Filter Effects 1 §9.16 feMerge: the inputs are the <feMergeNode> children
+            case merge
+
+            // Filter Effects 1 §9.5 feBlend: `in` blended onto `in2`
+            case blend(BlendMode)
+
+            // Filter Effects 1 §9.6 feColorMatrix
+            case colorMatrix(ColorMatrix)
+        }
+
+        // A filter primitive with its wiring (Filter Effects 1 §9.2 in / in2 / result) and subregion (§9.4)
+        package struct Primitive: Hashable {
+            package var effect: Effect
+
+            // `in` then `in2`, or one per <feMergeNode>; nil where the attribute is missing
+            package var inputs: [Input?]
+            package var result: String?
+
+            // primitive subregion in primitiveUnits: user units, or fractions of the bounding box;
+            // nil takes the default subregion
+            package var x: DOM.Coordinate?
+            package var y: DOM.Coordinate?
+            package var width: DOM.Coordinate?
+            package var height: DOM.Coordinate?
+
+            // the computed color-interpolation-filters, inherited from the <filter> and its ancestors
+            package var colorInterpolation: ColorInterpolation
+
+            package init(effect: Effect,
+                         inputs: [Input?] = [],
+                         result: String? = nil,
+                         colorInterpolation: ColorInterpolation = .linearRGB) {
+                self.effect = effect
+                self.inputs = inputs
+                self.result = result
+                self.colorInterpolation = colorInterpolation
+            }
+        }
+
+        package enum Input: Hashable {
+            case sourceGraphic
+            case sourceAlpha
+            case backgroundImage
+            case backgroundAlpha
+            case fillPaint
+            case strokePaint
+            case result(String)
+        }
+
+        package enum CompositeOperator: Hashable {
+            case over
+            case `in`
+            case out
+            case atop
+            case xor
+            // Filter Effects 1: the sum of both inputs
+            case lighter
+            // result = k1·i1·i2 + k2·i1 + k3·i2 + k4 on premultiplied values
+            case arithmetic(k1: DOM.Float, k2: DOM.Float, k3: DOM.Float, k4: DOM.Float)
+        }
+
+        // Compositing and Blending 1 §10 blend modes
+        package enum BlendMode: String, Hashable {
+            case normal
+            case multiply
+            case screen
+            case overlay
+            case darken
+            case lighten
+            case colorDodge = "color-dodge"
+            case colorBurn = "color-burn"
+            case hardLight = "hard-light"
+            case softLight = "soft-light"
+            case difference
+            case exclusion
+            case hue
+            case saturation
+            case color
+            case luminosity
+        }
+
+        package enum ColorMatrix: Hashable {
+            // 20 values, row-major 4x5; any other count is a pass through
+            case matrix([DOM.Float])
+            case saturate(DOM.Float)
+            // degrees
+            case hueRotate(DOM.Float)
+            case luminanceToAlpha
+        }
+
+        // Filter Effects 1 §10 color-interpolation-filters
+        package enum ColorInterpolation: String, Hashable {
+            case auto
+            case sRGB
+            case linearRGB
+        }
+
+        package enum Units: String {
+            case userSpaceOnUse
+            case objectBoundingBox
         }
     }
 }

DOM/Sources/DOM.Image.swift

@@ -36,6 +36,7 @@ package extension DOM {
 
         package var x: Coordinate?
         package var y: Coordinate?
+        package var preserveAspectRatio: PreserveAspectRatio?
 
         package init(href: URL) {
             self.href = href

DOM/Sources/DOM.LinearGradient.swift

@@ -41,15 +41,15 @@ package extension DOM {
 
         package var stops: [Stop]
         package var gradientUnits: Units?
-        package var gradientTransform: [Transform]
+        package var gradientTransform: [Transform]?
+        package var spreadMethod: SpreadMethod?
 
         //references another LinearGradient element id within defs
         package var href: URL?
 
         package init(id: String) {
             self.id = id
             self.stops = []
-            self.gradientTransform = []
         }
 
         package struct Stop: Equatable {
@@ -83,4 +83,11 @@ package extension DOM.LinearGradient {
         case userSpaceOnUse
         case objectBoundingBox
     }
+
+    // SVG 1.1 §13.2.2
+    enum SpreadMethod: String {
+        case pad
+        case reflect
+        case `repeat`
+    }
 }

DOM/Sources/DOM.Pattern.swift

@@ -38,15 +38,23 @@ package extension DOM {
         package var id: String
         package var x: Coordinate?
         package var y: Coordinate?
-        package var width: Coordinate
-        package var height: Coordinate
+        package var width: Coordinate?
+        package var height: Coordinate?
 
         package var patternUnits: Units?
         package var patternContentUnits: Units?
 
         package var childElements: [DOM.GraphicsElement] = []
 
-        package init(id: String, width: Coordinate, height: Coordinate) {
+        package var href: URL?
+        package var viewBox: DOM.SVG.ViewBox?
+        package var preserveAspectRatio: DOM.PreserveAspectRatio?
+        package var patternTransform: [Transform]?
+        /// Names of the x / y / width / height attributes written as percentages; their value
+        /// is stored as a fraction and resolved against the viewport under userSpaceOnUse.
+        package var percentageAttributes: Set<String> = []
+
+        package init(id: String, width: Coordinate? = nil, height: Coordinate? = nil) {
             self.id = id
             self.width = width
             self.height = height