agentix-cli 0.90.0 → 0.91.1

package/apps/mac-voice/Sources/AgentXVoice/Character.swift

@@ -0,0 +1,152 @@
+import AppKit
+
+/// The character (#458): the orb grown into a small creature, in the
+/// agent's palette, with two eyes, no mouth and no legs. It hovers above
+/// the bottom edge of the screen, shows what the assistant is doing, and
+/// gets out of the pointer's way. Chosen with `voice.look`; the orb stays
+/// the default.
+///
+/// It reacts and never interrupts: its window takes no clicks and no
+/// keys, and never comes forward by itself. With Reduce Motion on, or
+/// "Animated orb" off in the menu, it is a still picture that changes
+/// between states and stays where it rests.
+@MainActor
+final class CharacterHost {
+    /// The body's width in points, and the room around it for its marks
+    /// and for the dots it leaves behind.
+    private static let diameter: CGFloat = 56
+    private static let size = NSSize(width: 440, height: 150)
+    /// The edge it hovers above, from the bottom of its window.
+    private static let ground: CGFloat = 8
+
+    private let window: NSPanel
+    private let view = CharacterView(frame: NSRect(origin: .zero, size: CharacterHost.size))
+    private var sim = CharacterSim(unit: Double(CharacterHost.diameter) / 100)
+    private var timer: Timer?
+    private var motionObserver: NSObjectProtocol?
+
+    private var shown = false
+    private var animated = true
+    private var reduceMotion = NSWorkspace.shared.accessibilityDisplayShouldReduceMotion
+    private var activity = CharacterMath.Activity.idle
+    private var level = 0.0
+    /// The microphone's RMS level, read while listening. Set by the app.
+    var levelSource: (() -> Float)?
+    /// Where the pointer is, in screen coordinates.
+    var pointerSource: () -> NSPoint = { NSEvent.mouseLocation }
+
+    init() {
+        window = NSPanel(contentRect: NSRect(origin: .zero, size: Self.size),
+                         styleMask: [.borderless, .nonactivatingPanel], backing: .buffered, defer: false)
+        window.isFloatingPanel = true
+        window.level = .floating
+        window.collectionBehavior = [.canJoinAllSpaces, .fullScreenAuxiliary, .stationary]
+        window.isOpaque = false
+        window.backgroundColor = .clear
+        window.hasShadow = false
+        window.hidesOnDeactivate = false
+        window.ignoresMouseEvents = true
+        window.contentView = view
+        view.unit = Self.diameter / 100
+        view.edge = CGPoint(x: Self.size.width / 2, y: Self.size.height - Self.ground)
+        motionObserver = NSWorkspace.shared.notificationCenter.addObserver(
+            forName: NSWorkspace.accessibilityDisplayOptionsDidChangeNotification,
+            object: nil, queue: .main) { [weak self] _ in
+            MainActor.assumeIsolated {
+                guard let self else { return }
+                self.reduceMotion = NSWorkspace.shared.accessibilityDisplayShouldReduceMotion
+                self.run()
+            }
+        }
+    }
+
+    /// `voice.look` is "character", or not.
+    func setShown(_ on: Bool) {
+        guard shown != on else { return }
+        shown = on
+        if on { sim = CharacterSim(unit: Double(Self.diameter) / 100) }
+        run()
+    }
+
+    /// "Animated orb" in the menu.
+    func setAnimated(_ on: Bool) {
+        guard animated != on else { return }
+        animated = on
+        run()
+    }
+
+    /// Show what the pill shows, in `colors` or in shades of `tint`.
+    func show(_ activity: CharacterMath.Activity, tint: NSColor, colors: [NSColor]?) {
+        self.activity = activity
+        view.stops = CharacterDraw.stops(tint: tint, colors: colors)
+        if shown && timer == nil { tick() }
+    }
+
+    /// The frames run only while it is on screen and may move.
+    private func run() {
+        timer?.invalidate()
+        timer = nil
+        guard shown else { window.orderOut(nil); return }
+        tick()
+        window.orderFrontRegardless()
+        guard animated, !reduceMotion else { return }
+        timer = Timer.scheduledTimer(withTimeInterval: 1.0 / 30, repeats: true) { [weak self] _ in
+            MainActor.assumeIsolated { self?.tick() }
+        }
+        // Keeps moving while a menu is open or the pill is dragged.
+        if let timer { RunLoop.main.add(timer, forMode: .common) }
+    }
+
+    private func tick() {
+        // The screen with the menu bar, less the menu bar and the Dock.
+        guard let screen = NSScreen.screens.first else { return }
+        let visible = screen.visibleFrame
+        // It rests beside the pill's own corner, so they read as one, and
+        // goes no further right: stepping aside never puts it on the pill.
+        let left = Double(visible.minX + 44)
+        let home = max(Double(visible.maxX - PillPlacement.inset - Panel.size.width - 52), left)
+        let range = left...home
+
+        let frame: CharacterSim.Frame
+        if timer == nil {
+            frame = CharacterSim.still(activity, home: home)
+        } else {
+            if activity == .listening, let read = levelSource {
+                level = OrbMath.smooth(level, toward: OrbMath.level(fromRMS: read()))
+            } else {
+                level = 0
+            }
+            let mouse = pointerSource()
+            let pointer = screen.frame.contains(mouse) ? (x: Double(mouse.x), y: Double(mouse.y - visible.minY)) : nil
+            frame = sim.step(to: ProcessInfo.processInfo.systemUptime,
+                             CharacterSim.Input(activity: activity, level: level, pointer: pointer, home: home, range: range))
+        }
+        let origin = NSPoint(x: (CGFloat(frame.x) - Self.size.width / 2).rounded(), y: visible.minY - Self.ground)
+        if window.frame.origin != origin { window.setFrameOrigin(origin) }
+        view.origin = origin.x
+        view.shown = frame
+        view.needsDisplay = true
+    }
+}
+
+/// The character's drawing surface. Flipped, so the drawing's y grows
+/// downwards as in the pose sheet it was ported from.
+final class CharacterView: NSView {
+    var shown = CharacterSim.Frame()
+    var stops = CharacterDraw.stops(tint: Brand.accent, colors: nil)
+    var unit: CGFloat = 0.56
+    /// Under the character, in this view; and the view's left edge on screen.
+    var edge = CGPoint.zero
+    var origin: CGFloat = 0
+
+    override var isFlipped: Bool { true }
+    override func hitTest(_ point: NSPoint) -> NSView? { nil }
+
+    override func draw(_ dirtyRect: NSRect) {
+        guard let ctx = NSGraphicsContext.current?.cgContext else { return }
+        // The body is drawn where the window is, which follows the frame
+        // to the nearest point; the rest of the way is drawn here.
+        let at = CGPoint(x: CGFloat(shown.x) - origin, y: edge.y)
+        CharacterDraw.draw(shown, in: ctx, edge: at, origin: origin, unit: unit, stops: stops)
+    }
+}

