@mmerterden/multi-agent-pipeline 20.6.0 → 20.8.0

package/pipeline/skills/shared/external/pencilkit-drawing/evals/evals.json

@@ -3,41 +3,45 @@
   "evals": [
     {
       "id": 0,
-      "prompt": "I'm building a SwiftUI drawing screen for iPad with Apple Pencil and optional finger drawing. Sketch the PencilKit wrapper, tool picker setup, save/load path, and the lifecycle details that prevent stale tools or update loops.",
-      "expected_output": "A SwiftUI PencilKit implementation plan that wraps PKCanvasView, retains and observes PKToolPicker, chooses an appropriate drawingPolicy, serializes PKDrawing with dataRepresentation()/PKDrawing(data:), and avoids binding update loops.",
+      "name": "swiftui-sketch-pad",
+      "prompt": "I need a SwiftUI sketch pad for our iPad note app: a PencilKit canvas bound to a PKDrawing in our model, the tool palette toggled from a toolbar button, and the drawing saved to disk and restored on launch. Which input policy should we use, and how do we avoid update loops?",
+      "expected_output": "Builds a UIViewRepresentable with a Coordinator acting as PKCanvasViewDelegate that writes changes back to the binding. Keeps one PKToolPicker retained in the coordinator, adds the canvas as observer before showing it and makes the canvas first responder. Explains .default, .anyInput and .pencilOnly and picks one with a reason. Persists with dataRepresentation() and PKDrawing(data:), and only assigns the drawing in updateUIView when it differs.",
       "files": [],
       "expectations": [
-        "Wraps PKCanvasView with UIViewRepresentable and uses a Coordinator as PKCanvasViewDelegate.",
-        "Retains PKToolPicker outside a local scope and adds the canvas as an observer before showing the picker or becoming first responder.",
-        "Explains the difference between .default, .anyInput, and .pencilOnly enough to choose one for Pencil-primary versus finger-drawing modes.",
-        "Persists drawings using PKDrawing.dataRepresentation() and reloads with PKDrawing(data:).",
-        "Avoids SwiftUI update loops by checking whether the canvas drawing already matches the binding before assigning."
+        "Uses UIViewRepresentable with a Coordinator that implements canvasViewDrawingDidChange(_:)",
+        "Retains a single PKToolPicker and adds the canvas as observer before setVisible and becomeFirstResponder",
+        "Explains all three drawing policies, describing .default as following the system Pencil setting while the picker is visible",
+        "Saves with dataRepresentation() and loads with PKDrawing(data:)",
+        "Guards updateUIView with an inequality check to stop update loops"
       ]
     },
     {
       "id": 1,
-      "prompt": "Review this PencilKit compatibility plan: let users pick watercolor, crayon, and reed, save the PKDrawing bytes to CloudKit, and set canvasView.maximumSupportedContentVersion = .version2 so iPadOS 16 clients can open every drawing. What should change?",
-      "expected_output": "A correction-focused review that explains PencilKit content versions, unsupported-ink load failures, the need to set maximumSupportedContentVersion on both canvas and tool picker, and the version boundary for iPadOS 17 and iOS 26 inks.",
+      "name": "older-ipad-sync",
+      "prompt": "Teachers annotate worksheets on new iPads and students open them on iPads still running iPadOS 16. Students report that some worksheets fail to open. Our plan is to set maximumSupportedContentVersion to .version2 on the canvas. Review the plan.",
+      "expected_output": "Explains that inks newer than the recipient supports make loading fail, gives the full content version map (version1 pen/pencil/marker, version2 the iPadOS 17 inks, version3 barrel-roll data, version4 reed pen), and says .version2 does not help iPadOS 16, which needs .version1 or a verified fallback drawing. The cap must be set on both canvas and tool picker. Notes .reed needs 26 and curated picker items need iOS 18 or visionOS 2.",
       "files": [],
       "expectations": [
-        "States that unsupported newer inks cause older systems to fail when loading PKDrawing data rather than guaranteeing compatibility.",
-        "Correctly maps version1 to marker/pen/pencil-era compatibility, version2 to iPadOS 17 inks, version3 to barrel-roll angle data, and version4 to reed.",
-        "Explains that .version2 does not make drawings loadable by iPadOS 16 clients; use .version1 or a fallback for pre-iPadOS 17 compatibility.",
-        "Sets maximumSupportedContentVersion on both PKCanvasView and PKToolPicker when restricting new content.",
-        "Calls out .reed as iOS/iPadOS/macOS/visionOS 26+ and custom tool picker items as iOS/iPadOS 18+ or visionOS 2+."
+        "States that unsupported inks make older systems fail to load the drawing",
+        "Lists the four content versions with what each adds",
+        "Rejects .version2 for iPadOS 16 recipients and asks for .version1 or a checked fallback",
+        "Requires the cap on both PKCanvasView and PKToolPicker",
+        "Mentions .reed at 26 and PKToolPicker(toolItems:) at iOS 18 or visionOS 2"
       ]
     },
     {
       "id": 2,
-      "prompt": "I need an annotation experience with freehand Apple Pencil signatures, movable text boxes, arrows, image stickers, and a standard markup toolbar. Which parts should stay in PencilKit and when should I switch to PaperKit?",
-      "expected_output": "A boundary-aware answer that keeps freeform drawing, tool picker, stroke inspection, image export, and PKDrawing serialization in PencilKit while routing structured markup and toolbar needs to PaperKit.",
+      "name": "pencilkit-paperkit-split",
+      "prompt": "Product wants our inspection app to gain arrows, text callouts, photo stickers and a magnifier on top of the existing PencilKit signature and sketch features. What stays in PencilKit, what moves to PaperKit, and how do they connect?",
+      "expected_output": "PencilKit keeps the canvas, tool picker, PKDrawing persistence and export, stroke inspection and signatures. PaperKit takes shapes and arrows, text boxes, images and stickers, loupes and the markup toolbar. Connects them through PaperMarkupViewController.drawingTool accepting a PKTool and PaperMarkup appending a PKDrawing. Gives a step-by-step handoff plan without claiming PencilKit does structured markup.",
       "files": [],
       "expectations": [
-        "Keeps PencilKit scope to PKCanvasView, PKToolPicker, PKDrawing serialization/export, stroke inspection, and signature/freehand drawing.",
-        "Routes shapes, arrows, text boxes, images/stickers, loupes, and system-standard markup toolbar work to PaperKit.",
-        "Mentions the verified bridge points: PaperMarkupViewController.drawingTool accepts a PKTool and PaperMarkup can append PKDrawing.",
-        "Does not claim PencilKit directly owns structured markup elements such as movable text boxes or stickers.",
-        "Preserves a practical handoff plan between saved PKDrawing content and a PaperKit markup workflow."
+        "Keeps canvas, picker, serialization, export, stroke inspection and signatures in PencilKit",
+        "Moves arrows, text boxes, images or stickers, loupes and the markup toolbar to PaperKit",
+        "Mentions PaperMarkupViewController.drawingTool taking a PKTool",
+        "Mentions PaperMarkup accepting an appended PKDrawing",
+        "Does not claim PencilKit provides structured markup",
+        "Gives a concrete handoff plan"
       ]
     }
   ]

