Generate, 그리고 Stamp

    /// Step two, after Dad reads the prompt. Ember's automatic route is resolved and
    /// pinned here; a tier that bills by use is never sent until Dad confirms that
    /// exact provider (`confirmed`). A submission is never retried by itself.
    func submitPro(_ draft: ProDraft, confirmed: String? = nil) {
        guard let row = proProvider else { return note("Ember's Pro catalog is not loaded.") }
        proDraft = nil
        let aspect = proAspect(for: draft.source)
        let quality = "auto"
        proPhase = .generating("Preparing")
        Task {
            do {
                var provider = row.id, label = row.label, size = settings.proImageSize
                if !proImageSizes.contains(size) { size = row.defaultImageSize ?? proImageSizes.first ?? "auto" }
                if row.isRoute {
                    let route = try await client.proRoute(JSONBody(["image_size": size, "aspect_ratio": aspect,
                                                                    "reference_count": draft.references.count, "quality": quality]))
                    let billing = route.billing ?? proOptions?.provider(route.provider)?.billing ?? "unclassified"
                    if !Self.unmeteredBilling.contains(billing), confirmed != route.provider {
                        proPhase = .idle
                        proConfirmation = ProConfirmation(draft: draft, provider: route.provider,
                                                          label: route.label ?? route.provider, billing: billing)
                        return
                    }
                    // …
            } catch {
                jobs.removeAll { $0.kind == .pro }
                // Never resubmitted: Ember may have billed it even when the answer was lost.
                proPhase = .failed("Pro Generate did not finish: \(error.localizedDescription) Nothing was retried.")
            }

/// Popovers and sheets over the canvas.
enum CanvasPanel: String, Identifiable {
    case brushes, colors, layers, actions, pippa, generate, fill, adjustments, more

    var id: String { rawValue }

    /// Pippa and Generate sit beside the canvas on iPad: painting goes on with them
    /// open (Generate's Auto follows the strokes), so a stroke or a tool never closes them.
    var isDocked: Bool { self == .pippa || self == .generate }
}

// …

    /// Starts a stroke with the tool in hand, or with `fingerTool` for a
    /// finger set to smudge or erase (Procreate's Smudge and Erase "Touch").
    func beginStroke(fingerTool: GestureControls.FingerTool? = nil) -> Bool {
        if panel?.isDocked != true { panel = nil }
        // …

    var settings: GenerationSettings {
        didSet {
            settings.save(to: defaults)
            // Turning Auto on makes a preview at once, as Cinder does.
            if settings.auto, !oldValue.auto { scheduleAuto(delay: .zero) }
        }
    }
    // …
    var isPanelOpen = false { didSet { if isPanelOpen { scheduleAuto() } } }
    // …

    /// The artwork changed (a committed stroke, never mid-stroke): Auto makes a new preview.
    func noteChange() {
        guard settings.auto, isPanelOpen else { return }
        scheduleAuto()
    }

    private func scheduleAuto(delay: Duration = .seconds(1.2)) {
        guard settings.auto, isPanelOpen else { return }
        autoTask?.cancel()
        autoTask = Task { [weak self] in
            try? await Task.sleep(for: delay)
            guard !Task.isCancelled, let self else { return }
            // No prompt yet: Ember describes the drawing first.
            if !self.hasPrompt {
                guard await self.describeNow(), self.hasPrompt else { return }
            }
            self.preview()
        }
    }

    private func preview() {
        guard let model, let source = captureSource() else { return }
        // Cinder's unchanged-preview guard: the same picture is not sent again.
        guard source.jpeg != lastAutoSource else { return }
        lastAutoSource = source.jpeg
        previewRevision += 1
        let revision = previewRevision
        // …