package/apps/mac-voice/Sources/AgentXVoice/CharacterDraw.swift

@@ -0,0 +1,218 @@
+import AppKit
+
+/// One frame of the character, drawn in code like the orb: one drawing,
+/// every palette. The context is flipped (y grows downwards) and scaled so
+/// the body is 100 across, with the origin on the edge under the character.
+enum CharacterDraw {
+    typealias Frame = CharacterSim.Frame
+
+    private static let ink = NSColor(srgbRed: 0.059, green: 0.133, blue: 0.2, alpha: 1)
+    private static let radius: CGFloat = 50
+
+    /// Five stops, deep to light: the agent's palette, or shades of `tint`
+    /// without one (an error, held notifications, an older daemon).
+    static func stops(tint: NSColor, colors: [NSColor]?) -> [NSColor] {
+        if let colors, colors.count == 5 { return colors }
+        let base = tint.usingColorSpace(.sRGB) ?? tint
+        return [base.blended(withFraction: 0.45, of: .black), base.blended(withFraction: 0.2, of: .black), base,
+                base.blended(withFraction: 0.35, of: .white), base.blended(withFraction: 0.7, of: .white)].map { $0 ?? base }
+    }
+
+    /// Draw `frame`. `edge` is the point under the character and `unit`
+    /// the points per drawing unit; the marks are placed from `origin`,
+    /// the screen position of the context's left edge.
+    static func draw(_ frame: Frame, in ctx: CGContext, edge: CGPoint, origin: CGFloat, unit: CGFloat, stops c: [NSColor]) {
+        let pose = frame.pose
+        let sx = CGFloat(pose.sx), sy = CGFloat(pose.sy), lift = CGFloat(pose.lift)
+        let turned = CGFloat(abs(frame.face)), way: CGFloat = frame.face >= 0 ? 1 : -1
+
+        // Trail dots and stars stay where they were left, on the screen.
+        for m in frame.dots + frame.stars {
+            ctx.saveGState()
+            ctx.translateBy(x: CGFloat(m.x) - origin, y: edge.y - CGFloat(m.y))
+            ctx.scaleBy(x: unit, y: unit)
+            ctx.setFillColor(c[m.shade].withAlphaComponent(CGFloat(m.alpha)).cgColor)
+            let r = CGFloat(m.r)
+            if m.turn == 0 {
+                ctx.fillEllipse(in: CGRect(x: -r, y: -r, width: 2 * r, height: 2 * r))
+            } else {
+                ctx.rotate(by: CGFloat(m.turn) * .pi / 180)
+                let star = CGMutablePath()
+                star.move(to: CGPoint(x: 0, y: -r))
+                for p in [CGPoint(x: r, y: 0), CGPoint(x: 0, y: r), CGPoint(x: -r, y: 0), CGPoint(x: 0, y: -r)] {
+                    star.addQuadCurve(to: p, control: .zero)
+                }
+                ctx.addPath(star)
+                ctx.fillPath()
+            }
+            ctx.restoreGState()
+        }
+
+        ctx.saveGState()
+        ctx.translateBy(x: edge.x, y: edge.y)
+        ctx.scaleBy(x: unit, y: unit)
+
+        // Its shadow on the edge, smaller the higher it hovers.
+        let shadow = 34 * (1 - min(lift, 30) / 60)
+        ctx.setFillColor(ink.withAlphaComponent(0.13).cgColor)
+        ctx.fillEllipse(in: CGRect(x: -shadow, y: 0, width: 2 * shadow, height: 10))
+
+        let middle = -lift - radius * sy
+        marks(frame, in: ctx, middle: middle, stops: c)
+
+        ctx.translateBy(x: 0, y: -lift)
+        ctx.rotate(by: CGFloat(pose.tilt) * .pi / 180)
+        let cy = -radius * sy
+
+        // The body: a soft glow, the palette from light (top left) to
+        // deep, a rim so it reads on a pale wallpaper, and a highlight.
+        let space = CGColorSpace(name: CGColorSpace.sRGB)!
+        ctx.saveGState()
+        ctx.translateBy(x: 0, y: cy)
+        ctx.scaleBy(x: sx, y: sy)
+        let glow = CGGradient(colorsSpace: space, colors: [c[2].withAlphaComponent(0.34).cgColor, c[2].withAlphaComponent(0).cgColor] as CFArray,
+                              locations: [0.6, 1])!
+        ctx.drawRadialGradient(glow, startCenter: .zero, startRadius: 0, endCenter: .zero, endRadius: radius + 20, options: [])
+        let body = CGRect(x: -radius, y: -radius, width: 2 * radius, height: 2 * radius)
+        ctx.saveGState()
+        ctx.addEllipse(in: body)
+        ctx.clip()
+        let fill = CGGradient(colorsSpace: space, colors: [c[4], c[3], c[2], c[1], c[0]].map(\.cgColor) as CFArray,
+                              locations: [0, 0.28, 0.58, 0.84, 1])!
+        let light = CGPoint(x: -14, y: -20)
+        ctx.drawRadialGradient(fill, startCenter: light, startRadius: 0, endCenter: light, endRadius: 78,
+                               options: [.drawsAfterEndLocation])
+        ctx.restoreGState()
+        ctx.setStrokeColor(c[0].withAlphaComponent(0.4).cgColor)
+        ctx.setLineWidth(1.5)
+        ctx.strokeEllipse(in: body.insetBy(dx: 0.75, dy: 0.75))
+        ctx.translateBy(x: -17, y: -24)
+        ctx.rotate(by: -24 * .pi / 180)
+        ctx.setFillColor(NSColor.white.withAlphaComponent(0.35).cgColor)
+        ctx.fillEllipse(in: CGRect(x: -13, y: -8, width: 26, height: 16))
+        ctx.restoreGState()
+
+        // Turned, both eyes move to that side and the far one narrows.
+        let ey = cy + 2 * sy
+        let gaze = CGPoint(x: CGFloat(pose.gx), y: CGFloat(pose.gy))
+        eye(in: ctx, at: CGPoint(x: (15 + 18 * turned) * sx * way, y: ey), pose, gaze: gaze, width: 1 - 0.38 * turned)
+        eye(in: ctx, at: CGPoint(x: (-15 + 26 * turned) * sx * way, y: ey), pose, gaze: gaze, width: 1)
+        ctx.restoreGState()
+    }
+
+    /// One eye. As it closes, the eyeball fades into the curve of the shut
+    /// eye, so one look turns into another without a jump.
+    private static func eye(in ctx: CGContext, at p: CGPoint, _ pose: CharacterMath.Pose, gaze: CGPoint, width w: CGFloat) {
+        let open = CGFloat(pose.open), s = CGFloat(pose.size), lid = CGFloat(pose.lid), curve = CGFloat(pose.curve)
+        let k = min(max(open, 0) / 0.3, 1)
+        if k > 0 {
+            let c = CGPoint(x: p.x + gaze.x, y: p.y + gaze.y)
+            let rx = 6.5 * s * w, ry = 9.5 * s * max(open, 0.04)
+            let top = c.y - ry + 2 * ry * lid  // what shows below the eyelid
+            ctx.saveGState()
+            ctx.clip(to: CGRect(x: c.x - rx - 1, y: top, width: 2 * rx + 2, height: 2 * ry + 1))
+            ctx.setFillColor(ink.withAlphaComponent(k).cgColor)
+            ctx.fillEllipse(in: CGRect(x: c.x - rx, y: c.y - ry, width: 2 * rx, height: 2 * ry))
+            ctx.restoreGState()
+            if lid > 0.02 {
+                let half = rx * max(1 - pow((top - c.y) / ry, 2), 0).squareRoot() + 1.5 * w
+                line(in: ctx, [CGPoint(x: c.x - half, y: top), CGPoint(x: c.x + half, y: top)],
+                     ink.withAlphaComponent(k * min(lid * 4, 1)), width: 2.6)
+            }
+            let shine = k * max(1 - lid * 2.5, 0) * min(max(open * 2 - 0.6, 0), 1)
+            ctx.setFillColor(NSColor.white.withAlphaComponent(shine).cgColor)
+            let r = 2.2 * s * w
+            ctx.fillEllipse(in: CGRect(x: c.x, y: c.y - 3.4 * s * open - r, width: 2 * r, height: 2 * r))
+        }
+        if k < 1 {
+            let shut = CGMutablePath()
+            shut.move(to: CGPoint(x: p.x - 7 * w, y: p.y + 1.5 + 1.5 * curve))
+            shut.addQuadCurve(to: CGPoint(x: p.x + 7 * w, y: p.y + 1.5 + 1.5 * curve),
+                              control: CGPoint(x: p.x, y: p.y - 0.5 - 7.5 * curve))
+            ctx.addPath(shut)
+            ctx.setStrokeColor(ink.withAlphaComponent(1 - k).cgColor)
+            ctx.setLineWidth(3.2)
+            ctx.setLineCap(.round)
+            ctx.strokePath()
+        }
+    }
+
+    /// The marks beside it, each with a loop of its own: voice rings, the
+    /// arcs of its own voice, thinking dots, sleep letters, call rings and
+    /// the question. `middle` is the height of the middle of its body.
+    private static func marks(_ frame: Frame, in ctx: CGContext, middle: CGFloat, stops c: [NSColor]) {
+        let pose = frame.pose, t = frame.t
+        func beat(_ rate: Double, _ i: Int) -> CGFloat { CGFloat(0.5 + 0.5 * sin(2 * .pi * (rate * t - Double(i) * 0.22))) }
+        /// Arcs opening away from the body on `side`, swelling one after the other.
+        func arcs(_ n: Int, side: CGFloat, x: CGFloat, y: CGFloat, strength: CGFloat, rate: Double, _ color: NSColor) {
+            guard strength > 0.01 else { return }
+            for i in 0..<n {
+                let b = beat(rate, i), r = 9 + CGFloat(i) * 9 + 2 * b
+                let arc = CGMutablePath()
+                arc.addArc(center: CGPoint(x: x, y: y), radius: r, startAngle: -.pi / 2, endAngle: .pi / 2, clockwise: side < 0)
+                ctx.addPath(arc)
+                ctx.setStrokeColor(color.withAlphaComponent(strength * (0.85 - CGFloat(i) * 0.25) * (0.35 + 0.65 * b)).cgColor)
+                ctx.setLineWidth(3)
+                ctx.setLineCap(.round)
+                ctx.strokePath()
+            }
+        }
+        // Listening: the rings follow your voice.
+        arcs(3, side: -1, x: -78, y: middle, strength: CGFloat(pose.hear * (0.45 + 0.55 * frame.level)), rate: 1.7, c[2])
+        // Speaking: its own voice goes out the other way.
+        arcs(3, side: 1, x: 74, y: middle - 8, strength: CGFloat(frame.voice), rate: 2.1, c[2])
+        // An agent is calling: it rings on both sides.
+        arcs(2, side: 1, x: 76, y: middle - 20, strength: CGFloat(pose.ring), rate: 2.4, c[1])
+        arcs(2, side: -1, x: -76, y: middle - 20, strength: CGFloat(pose.ring), rate: 2.4, c[1])
+
+        // Working: three dots that hop in turn.
+        let think = CGFloat(pose.think)
+        if think > 0.01 {
+            for i in 0..<3 {
+                let hop = CGFloat(max(sin(2 * .pi * (1.1 * t - Double(i) * 0.2)), 0)), r = (4 + CGFloat(i) * 1.6) * think
+                ctx.setFillColor(c[1].withAlphaComponent(think * (0.45 + CGFloat(i) * 0.25)).cgColor)
+                ctx.fillEllipse(in: CGRect(x: 62 + CGFloat(i) * 17 - r, y: middle - 8 - CGFloat(i) * 9 - 6 * hop - r, width: 2 * r, height: 2 * r))
+            }
+        }
+
+        // Dozing: each z rises, grows and fades.
+        if pose.sleep > 0.01 {
+            let life = 2.4, every = 1.2
+            for j in max(Int(((t - life) / every).rounded(.down)) + 1, 0)...Int((t / every).rounded(.down)) {
+                let a = (t - Double(j) * every) / life
+                guard a >= 0, a < 1 else { continue }
+                text("z", in: ctx, at: CGPoint(x: 50 + 24 * a + 5 * sin(5 * a), y: Double(middle) - 16 - 40 * a),
+                     size: 13 + 9 * a, c[1].withAlphaComponent(CGFloat(pose.sleep * 0.9 * sin(.pi * a))))
+            }
+        }
+
+        // Needs your answer: a question that grows out of it and waits.
+        let ask = CGFloat(pose.ask)
+        if ask > 0.01 {
+            let r = 15 * ask, bob = CGFloat(2 * sin(2 * .pi * t / 1.8))
+            let at = CGPoint(x: 64, y: middle - 44 - bob)
+            let bubble = CGRect(x: at.x - r, y: at.y - r, width: 2 * r, height: 2 * r)
+            ctx.setFillColor(NSColor.white.withAlphaComponent(ask).cgColor)
+            ctx.fillEllipse(in: bubble)
+            ctx.setStrokeColor(c[0].withAlphaComponent(ask).cgColor)
+            ctx.setLineWidth(2.5)
+            ctx.strokeEllipse(in: bubble)
+            text("?", in: ctx, at: CGPoint(x: at.x - 5.5 * ask, y: at.y - 12 * ask), size: Double(20 * ask), c[0].withAlphaComponent(ask))
+        }
+    }
+
+    private static func line(in ctx: CGContext, _ points: [CGPoint], _ color: NSColor, width: CGFloat) {
+        ctx.setStrokeColor(color.cgColor)
+        ctx.setLineWidth(width)
+        ctx.setLineCap(.round)
+        ctx.strokeLineSegments(between: points)
+    }
+
+    /// Bold text with its top-left corner at `at`.
+    private static func text(_ s: String, in ctx: CGContext, at: CGPoint, size: Double, _ color: NSColor) {
+        NSGraphicsContext.saveGraphicsState()
+        NSGraphicsContext.current = NSGraphicsContext(cgContext: ctx, flipped: true)
+        (s as NSString).draw(at: at, withAttributes: [.font: NSFont.systemFont(ofSize: size, weight: .bold), .foregroundColor: color])
+        NSGraphicsContext.restoreGraphicsState()
+    }
+}