package/pipeline/skills/shared/external/pencilkit-drawing/references/pencilkit-patterns.md

@@ -1,333 +1,268 @@
-# PencilKit Extended Patterns
+# PencilKit patterns
 
-Overflow reference for the `pencilkit` skill. Contains advanced patterns
-that exceed the main skill file's scope.
+Longer recipes for the `pencilkit-drawing` skill ([../SKILL.md](../SKILL.md)).
 
-## Contents
+## Listening to the tool picker
 
-- [Tool Picker Observer Pattern](#tool-picker-observer-pattern)
-- [Custom Tool Picker Items](#custom-tool-picker-items)
-- [Canvas View Delegate Lifecycle](#canvas-view-delegate-lifecycle)
-- [Undo/Redo Support](#undoredo-support)
-- [Thumbnail Generation](#thumbnail-generation)
-- [Drawing Comparison and Scoring](#drawing-comparison-and-scoring)
-- [Content Version Management](#content-version-management)
-- [Advanced SwiftUI Wrapper](#advanced-swiftui-wrapper)
-
-## Tool Picker Observer Pattern
-
-Observe tool picker changes to update custom UI or track tool usage.
+Register your controller next to the canvas so both hear about changes.
 
 ```swift
 import PencilKit
-
-class DrawingController: UIViewController, PKToolPickerObserver {
-    let canvasView = PKCanvasView()
-    let toolPicker = PKToolPicker()
-
-    override func viewDidLoad() {
-        super.viewDidLoad()
-        toolPicker.addObserver(self)
-        toolPicker.addObserver(canvasView)
+import UIKit
+
+final class StudioViewController: UIViewController, PKToolPickerObserver {
+    private let board = PKCanvasView()
+    private let palette = PKToolPicker()
+
+    override func viewDidAppear(_ isAnimated: Bool) {
+        super.viewDidAppear(isAnimated)
+        palette.addObserver(board)
+        palette.addObserver(self)
+        palette.setVisible(true, forFirstResponder: board)
+        board.becomeFirstResponder()
     }
 
     func toolPickerSelectedToolItemDidChange(_ toolPicker: PKToolPicker) {
-        let item = toolPicker.selectedToolItem
-        print("Selected tool: \(item.identifier)")
+        let chosen = toolPicker.selectedToolItem.identifier
+        title = "Tool: \(chosen)"
     }
 
     func toolPickerVisibilityDidChange(_ toolPicker: PKToolPicker) {
-        print("Picker visible: \(toolPicker.isVisible)")
+        navigationController?.setToolbarHidden(toolPicker.isVisible, animated: true)
     }
 
     func toolPickerFramesObscuredDidChange(_ toolPicker: PKToolPicker) {
-        let obscured = toolPicker.frameObscured(in: view)
-        // Adjust content insets to avoid overlap
-        canvasView.contentInset.bottom = obscured.height
+        let covered = toolPicker.frameObscured(in: view)
+        board.contentInset.bottom = covered.isNull ? 0 : view.bounds.maxY - covered.minY
     }
 }
 ```
 
-## Custom Tool Picker Items
+The last callback keeps the bottom of the drawing reachable when the docked
+palette covers part of the screen.
 
-Create custom tools with unique behaviors and icons. Custom tool picker items
-require iOS/iPadOS 18+, Mac Catalyst 18+, or visionOS 2+.
+## A custom picker item
 
-```swift
-var customConfig = PKToolPickerCustomItem.Configuration(
-    identifier: "com.app.highlighter",
-    name: "Highlighter"
-)
-customConfig.defaultColor = .yellow
-customConfig.allowsColorSelection = true
-customConfig.defaultWidth = 20
-customConfig.widthVariants = [
-    10: UIImage(systemName: "line.diagonal")!,
-    20: UIImage(systemName: "line.3.horizontal")!,
-    40: UIImage(systemName: "rectangle.fill")!
-]
-customConfig.imageProvider = { item in
-    // Return a custom image based on current color/width
-    let config = UIImage.SymbolConfiguration(pointSize: 24)
-    return UIImage(systemName: "highlighter", withConfiguration: config)!
-}
+Requires iOS or iPadOS 18, visionOS 2, or Mac Catalyst 18.
 
-let customItem = PKToolPickerCustomItem(configuration: customConfig)
+```swift
+@available(iOS 18.0, visionOS 2.0, *)
+func makeStampPicker() -> PKToolPicker {
+    var setup = PKToolPickerCustomItem.Configuration(identifier: "com.example.stamp",
+                                                     name: "Stamp")
+    setup.defaultColor = .systemOrange
+    setup.allowsColorSelection = true
+    setup.defaultWidth = 24
+    setup.widthVariants = [
+        16: UIImage(systemName: "circle.fill") ?? UIImage(),
+        24: UIImage(systemName: "circle.circle.fill") ?? UIImage()
+    ]
+    setup.imageProvider = { item in
+        (UIImage(systemName: "seal.fill") ?? UIImage()).withTintColor(item.color)
+    }
 
-let toolPicker = PKToolPicker(toolItems: [
-    PKToolPickerInkingItem(type: .pen, color: .black, width: 5),
-    customItem,
-    PKToolPickerEraserItem(type: .vector)
-])
+    let stamp = PKToolPickerCustomItem(configuration: setup)
+    return PKToolPicker(toolItems: [
+        PKToolPickerInkingItem(type: .pen),
+        stamp,
+        PKToolPickerEraserItem(type: .bitmap)
+    ])
+}
 ```
 
-## Canvas View Delegate Lifecycle
-
-Track the complete drawing lifecycle.
+## Delegate lifecycle
 
 ```swift
-class DrawingManager: NSObject, PKCanvasViewDelegate {
-    var hasUnsavedChanges = false
-    var isCurrentlyDrawing = false
-
+extension StudioViewController: PKCanvasViewDelegate {
     func canvasViewDidBeginUsingTool(_ canvasView: PKCanvasView) {
-        isCurrentlyDrawing = true
+        autosaveTimer?.invalidate()           // user is mid-stroke
     }
 
     func canvasViewDidEndUsingTool(_ canvasView: PKCanvasView) {
-        isCurrentlyDrawing = false
+        scheduleAutosave()
     }
 
     func canvasViewDrawingDidChange(_ canvasView: PKCanvasView) {
-        hasUnsavedChanges = true
+        hasPendingChanges = true
     }
 
     func canvasViewDidFinishRendering(_ canvasView: PKCanvasView) {
-        // Safe to capture a snapshot for thumbnails
+        refreshPreviewTile()                  // rendering has settled; safe to snapshot
     }
 }
 ```
 
-## Undo/Redo Support
+`autosaveTimer`, `hasPendingChanges`, `scheduleAutosave()` and
+`refreshPreviewTile()` stand for the app's own state.
 
-`PKCanvasView` automatically integrates with `UndoManager`.
+## Undo and redo
+
+The canvas registers its edits with the responder chain's `UndoManager`, so
+buttons only need to forward (for example from `viewDidLoad()`):
 
 ```swift
-class DrawingViewController: UIViewController {
-    let canvasView = PKCanvasView()
-
-    override func viewDidLoad() {
-        super.viewDidLoad()
-        view.addSubview(canvasView)
-
-        navigationItem.leftBarButtonItem = UIBarButtonItem(
-            systemItem: .undo,
-            primaryAction: UIAction { [weak self] _ in
-                self?.canvasView.undoManager?.undo()
-            }
-        )
-        navigationItem.rightBarButtonItem = UIBarButtonItem(
-            systemItem: .redo,
-            primaryAction: UIAction { [weak self] _ in
-                self?.canvasView.undoManager?.redo()
-            }
-        )
-    }
+let stepBack = UIAction(title: "Undo", image: UIImage(systemName: "arrow.uturn.backward")) { [weak self] _ in
+    self?.board.undoManager?.undo()
+}
+let stepForward = UIAction(title: "Redo", image: UIImage(systemName: "arrow.uturn.forward")) { [weak self] _ in
+    self?.board.undoManager?.redo()
 }
+navigationItem.rightBarButtonItems = [
+    UIBarButtonItem(primaryAction: stepForward),
+    UIBarButtonItem(primaryAction: stepBack)
+]
 ```
 
-## Thumbnail Generation
-
-Generate thumbnails for document browsers or galleries.
+## Thumbnails with a fixed aspect ratio
 
 ```swift
-func generateThumbnail(
-    for drawing: PKDrawing,
-    size: CGSize,
-    scale: CGFloat = 2.0
-) -> UIImage? {
-    let bounds = drawing.bounds
-    guard !bounds.isEmpty else { return nil }
-
-    let aspectRatio = bounds.width / bounds.height
-    let targetAspect = size.width / size.height
-    var renderRect = bounds
-
-    if aspectRatio > targetAspect {
-        let scaleFactor = size.width / bounds.width
-        renderRect = CGRect(
-            x: bounds.minX,
-            y: bounds.midY - (size.height / scaleFactor) / 2,
-            width: bounds.width,
-            height: size.height / scaleFactor
-        )
+func tile(for sketch: PKDrawing, size: CGSize, scale: CGFloat) -> UIImage? {
+    let content = sketch.bounds
+    guard !content.isEmpty else { return nil }
+
+    let wanted = size.width / size.height
+    var frame = content
+    if content.width / content.height > wanted {
+        let width = content.height * wanted
+        frame = CGRect(x: content.midX - width / 2, y: content.minY,
+                       width: width, height: content.height)
     } else {
-        let scaleFactor = size.height / bounds.height
-        renderRect = CGRect(
-            x: bounds.midX - (size.width / scaleFactor) / 2,
-            y: bounds.minY,
-            width: size.width / scaleFactor,
-            height: bounds.height
-        )
+        let height = content.width / wanted
+        frame = CGRect(x: content.minX, y: content.midY - height / 2,
+                       width: content.width, height: height)
     }
-
-    return drawing.image(from: renderRect, scale: scale)
+    return sketch.image(from: frame, scale: scale)
 }
 ```
 
-## Drawing Comparison and Scoring
+## Scoring a tracing exercise
 
-Compare two drawings by analyzing their strokes and points.
+A simple similarity score: sample both drawings evenly, then count how many
+reference samples have an attempt sample nearby.
 
 ```swift
-func strokeSimilarity(
-    reference: PKDrawing,
-    candidate: PKDrawing,
-    tolerance: CGFloat = 20
-) -> Double {
-    let refPoints = reference.strokes.flatMap { stroke in
-        stroke.path.interpolatedPoints(by: .distance(5)).map(\.location)
-    }
-
-    let candPoints = candidate.strokes.flatMap { stroke in
-        stroke.path.interpolatedPoints(by: .distance(5)).map(\.location)
-    }
-
-    guard !refPoints.isEmpty else { return 0 }
-
-    var matchCount = 0
-    for refPoint in refPoints {
-        let minDist = candPoints.map { point in
-            hypot(refPoint.x - point.x, refPoint.y - point.y)
-        }.min() ?? .infinity
-
-        if minDist <= tolerance { matchCount += 1 }
+func tracingScore(target: PKDrawing, attempt: PKDrawing, radius: CGFloat = 20) -> Double {
+    func samples(_ drawing: PKDrawing) -> [CGPoint] {
+        drawing.strokes.flatMap { stroke in
+            let evenly = stroke.path.interpolatedPoints(by: .distance(5))
+            return evenly.map { $0.location.applying(stroke.transform) }
+        }
     }
-
-    return Double(matchCount) / Double(refPoints.count)
+    let wanted = samples(target)
+    let drawn = samples(attempt)
+    guard !wanted.isEmpty else { return 0 }
+
+    let hits = wanted.filter { goal in
+        drawn.contains { hypot($0.x - goal.x, $0.y - goal.y) <= radius }
+    }.count
+    return Double(hits) / Double(wanted.count)
 }
 ```
 
-## Content Version Management
+## Managing content versions
 
-Handle backward compatibility when sharing drawings across OS versions.
+The version map and the cap from the main skill, in one place:
 
 ```swift
-// Check if a drawing uses features beyond a version
-let drawing = canvasView.drawing
-let version = drawing.requiredContentVersion
-
-switch version {
-case .version1:
-    // iPadOS 14-era inks: marker, pen, pencil
-    break
-case .version2:
-    // iPadOS 17 inks: monoline, fountain pen, watercolor, crayon
-    break
-case .version3:
-    // Barrel-roll angle data
-    break
-case .version4:
-    // Reed pen
-    break
-@unknown default:
-    break
+func describe(_ sketch: PKDrawing) -> String {
+    switch sketch.requiredContentVersion {
+    case .version1: "pen, pencil, marker"
+    case .version2: "adds monoline, fountain pen, watercolor, crayon"
+    case .version3: "adds barrel-roll angles"
+    case .version4: "adds reed pen"
+    @unknown default: "unknown future content"
+    }
 }
 
-// Limit both canvas and picker to a specific version.
-// Use .version1 when saved drawings must load on pre-iPadOS 17 systems.
-if #available(iOS 17.0, *) {
-    canvasView.maximumSupportedContentVersion = .version1
-    toolPicker.maximumSupportedContentVersion = .version1
+@MainActor
+func limitToOldestClients(_ board: PKCanvasView, _ palette: PKToolPicker) {
+    if #available(iOS 17.0, *) {                // drawings must open before iPadOS 17
+        board.maximumSupportedContentVersion = .version1
+        palette.maximumSupportedContentVersion = .version1
+    }
 }
 ```
 
-When you allow newer inks, branch before CloudKit or cross-device sync and
-upload either the original drawing or a verified fallback drawing.
+### Deciding what to upload
+
+Before sending a drawing through CloudKit or any cross-device channel, decide
+what the oldest device will receive.
 
 ```swift
-func drawingForPreiPadOS17Sync(_ drawing: PKDrawing) -> PKDrawing? {
-    switch drawing.requiredContentVersion {
+func payloadForOldestDevice(_ sketch: PKDrawing) -> PKDrawing? {
+    switch sketch.requiredContentVersion {
     case .version1:
-        return drawing
+        return sketch
     case .version2, .version3, .version4:
-        let fallback = version1Fallback(from: drawing)
-        guard fallback.requiredContentVersion == .version1 else {
-            // Reusing paths can preserve newer metadata, such as barrel-roll data.
-            // Sync a thumbnail/message instead of incompatible drawing data.
-            return nil
+        let simplified = downgradedCopy(of: sketch)
+        guard simplified.requiredContentVersion == .version1 else {
+            return nil          // send a thumbnail or an explanation instead
         }
-        return fallback
+        return simplified
     @unknown default:
         return nil
     }
 }
 
-func version1Fallback(from drawing: PKDrawing) -> PKDrawing {
-    let strokes = drawing.strokes.map { stroke -> PKStroke in
-        var fallback = stroke
-        fallback.ink = PKInkingTool(.pen, color: .black, width: 2).ink
-        return fallback
+func downgradedCopy(of sketch: PKDrawing) -> PKDrawing {
+    let basicInk = PKInkingTool(.pen, color: .black, width: 4).ink
+    let strokes = sketch.strokes.map { original -> PKStroke in
+        var copy = original
+        copy.ink = PKInk(basicInk.inkType, color: original.ink.color)
+        return copy
     }
     return PKDrawing(strokes: strokes)
 }
 ```
 
-## Advanced SwiftUI Wrapper
+Swapping the ink is not always enough. The copied paths can still carry newer
+data such as barrel-roll angles, which is why the result is checked again
+before upload.
 
-A full-featured SwiftUI wrapper with tool picker, undo, and save support.
+## A configurable SwiftUI wrapper
 
 ```swift
-import SwiftUI
 import PencilKit
+import SwiftUI
 
-struct DrawingCanvas: UIViewRepresentable {
+struct SketchSurface: UIViewRepresentable {
     @Binding var drawing: PKDrawing
-    var drawingPolicy: PKCanvasViewDrawingPolicy = .anyInput
-    var showToolPicker: Bool = true
+    var policy: PKCanvasViewDrawingPolicy = .anyInput
+    var showsPalette = true
+
+    func makeCoordinator() -> Coordinator { Coordinator(drawing: $drawing) }
 
     func makeUIView(context: Context) -> PKCanvasView {
         let canvas = PKCanvasView()
-        canvas.delegate = context.coordinator
-        canvas.drawingPolicy = drawingPolicy
-        canvas.drawing = drawing
         canvas.backgroundColor = .clear
         canvas.isOpaque = false
-
-        let coordinator = context.coordinator
-        coordinator.toolPicker.addObserver(canvas)
-
+        canvas.drawingPolicy = policy
+        canvas.drawing = drawing
+        canvas.delegate = context.coordinator
+        context.coordinator.palette.addObserver(canvas)
         return canvas
     }
 
-    func updateUIView(_ canvas: PKCanvasView, context: Context) {
-        let coordinator = context.coordinator
-
-        if canvas.drawing != drawing {
-            canvas.drawing = drawing
-        }
-
-        coordinator.toolPicker.setVisible(showToolPicker, forFirstResponder: canvas)
-        if showToolPicker {
-            canvas.becomeFirstResponder()
-        }
+    func updateUIView(_ uiView: PKCanvasView, context: Context) {
+        uiView.drawingPolicy = policy
+        if uiView.drawing != drawing { uiView.drawing = drawing }
+        let palette = context.coordinator.palette
+        palette.setVisible(showsPalette, forFirstResponder: uiView)
+        if showsPalette { uiView.becomeFirstResponder() }
     }
 
-    func makeCoordinator() -> Coordinator {
-        Coordinator(parent: self)
-    }
+    final class Coordinator: NSObject, PKCanvasViewDelegate {
+        let palette = PKToolPicker()
+        private let drawing: Binding<PKDrawing>
 
-    class Coordinator: NSObject, PKCanvasViewDelegate {
-        let parent: DrawingCanvas
-        let toolPicker = PKToolPicker()
-
-        init(parent: DrawingCanvas) {
-            self.parent = parent
-        }
+        init(drawing: Binding<PKDrawing>) { self.drawing = drawing }
 
         func canvasViewDrawingDidChange(_ canvasView: PKCanvasView) {
-            parent.drawing = canvasView.drawing
+            drawing.wrappedValue = canvasView.drawing
         }
     }
 }
 ```
+
+The clear background lets the surface sit over a photo, a PDF page or a
+paper texture.