dsh-notch 0.3.1 → 0.3.6

package/macos/Sources/StatusOrbit.swift

@@ -1,642 +0,0 @@
-import SwiftUI
-import AppKit
-import CoreText
-
-struct OrbitLayout: Equatable {
-  var top: Double = 0
-  var middle: Double = 0
-  var bottom: Double = 0
-  var decision: Double = 0
-  var total: Double { top+middle+bottom+decision }
-  var height: CGFloat { 20+28*max(0,total-1) }
-  var middleY: CGFloat { 10+28*(top+max(0,decision+middle-1)) }
-  var bottomY: CGFloat { height-10 }
-  static func mix(_ a:Self,_ b:Self,_ t:Double)->Self {
-    Self(top:a.top+(b.top-a.top)*t,middle:a.middle+(b.middle-a.middle)*t,bottom:a.bottom+(b.bottom-a.bottom)*t,decision:a.decision+(b.decision-a.decision)*t)
-  }
-  static func flight(from a:Self,to b:Self,progress:Double,flight:StatusFlight)->Self {
-    let growth=OrbitMotionFrame.ease(progress/0.48)
-    var result=mix(a,b,growth)
-    if !flight.returnsToRunning {
-      let source=OrbitMotionFrame(progress:progress,failed:flight.failed,returns:false,angle:flight.angle).sourceOpacity
-      // Existing result: close the vacated slot as ink leaves it. A new result
-      // first needs room for its drawn circle, then releases the source slot.
-      let remaining=flight.destinationBefore > 0 ? source:1-OrbitMotionFrame.ease((progress-0.72)/0.28)
-      result.middle=max(a.middle,1)*remaining
-    }
-    return result
-  }
-}
-
-enum StatusOutcome {
-  case success, failure, decision
-  var rgb: (Double, Double, Double) {
-    switch self {
-    case .success: (0.204, 0.780, 0.349)
-    case .failure: (1.0, 0.251, 0.0)
-    case .decision: (0.949, 1.0, 0.078)
-    }
-  }
-  var color: Color { let c=rgb; return Color(red:c.0,green:c.1,blue:c.2) }
-}
-
-struct StatusFlight: Identifiable {
-  let id = UUID()
-  let outcome: StatusOutcome
-  var failed: Bool { outcome == .failure }
-  var decision: Bool { outcome == .decision }
-  let startedAt: Date
-  let busyBefore: Int
-  let destinationBefore: Int
-  let returnsToRunning: Bool
-  let angle: Double
-  init(failed: Bool, startedAt: Date, busyBefore: Int, destinationBefore: Int, returnsToRunning: Bool = true, angle:Double? = nil) {
-    self.init(outcome:failed ? .failure:.success,startedAt:startedAt,busyBefore:busyBefore,destinationBefore:destinationBefore,returnsToRunning:returnsToRunning,angle:angle)
-  }
-  init(outcome: StatusOutcome, startedAt: Date, busyBefore: Int, destinationBefore: Int, returnsToRunning: Bool = true, angle:Double? = nil) {
-    self.outcome = outcome
-    self.startedAt = startedAt
-    self.busyBefore = busyBefore
-    self.destinationBefore = destinationBefore
-    self.returnsToRunning = returnsToRunning
-    self.angle=angle ?? startedAt.timeIntervalSinceReferenceDate*2 * .pi/3
-  }
-  static let duration: TimeInterval = 0.95
-}
-
-/// A reply returns the same task to the running lamp. It owns a clock so
-/// polling and panel folding cannot reset its ink, count, or layout progress.
-struct DecisionReturn: Identifiable {
-  let id = UUID()
-  let startedAt: Date
-  let busyBefore: Int
-  let from: OrbitLayout
-  let angle: Double
-  var travelling: Bool { from.middle > 0.001 || from.top > 0.001 }
-  var duration: Double { travelling ? StatusFlight.duration:DecisionMorph.resumeDuration }
-  func progress(at now:Date)->Double { min(1,max(0,now.timeIntervalSince(startedAt)/duration)) }
-}
-
-struct DecisionReturnFrame {
-  let progress: Double
-  let distance: CGFloat
-  let tailLength: CGFloat
-  let tint: Double
-  let fill: Double
-  let strokeOpacity: Double
-  let countMix: Double
-  let collapse: Double
-  let baseRingOpacity: Double
-  init(progress:Double,angle:Double) {
-    let p=min(1,max(0,progress));self.progress=p
-    let route=OrbitBrushRoute(failed:false,angle:angle)
-    let u=min(1,max(0,(p-0.14)/0.86))
-    let span=route.total-route.resultDrawn
-    let terminal=9.5*DecisionSpin.runningVelocity*StatusFlight.duration*0.86/span
-    let paced=(3*u*u-2*u*u*u)+terminal*(u*u*u-u*u)
-    distance=route.resultDrawn+span*paced
-    let leaving=OrbitMotionFrame.ease((distance-route.resultDrawn)/max(1,route.returned-route.resultDrawn))
-    let joined=OrbitMotionFrame.ease((distance-route.returned)/max(1,route.total-route.returned))
-    tailLength=(2 * .pi*9.5)+(18-2 * .pi*9.5)*leaving+(route.departure-18)*joined
-    tint=1-leaving
-    fill=1-OrbitMotionFrame.ease(p/0.28)
-    strokeOpacity=OrbitMotionFrame.ease(p/0.14)
-    countMix=joined
-    collapse=OrbitMotionFrame.ease((p-0.35)/0.65)
-    // The existing ring keeps rotating while the incoming tip approaches it;
-    // the travelling trail becomes that same ring at the final phase/velocity.
-    baseRingOpacity=1-OrbitMotionFrame.ease((leaving-0.55)/0.45)
-  }
-}
-
-struct DecisionReturnStroke: Shape {
-  let frame:DecisionReturnFrame
-  let angle:Double
-  let gap:CGFloat
-  func path(in rect:CGRect)->Path {
-    let route=OrbitBrushRoute(failed:false,angle:angle,gap:gap)
-    let original=OrbitBrushRoute(failed:false,angle:angle)
-    let source=[original.arrival,original.resultDrawn,original.returned,original.total]
-    let target=[route.arrival,route.resultDrawn,route.returned,route.total]
-    func mapped(_ d:CGFloat)->CGFloat {
-      for i in 1..<source.count where d <= source[i] {
-        return target[i-1]+(target[i]-target[i-1])*(d-source[i-1])/max(0.00001,source[i]-source[i-1])
-      }
-      return route.total
-    }
-    return route.path(in:mapped(frame.distance-frame.tailLength)...mapped(frame.distance))
-      .offsetBy(dx:rect.midX,dy:rect.midY)
-  }
-}
-
-struct OrbitMotionFrame {
-  let progress: Double
-  let failed: Bool
-  let returns: Bool
-  let distance: CGFloat
-  let tailLength: CGFloat
-  let tint: Double
-  let resultOpacity: Double
-  let sourceOpacity: Double
-  let arrived: Bool
-  let returning: Bool
-  let returned: Bool
-  static func ease(_ value: Double) -> Double {
-    let t = min(1, max(0, value))
-    return t * t * (3 - 2 * t)
-  }
-  private static func pacedHead(_ t:Double,_ values:[CGFloat])->CGFloat {
-    let times=[0.0,0.18,0.56,0.94,1.0]
-    func slope(_ i:Int)->CGFloat {
-      guard i > 0 && i < 4 else { return 0 }
-      let a=(values[i]-values[i-1])/(times[i]-times[i-1])
-      let b=(values[i+1]-values[i])/(times[i+1]-times[i])
-      return a*b > 0 ? 2*a*b/(a+b):0
-    }
-    let i=(0..<4).first { t <= times[$0+1] } ?? 3
-    let dt=times[i+1]-times[i],u=min(1,max(0,(t-times[i])/dt)),u2=u*u,u3=u2*u
-    return (2*u3-3*u2+1)*values[i]+(u3-2*u2+u)*dt*slope(i)+(-2*u3+3*u2)*values[i+1]+(u3-u2)*dt*slope(i+1)
-  }
-  init(progress: Double, failed: Bool, returns: Bool, angle: Double = 0) {
-    self.progress = min(1, max(0, progress))
-    self.failed = failed
-    self.returns = returns
-    let route = OrbitBrushRoute(failed: failed, angle: angle)
-    let end = returns ? route.total : route.resultDrawn + 18
-    let u=self.progress
-    let terminal=9.5*DecisionSpin.runningVelocity*StatusFlight.duration/(end-route.departure)
-    let paced=(3*u*u-2*u*u*u)+terminal*(u-3*u*u+2*u*u*u)
-    let head = returns ? route.departure + (end - route.departure) * paced : Self.pacedHead(self.progress,[route.departure,route.sourceExit,route.arrival,route.resultDrawn,route.resultDrawn+18])
-    distance = min(head, returns ? route.total : route.resultDrawn)
-    let outbound = Self.ease((head - route.sourceExit) / (route.arrival - route.sourceExit))
-    let inbound = Self.ease((head - route.resultDrawn + 8) / (route.returned - route.resultDrawn + 16))
-    let tintStart = max(route.departure, route.sourceExit - 8)
-    let outgoingTint = Self.ease((head - tintStart) / (route.arrival + 8 - tintStart))
-    tint = returns && head > route.resultDrawn - 8 ? 1 - inbound : outgoingTint
-    resultOpacity = Self.ease((head - route.arrival - 0.55 * (route.resultDrawn - route.arrival)) / (0.35 * (route.resultDrawn - route.arrival)))
-    arrived = resultOpacity > 0
-    returning = returns && head > route.resultDrawn
-    returned = returns && head >= route.returned
-    sourceOpacity = returns ? 1 : 1 - outbound
-    if head < route.arrival { tailLength = route.departure + (18 - route.departure) * outbound }
-    else if !returns && head > route.resultDrawn { tailLength = max(0, 18 - (head - route.resultDrawn)) }
-    else if head > route.returned {
-      let t = (head - route.returned) / (route.total - route.returned)
-      tailLength = 18 + (route.departure - 18) * (3*t*t-2*t*t*t)
-    } else { tailLength = 18 }
-  }
-}
-
-/// An arc-length trail: the head draws forward and the tail follows on the same route.
-struct OrbitBrushRoute {
-  private(set) var points: [CGPoint] = []
-  private(set) var lengths: [CGFloat] = []
-  private(set) var departure: CGFloat = 0
-  private(set) var sourceExit: CGFloat = 0
-  private(set) var arrival: CGFloat = 0
-  private(set) var resultDrawn: CGFloat = 0
-  private(set) var returned: CGFloat = 0
-  var total: CGFloat { lengths.last ?? 0 }
-
-  init(failed: Bool, angle: Double, gap: CGFloat = 28) {
-    let r: CGFloat = 9.5
-    let direction: CGFloat = failed ? 1 : -1
-    let y = direction * gap
-    arc(center: .zero, from: angle, sweep: 1.4 * .pi, radius: r)
-    departure = total
-    let exitAngle = failed ? Double.pi / 2 : -Double.pi / 2
-    let sourceHead = angle + 1.4 * .pi
-    let extra = (exitAngle - sourceHead).truncatingRemainder(dividingBy: 2 * .pi)
-    arc(center: .zero, from: sourceHead, sweep: extra < 0 ? extra + 2 * .pi : extra, radius: r)
-    sourceExit = total
-    let start = points.last!
-    curve(from: start, c1: CGPoint(x: start.x - 4 * sin(exitAngle), y: start.y + 4 * cos(exitAngle)),
-          c2: CGPoint(x: -r, y: y + 10), to: CGPoint(x: -r, y: y))
-    arrival = total
-    arc(center: CGPoint(x: 0, y: y), from: .pi, sweep: 2 * .pi, radius: r)
-    resultDrawn = total
-    let finalAngle = angle + StatusFlight.duration * 2 * .pi / 3
-    let end = CGPoint(x: r * cos(exitAngle), y: r * sin(exitAngle))
-    curve(from: points.last!, c1: CGPoint(x: -r, y: y - 10),
-          c2: CGPoint(x: end.x + 4 * sin(exitAngle), y: end.y - 4 * cos(exitAngle)), to: end)
-    returned = total
-    let resume = (finalAngle - exitAngle).truncatingRemainder(dividingBy: 2 * .pi)
-    arc(center: .zero, from: exitAngle, sweep: (resume < 0 ? resume + 2 * .pi : resume) + 1.4 * .pi, radius: r)
-  }
-
-  func range(for frame: OrbitMotionFrame) -> ClosedRange<CGFloat> {
-    max(0, frame.distance - frame.tailLength)...frame.distance
-  }
-
-  func path(in range: ClosedRange<CGFloat>) -> Path {
-    var path = Path()
-    guard range.upperBound - range.lowerBound > 0.01 else { return path }
-    var began = false
-    for i in 1..<points.count {
-      let a = lengths[i - 1], b = lengths[i]
-      guard b > a, b >= range.lowerBound, a <= range.upperBound else { continue }
-      let lo = max(a, range.lowerBound), hi = min(b, range.upperBound)
-      func point(_ d: CGFloat) -> CGPoint {
-        let t = (d - a) / (b - a)
-        return CGPoint(x: points[i-1].x + (points[i].x-points[i-1].x)*t,
-                       y: points[i-1].y + (points[i].y-points[i-1].y)*t)
-      }
-      if !began { path.move(to: point(lo)); began = true }
-      path.addLine(to: point(hi))
-    }
-    return path
-  }
-
-  private mutating func append(_ point: CGPoint) {
-    let distance = points.last.map { hypot(point.x - $0.x, point.y - $0.y) } ?? 0
-    lengths.append(total + distance)
-    points.append(point)
-  }
-  private mutating func arc(center: CGPoint, from: Double, sweep: Double, radius: CGFloat) {
-    for i in 0...96 {
-      let a = from + sweep * Double(i) / 96
-      append(CGPoint(x: center.x + radius * cos(a), y: center.y + radius * sin(a)))
-    }
-  }
-  private mutating func curve(from: CGPoint, c1: CGPoint, c2: CGPoint, to: CGPoint) {
-    for i in 1...64 {
-      let t = CGFloat(i) / 64, u = 1 - t
-      append(CGPoint(x: u*u*u*from.x + 3*u*u*t*c1.x + 3*u*t*t*c2.x + t*t*t*to.x,
-                     y: u*u*u*from.y + 3*u*u*t*c1.y + 3*u*t*t*c2.y + t*t*t*to.y))
-    }
-  }
-}
-
-struct OrbitStroke: Shape {
-  let frame: OrbitMotionFrame
-  let angle: Double
-  var gap: CGFloat = 28
-  func path(in rect: CGRect) -> Path {
-    let route = OrbitBrushRoute(failed: frame.failed, angle: angle, gap:gap)
-    let canonical=OrbitBrushRoute(failed:frame.failed,angle:angle)
-    let source=[CGFloat(0),canonical.departure,canonical.sourceExit,canonical.arrival,canonical.resultDrawn,canonical.returned,canonical.total]
-    let dest=[CGFloat(0),route.departure,route.sourceExit,route.arrival,route.resultDrawn,route.returned,route.total]
-    func map(_ d:CGFloat)->CGFloat {
-      for i in 1..<source.count where d <= source[i] {
-        let w=(d-source[i-1])/max(0.00001,source[i]-source[i-1])
-        return dest[i-1]+w*(dest[i]-dest[i-1])
-      }
-      return route.total
-    }
-    let range=canonical.range(for:frame)
-    return route.path(in: map(range.lowerBound)...map(range.upperBound)).offsetBy(dx: rect.midX, dy: rect.midY)
-  }
-}
-
-struct DecisionSpin {
-  let began:Date
-  let angle:Double
-  let initialVelocity:Double
-  let finalVelocity:Double
-  var delay:Double = 0
-  static let duration=0.62
-  static let runningVelocity=2 * Double.pi/3
-  func velocity(at now:Date)->Double {
-    let u=min(1,max(0,(now.timeIntervalSince(began)-delay)/Self.duration))
-    return initialVelocity+(finalVelocity-initialVelocity)*(3*u*u-2*u*u*u)
-  }
-  func position(at now:Date)->Double {
-    let elapsed=max(0,now.timeIntervalSince(began)-delay),t=min(elapsed,Self.duration),u=t/Self.duration
-    return angle+initialVelocity*t+(finalVelocity-initialVelocity)*Self.duration*(u*u*u-0.5*u*u*u*u)+finalVelocity*max(0,elapsed-Self.duration)
-  }
-}
-struct DecisionMorph {
-  let amount:Double
-  private var q:Double { min(1,max(0,amount)) }
-  private var p:Double { 1-q }
-  static let resumeDuration=0.98
-  private static let clearFraction=0.28/resumeDuration
-  var draw:Double {
-    let u=min(1,max(0,(p-Self.clearFraction)/(1-Self.clearFraction)))
-    let terminal=DecisionSpin.runningVelocity*(Self.resumeDuration-0.28)/(2 * Double.pi*0.70)
-    // Integrate a monotone smoothstep velocity: acceleration also reaches zero at handoff.
-    return (2-terminal)*u+(2*terminal-2)*(u*u*u-0.5*u*u*u*u)
-  }
-  var fill:Double { 1-IdleInterpolation.smooth((p-0.02)/(Self.clearFraction-0.02)) }
-  var flip:Double { 1-IdleInterpolation.smooth(p/Self.clearFraction) }
-  var trim:Double { 0.70*draw }
-}
-
-struct DecisionClosing {
-  static let duration=0.82
-  let amount:Double
-  var trim:Double { 0.70+0.30*IdleInterpolation.smooth(amount/0.5) }
-  var fill:Double { IdleInterpolation.smooth((amount-0.50)/0.38) }
-  var tint:Double { IdleInterpolation.smooth((amount-0.24)/0.55) }
-  var flip:Double { IdleInterpolation.smooth((amount-0.62)/0.38) }
-}
-
-/// Center visible ink, excluding font side bearings and baseline line-box padding.
-@MainActor enum CenteredStatusGlyph {
-  private static var cache:[String:Path]=[:]
-  static func path(_ text:String)->Path {
-    if let cached=cache[text] { return cached }
-    let base=NSFont.systemFont(ofSize:10,weight:.bold)
-    let font=NSFont(descriptor:base.fontDescriptor.withDesign(.rounded) ?? base.fontDescriptor,size:10) ?? base
-    let ct=CTFontCreateWithName(font.fontName as CFString,10,nil)
-    let chars=Array(text.utf16)
-    var glyphs=[CGGlyph](repeating:0,count:chars.count)
-    CTFontGetGlyphsForCharacters(ct,chars,&glyphs,chars.count)
-    var advances=[CGSize](repeating:.zero,count:glyphs.count)
-    CTFontGetAdvancesForGlyphs(ct,.horizontal,glyphs,&advances,glyphs.count)
-    let combined=CGMutablePath();var x=0.0
-    for (i,glyph) in glyphs.enumerated() {
-      if let outline=CTFontCreatePathForGlyph(ct,glyph,nil) {
-        combined.addPath(outline,transform:CGAffineTransform(translationX:x,y:0))
-      }
-      x+=advances[i].width
-    }
-    let bounds=combined.boundingBoxOfPath
-    guard !bounds.isEmpty else { return Path() }
-    let scale=min(1,12/bounds.width)
-    let transform=CGAffineTransform(a:scale,b:0,c:0,d:-scale,tx:-bounds.midX*scale,ty:bounds.midY*scale)
-    var result=Path();result.addPath(Path(combined),transform:transform)
-    if text == "!" {
-      // The long stem carries more ink than the dot: align optical mass, not just bounds.
-      let ink=result.boundingRect,step=0.04
-      var sumY=0.0,count=0.0
-      for y in stride(from:ink.minY+step/2,to:ink.maxY,by:step) {
-        for x in stride(from:ink.minX+step/2,to:ink.maxX,by:step) {
-          if result.contains(CGPoint(x:x,y:y)) { sumY+=y;count+=1 }
-        }
-      }
-      if count > 0 { result=result.applying(CGAffineTransform(translationX:0,y:-sumY/count)) }
-    }
-    cache[text]=result;return result
-  }
-}
-
-/// Two halves hinge at the glyph's equator, like a split-flap calendar.
-struct DecisionFlipGlyph:View {
-  let number:Int
-  let progress:Double
-  let color:Color
-  var body:some View {
-    let numeral=CenteredStatusGlyph.path("\(number)")
-    let mark=CenteredStatusGlyph.path("!")
-    Canvas { context,size in
-      func half(_ text:String,top:Bool,scale:Double,exposed:Double? = nil) {
-        guard scale > 0.001 else { return }
-        var c=context
-        c.translateBy(x:size.width/2,y:size.height/2)
-        if let exposed {
-          let y=top ? -size.height/2:exposed
-          let height=top ? size.height/2-exposed:size.height/2-exposed
-          c.clip(to:Path(CGRect(x:-size.width/2,y:y,width:size.width,height:max(0,height))))
-        }
-        c.scaleBy(x:1,y:scale)
-        c.clip(to:Path(CGRect(x:-size.width/2,y:top ? -size.height/2:0,width:size.width,height:size.height/2)))
-        c.fill(text == "!" ? mark:numeral,with:.color(color))
-      }
-      if progress < 0.5 {
-        let scale=max(0,cos(.pi*progress))
-        half("!",top:true,scale:1,exposed:size.height/2*scale)
-        half("\(number)",top:false,scale:1)
-        half("\(number)",top:true,scale:scale)
-      } else {
-        let scale=max(0,cos(.pi*(1-progress)))
-        half("!",top:true,scale:1)
-        half("\(number)",top:false,scale:1,exposed:size.height/2*scale)
-        half("!",top:false,scale:scale)
-      }
-    }.frame(width:19,height:19)
-  }
-}
-
-struct DecisionDissolveGlyph:View {
-  let number:Int
-  let progress:Double
-  let color:Color
-  var body:some View {
-    let numeral=CenteredStatusGlyph.path("\(number)"),mark=CenteredStatusGlyph.path("!")
-    let t=min(1,max(0,progress))
-    Canvas { context,size in
-      context.translateBy(x:size.width/2,y:size.height/2)
-      var old=context;old.opacity *= 1-t;old.fill(numeral,with:.color(color))
-      var new=context;new.opacity *= t;new.fill(mark,with:.color(color))
-    }.frame(width:19,height:19)
-  }
-}
-
-/// Disappear before the two 19-point disks (plus stroke allowance) can touch.
-struct StatusSeparation {
-  static func opacity(weight:Double,distance:Double)->Double {
-    weight*IdleInterpolation.smooth((distance-20)/8)
-  }
-}
-
-struct WorkingDecisionGlyph:View {
-  let amount:Double
-  let number:Int
-  let angle:Double
-  var closing:Bool = false
-  var body:some View {
-    let m=DecisionMorph(amount:amount)
-    let closed=DecisionClosing(amount:amount)
-    let blue=NotchTokens.deepSeekBlue
-    ZStack {
-      if closing {
-        let ink=Color(red:0.302+(0.949-0.302)*closed.tint,green:0.420+0.580*closed.tint,blue:0.996+(0.078-0.996)*closed.tint)
-        Circle().fill(ink).scaleEffect(closed.fill)
-        Circle().trim(from:0,to:closed.trim).stroke(ink,style:StrokeStyle(lineWidth:1.5,lineCap:.round)).rotationEffect(.radians(angle))
-        DecisionDissolveGlyph(number:number,progress:closed.flip,color:Color(red:(0.302+(0.949-0.302)*closed.tint)*(1-closed.fill),green:(0.420+0.580*closed.tint)*(1-closed.fill),blue:(0.996+(0.078-0.996)*closed.tint)*(1-closed.fill)))
-      } else {
-      Circle().fill(NotchTokens.amber).opacity(m.fill)
-      Circle().stroke(NotchTokens.amber,lineWidth:1.5).opacity(m.fill)
-      Circle().trim(from:0,to:m.trim)
-        .stroke(blue,style:StrokeStyle(lineWidth:1.5,lineCap:.round))
-        .opacity(min(1,m.draw/0.03)).rotationEffect(.radians(angle))
-      DecisionDissolveGlyph(number:number,progress:m.flip,color:Color(red:0.302*(1-m.fill),green:0.420*(1-m.fill),blue:0.996*(1-m.fill)))
-      }
-    }.frame(width:19,height:19)
-  }
-}
-
-/// The robot's final point travels to the rim, becomes the pen, then resolves text.
-struct StatusBirth {
-  let progress:Double
-  static let blueDrawDuration=(RobotDeparture.duration-0.666)*0.76
-  static let bluePenVelocity=2 * Double.pi*0.70/blueDrawDuration
-  var blueDraw:Double { min(1,max(0,(progress-0.24)/0.76)) }
-  var travel:Double { IdleInterpolation.smooth(progress/0.24) }
-  var draw:Double { IdleInterpolation.smooth((progress-0.24)/0.48) }
-  var fill:Double { IdleInterpolation.smooth((progress-0.72)/0.18) }
-  var text:Double { IdleInterpolation.smooth((progress-0.86)/0.14) }
-}
-struct StatusBirthGlyph:View {
-  let progress:Double
-  let decision:Bool
-  let number:Int
-  let angle:Double
-  var body:some View {
-    let m=StatusBirth(progress:progress)
-    let ink=decision ? NotchTokens.amber:NotchTokens.deepSeekBlue
-    let drawn=decision ? m.draw:m.blueDraw
-    let length=(decision ? 1.0:0.70)*drawn
-    ZStack {
-      if decision { Circle().fill(ink).scaleEffect(m.fill) }
-      Circle().trim(from:0,to:length)
-        .stroke(ink,style:StrokeStyle(lineWidth:1.5,lineCap:.round))
-        .rotationEffect(.radians(angle)).opacity(min(1,drawn/0.02))
-      Circle().fill(ink).frame(width:1.5,height:1.5)
-        .offset(x:cos(angle)*9.5*m.travel,y:sin(angle)*9.5*m.travel)
-        .opacity(1-min(1,drawn/0.02))
-      DecisionFlipGlyph(number:number,progress:decision ? 1:0,color:decision ? Color.black:ink)
-        .opacity(decision ? m.text:m.blueDraw)
-    }.frame(width:19,height:19)
-  }
-}
-
-struct StatusOrbitView: View {
-  @ObservedObject var model: BoardModel
-  @Environment(\.accessibilityReduceMotion) private var systemReduceMotion
-  var reduceMotionOverride: Bool? = nil
-  /// Fixed presentation time for deterministic native frame capture.
-  var renderDate: Date? = nil
-  var workReveal:Double = 1
-  private var reduceMotion: Bool { reduceMotionOverride ?? systemReduceMotion }
-
-  private var layout: OrbitLayout { model.orbitLayout }
-  private var showTop: Bool { layout.top > 0.0001 }
-  private var showBottom: Bool { layout.bottom > 0.0001 }
-  private var showMiddle: Bool { layout.middle > 0.0001 }
-  private var totalHeight: CGFloat { layout.height }
-  private var originY: CGFloat { layout.middleY }
-  private var bottomY: CGFloat { layout.bottomY }
-
-  private func clearance(_ weight:Double,_ y:Double,_ present:Bool)->Double {
-    guard !present else { return weight }
-    var neighbors:[Double]=[]
-    if model.busyCount > 0 { neighbors.append(layout.middleY) }
-    if model.completedUnreadCount > 0 { neighbors.append(10+28*layout.decision) }
-    if !model.failedRows.isEmpty { neighbors.append(layout.bottomY) }
-    if model.needsAction { neighbors.append(10) }
-    guard let distance=neighbors.map({abs($0-y)}).min() else { return weight }
-    return StatusSeparation.opacity(weight:weight,distance:distance)
-  }
-
-  var body: some View {
-    TimelineView(.animation(minimumInterval: 1.0 / 60.0, paused: reduceMotion || (model.busyCount == 0 && model.statusFlight == nil && !model.decisionSpinActive))) { context in
-      let now = renderDate ?? context.date
-      let flight = reduceMotion ? nil : model.statusFlight
-      let progress = flight.map { now.timeIntervalSince($0.startedAt) / StatusFlight.duration } ?? 1
-      let motion = flight.map { OrbitMotionFrame(progress: progress, failed: $0.failed, returns: $0.returnsToRunning, angle: $0.angle) }
-      let angle = model.decisionAngle(at:now)
-      let reply = reduceMotion ? nil:model.decisionReturn
-      let replyProgress = reply?.progress(at:now) ?? 1
-      let replyFrame = reply.map { DecisionReturnFrame(progress:replyProgress,angle:$0.angle) }
-      let localReply = reply.map { !$0.travelling } ?? false
-      let isolated = layout.top < 0.0001 && layout.bottom < 0.0001
-      let morphing = localReply || (reply == nil && flight == nil && isolated && abs(layout.middle+layout.decision-1) < 0.001)
-      ZStack(alignment: .topLeading) {
-        if morphing {
-          Group {
-            if workReveal < 1 {
-              StatusBirthGlyph(progress:workReveal,decision:model.needsAction,number:max(1,model.busyCount),angle:reduceMotion ? 0:angle)
-            } else {
-              WorkingDecisionGlyph(amount:localReply ? 1-replyProgress:layout.decision,number:max(1,max(model.busyCount,model.retainedBusyCount)),angle:reduceMotion ? 0:angle,closing:reply == nil && model.closingDecision)
-            }
-          }.position(x:15,y:10)
-        }
-        if layout.decision > 0.0001 && !morphing {
-          ZStack {
-            Circle().fill(NotchTokens.amber)
-            DecisionFlipGlyph(number:1,progress:1,color:.black)
-          }.frame(width:19,height:19)
-            .scaleEffect(workReveal)
-            .opacity(flight?.decision == true && flight?.destinationBefore == 0 ? (motion?.resultOpacity ?? 1):1)
-            .opacity(reply?.travelling == true ? (replyFrame?.fill ?? 1):clearance(layout.decision,10,model.needsAction))
-            .position(x:15,y:10)
-        }
-        if showTop {
-          let count = flight?.outcome == .success && motion?.arrived == false ? flight!.destinationBefore : max(model.completedUnreadCount,model.retainedSuccessCount)
-          statusDisk(count: count, color: NotchTokens.greenComplete, opacity: flight?.outcome == .success && flight?.destinationBefore == 0 ? (motion?.resultOpacity ?? 1) : 1)
-            .position(x: 15, y: 10+28*layout.decision)
-            .opacity(clearance(layout.top,10+28*layout.decision,model.completedUnreadCount > 0))
-        }
-        if showMiddle && !morphing {
-          let count = flight != nil && motion?.returned == false ? flight!.busyBefore : model.orbitBusyCount
-          ZStack {
-            Circle().fill(Color.black).frame(width: 15, height: 15)
-              .opacity(flight?.returnsToRunning == false ? (motion?.sourceOpacity ?? 1):1)
-            if flight == nil && model.busyCount > 0 && (reply == nil || reply!.busyBefore > 0) {
-              Circle().trim(from: 0, to: 0.70)
-                .stroke(NotchTokens.deepSeekBlue, style: StrokeStyle(lineWidth: 1.5, lineCap: .round))
-                .rotationEffect(.radians(reduceMotion ? 0 : angle))
-                .opacity(replyFrame?.baseRingOpacity ?? 1)
-            }
-            if let reply, let replyFrame {
-              DecisionFlipGlyph(number:reply.busyBefore,progress:0,color:NotchTokens.deepSeekBlue)
-                .opacity(reply.busyBefore > 0 ? 1-replyFrame.countMix:0)
-              DecisionFlipGlyph(number:model.busyCount,progress:0,color:NotchTokens.deepSeekBlue)
-                .opacity(replyFrame.countMix)
-            } else {
-              DecisionFlipGlyph(number:count,progress:0,color:NotchTokens.deepSeekBlue)
-                .opacity(count > 0 ? (motion?.sourceOpacity ?? 1) : 0)
-            }
-          }
-          .frame(width: 19, height: 19)
-          .scaleEffect(workReveal).opacity(layout.middle)
-          .position(x: 15, y: originY)
-        }
-        if showBottom {
-          let count = flight?.failed == true && motion?.arrived == false ? flight!.destinationBefore : max(model.failedRows.count,model.retainedFailureCount)
-          statusDisk(count: count, color: NotchTokens.redFail, opacity: flight?.failed == true && flight?.destinationBefore == 0 ? (motion?.resultOpacity ?? 1) : 1)
-            .position(x: 15, y: bottomY)
-            .opacity(clearance(layout.bottom,layout.bottomY,!model.failedRows.isEmpty))
-        }
-        if let reply, let frame=replyFrame, reply.travelling {
-          let yellow=StatusOutcome.decision.rgb
-          let ink=Color(red:0.302+(yellow.0-0.302)*frame.tint,
-                        green:0.420+(yellow.1-0.420)*frame.tint,
-                        blue:0.996+(yellow.2-0.996)*frame.tint)
-          DecisionReturnStroke(frame:frame,angle:reply.angle,gap:max(0,originY-10))
-            .stroke(ink,style:StrokeStyle(lineWidth:1.5,lineCap:.round))
-            .frame(width:30,height:20).position(x:15,y:originY)
-            .opacity(frame.strokeOpacity).allowsHitTesting(false).zIndex(-1)
-        }
-        if let flight, let motion {
-          let target = flight.outcome.rgb
-          let color = Color(red: 0.302 + (target.0 - 0.302) * motion.tint,
-                            green: 0.420 + (target.1 - 0.420) * motion.tint,
-                            blue: 0.996 + (target.2 - 0.996) * motion.tint)
-          // Colour belongs to the visible trail: its tail stays the result colour
-          // as the head returns towards the source rim, even behind the solid disk.
-          let resultColor = flight.outcome.color
-          let direction: CGFloat = flight.failed ? 1 : -1
-          let returnInk = LinearGradient(stops: [
-            .init(color: resultColor, location: 0),
-            .init(color: resultColor, location: 0.52),
-            .init(color: NotchTokens.deepSeekBlue, location: 1),
-          ], startPoint: UnitPoint(x: 0.5, y: 0.5 + direction * 28 / 20),
-             endPoint: UnitPoint(x: 0.5, y: 0.5 + direction * 9.5 / 20))
-          let ink = motion.returning ? AnyShapeStyle(returnInk) : AnyShapeStyle(color)
-          OrbitStroke(frame: motion, angle: flight.angle, gap:flight.decision ? max(0,originY-10):28*(flight.failed ? layout.middle : layout.top))
-            .stroke(ink, style: StrokeStyle(lineWidth: 1.5, lineCap: .round))
-            .frame(width: 30, height: 20)
-            .position(x: 15, y: originY)
-            .allowsHitTesting(false)
-            .zIndex(-1)
-        }
-      }
-      .frame(width: 30, height: totalHeight)
-    }
-
-    .accessibilityElement(children: .ignore)
-    .accessibilityLabel("运行中 \(model.busyCount)，完成 \(model.completedUnreadCount)，失败 \(model.failedRows.count)，等待决定 \(model.needsAction ? 1:0)")
-  }
-
-  private func statusDisk(count: Int, color: Color, opacity: Double) -> some View {
-    ZStack {
-      Circle().fill(color)
-      DecisionFlipGlyph(number:count,progress:0,color:color == NotchTokens.greenComplete ? Color.black:Color.white)
-    }
-    .frame(width: 19, height: 19)
-    .opacity(count > 0 ? opacity : 0)
-  }
-}