package/apps/mac-voice/Sources/AgentXVoice/CharacterMath.swift

@@ -0,0 +1,145 @@
+import Foundation
+
+/// The numbers behind the character (#458): the orb grown into a small
+/// creature. Kept free of AppKit so the tests can check them without a
+/// window.
+///
+/// Nothing snaps. A state is a small set of numbers (stretch, lean,
+/// height, gaze, eyes, and how strong each mark is), so going from any
+/// state to any other is a blend of those numbers. Lengths are in the
+/// drawing's own units: the body is 100 across.
+enum CharacterMath {
+    /// What the character shows: the nine states of the pose sheet.
+    enum Mood: String, CaseIterable {
+        case idle, notices, listening, working, speaking, understood, dozing, calling, asking
+    }
+
+    /// What the assistant is doing: the pill's states without their words.
+    enum Activity { case idle, listening, thinking, speaking, ringing, waiting }
+
+    /// The state shown for what the assistant is doing. Noticing, the nod
+    /// and dozing are not activities: the character passes through them
+    /// (`passing`) or settles into them with time.
+    static func mood(for activity: Activity) -> Mood {
+        switch activity {
+        case .idle: return .idle
+        case .listening: return .listening
+        case .thinking: return .working
+        case .speaking: return .speaking
+        case .ringing: return .calling
+        case .waiting: return .asking
+        }
+    }
+
+    /// The state it goes through on the way from `from` to `to`, if any:
+    /// it notices you before it listens and when it wakes, and nods once
+    /// it has heard you.
+    static func passing(from: Mood, to: Mood) -> Mood? {
+        if from == .dozing { return .notices }
+        if from == .idle && to == .listening { return .notices }
+        if from == .listening && to == .working { return .understood }
+        return nil
+    }
+
+    /// Seconds a passing state is held before moving on.
+    static func hold(_ mood: Mood) -> Double { mood == .understood ? 0.9 : 0.45 }
+
+    /// Seconds to get into a state. It settles into sleep slowly.
+    static func duration(into mood: Mood) -> Double {
+        switch mood {
+        case .dozing: return 1.8
+        case .notices, .understood: return 0.3
+        default: return 0.5
+        }
+    }
+
+    struct Pose: Equatable {
+        // Body: stretch, lean in degrees, height above the edge.
+        var sx = 1.0, sy = 1.0, tilt = 0.0, lift = 14.0
+        // Eyes: gaze, how open (1 open, 0 shut), size, eyelid, and the
+        // curve of the shut eye (1 a smile, -1 asleep).
+        var gx = 0.0, gy = 0.0, open = 1.0, size = 1.0, lid = 0.0, curve = 0.0
+        // Marks, 0…1: voice rings, thinking dots, speech arcs, sleep
+        // letters, call rings, the question.
+        var hear = 0.0, think = 0.0, speak = 0.0, sleep = 0.0, ring = 0.0, ask = 0.0
+    }
+
+    static func pose(_ mood: Mood) -> Pose {
+        switch mood {
+        case .idle: return Pose()
+        case .notices: return Pose(sx: 0.94, sy: 1.08, lift: 18, gy: -3, size: 1.22)
+        case .listening: return Pose(tilt: -9, gx: -2, gy: -1, hear: 1)
+        case .working: return Pose(sx: 1.03, sy: 0.96, gx: -4, gy: 5, lid: 0.5, think: 1)
+        case .speaking: return Pose(sx: 0.97, sy: 1.04, lift: 16, gy: -1, speak: 1)
+        case .understood: return Pose(sx: 1.07, sy: 0.9, lift: 8, open: 0, curve: 1)
+        case .dozing: return Pose(sx: 1.14, sy: 0.8, lift: 3, open: 0, curve: -1, sleep: 1)
+        case .calling: return Pose(sx: 0.95, sy: 1.06, lift: 20, size: 1.22, ring: 1)
+        case .asking: return Pose(tilt: 11, gx: 3, gy: -3, ask: 1)
+        }
+    }
+
+    /// `a` towards `b`: the eyes, the body and the marks each by their own
+    /// amount, so the eyes can lead and the body follow.
+    static func blend(_ a: Pose, _ b: Pose, eyes: Double, body: Double, marks: Double) -> Pose {
+        func mix(_ x: Double, _ y: Double, _ p: Double) -> Double { x + (y - x) * p }
+        return Pose(sx: mix(a.sx, b.sx, body), sy: mix(a.sy, b.sy, body),
+                    tilt: mix(a.tilt, b.tilt, body), lift: mix(a.lift, b.lift, body),
+                    gx: mix(a.gx, b.gx, eyes), gy: mix(a.gy, b.gy, eyes),
+                    open: mix(a.open, b.open, eyes), size: mix(a.size, b.size, eyes),
+                    lid: mix(a.lid, b.lid, eyes), curve: mix(a.curve, b.curve, eyes),
+                    hear: mix(a.hear, b.hear, marks), think: mix(a.think, b.think, marks),
+                    speak: mix(a.speak, b.speak, marks), sleep: mix(a.sleep, b.sleep, marks),
+                    ring: mix(a.ring, b.ring, marks), ask: mix(a.ask, b.ask, marks))
+    }
+
+    /// One change of state. The eyes go first and are there by half time;
+    /// the body follows a moment later, with weight.
+    struct Transition {
+        var from: Pose
+        var to: Pose
+        var start: Double
+        var duration: Double
+
+        func pose(at t: Double) -> Pose {
+            blend(from, to,
+                  eyes: ease(span(t, start, start + duration * 0.5)),
+                  body: swing(span(t, start + duration * 0.15, start + duration * 1.25)),
+                  marks: ease(span(t, start, start + duration)))
+        }
+    }
+
+    /// Slow start, slow stop.
+    static func ease(_ p: Double) -> Double {
+        let p = min(max(p, 0), 1)
+        return p * p * (3 - 2 * p)
+    }
+
+    /// How far `t` is between `a` and `b`, 0…1.
+    static func span(_ t: Double, _ a: Double, _ b: Double) -> Double {
+        min(max((t - a) / (b - a), 0), 1)
+    }
+
+    /// Like `ease`, with weight: a small wind-up before it goes and a
+    /// small overshoot before it settles.
+    static func swing(_ p: Double, back: Double = 1) -> Double {
+        let p = min(max(p, 0), 1), c = back * 1.525
+        if p < 0.5 { return pow(2 * p, 2) * ((c + 1) * 2 * p - c) / 2 }
+        return (pow(2 * p - 2, 2) * ((c + 1) * (2 * p - 2) + c) + 2) / 2
+    }
+
+    /// The same "random" number 0…1 for the same `n`, so the marks are
+    /// the same on every run and the tests can count on them.
+    static func rnd(_ n: Int, _ salt: Int = 0) -> Double {
+        let v = sin(Double(n) * 12.9898 + Double(salt) * 78.233) * 43758.5453
+        return v - v.rounded(.down)
+    }
+
+    /// Where it goes to get out of the pointer's way: `clear` to the side
+    /// it is already on, or to the other side when the screen ends there.
+    static func aside(x: Double, pointer: Double, clear: Double, range: ClosedRange<Double>) -> Double {
+        let side: Double = x >= pointer ? 1 : -1
+        let there = pointer + side * clear
+        if range.contains(there) { return there }
+        return min(max(pointer - side * clear, range.lowerBound), range.upperBound)
+    }
+}