dsh-notch 0.3.1

package/macos/Tests/MotionProbe.swift

@@ -0,0 +1,106 @@
+import AppKit
+import SwiftUI
+@main enum MotionProbe {
+ @MainActor static func main() {
+  let app=NSApplication.shared
+  app.setActivationPolicy(.accessory)
+  let output = URL(fileURLWithPath: ProcessInfo.processInfo.environment["NOTCH_MOTION_OUTPUT"] ?? NSTemporaryDirectory()).appendingPathComponent("notch-motion-proof")
+  try! FileManager.default.createDirectory(at: output, withIntermediateDirectories: true)
+  var failures=0
+  func check(_ value:Bool,_ label:String) { if !value { failures += 1; print("FAIL \(label)") } }
+  func snapshot(_ busy:Int,_ done:Int,_ failed:Int) -> NotchSnapshot {
+   let rows=(0..<busy).map { NotchRow(id:"busy-\($0)",title:"running",child:false,busy:true,unread:false) }
+     + (0..<done).map { NotchRow(id:"done-\($0)",title:"done",child:false,busy:false,unread:true) }
+     + (0..<failed).map { NotchRow(id:"failed-\($0)",title:"failed",child:false,busy:false,unread:true,lastTurn:NotchLastTurn(at:0,kind:"error",failed:true)) }
+   return NotchSnapshot(ok:true,generatedAt:0,origin:"local-test",rows:rows)
+  }
+  for failed in [false,true] {
+   for angle in stride(from: 0.0, to: 2 * Double.pi, by: Double.pi / 4) {
+    let route = OrbitBrushRoute(failed: failed, angle: angle)
+    check(route.points.allSatisfy { abs($0.x) + 0.75 <= 15 }, "brush stays inside shell")
+    for returns in [false,true] {
+     var previous = OrbitMotionFrame(progress:0,failed:failed,returns:returns,angle:angle)
+     check(previous.tint==0 && previous.resultOpacity==0,"blue start")
+     for i in 1...160 {
+      let frame = OrbitMotionFrame(progress:Double(i)/160,failed:failed,returns:returns,angle:angle)
+      check(frame.distance >= previous.distance,"brush head never reverses")
+      check(abs(frame.distance-previous.distance)<5,"continuous brush travel")
+      check(abs(frame.tint-previous.tint)<0.15,"continuous colour")
+      let range = route.range(for:frame)
+      check(range.lowerBound >= 0 && range.upperBound <= route.total + 0.01,"trail range")
+      previous=frame
+     }
+     check(previous.resultOpacity==1,"solid result appears")
+     check(returns ? previous.tint==0 : previous.tint==1,"final colour")
+     check(returns ? previous.tailLength>35 : previous.tailLength<0.01,"returning arc or settled dot")
+    }
+   }
+  }
+  let model=BoardModel()
+  var snap=snapshot(2,0,0);model.applySnapshot(snap)
+  check(model.statusFlight==nil,"cold snapshot has no flight")
+  snap.rows[0].busy=false;snap.rows[0].unread=true;model.applySnapshot(snap)
+  check(model.statusFlight?.failed==false,"successful completion moves upward")
+  let first=model.statusFlight!.id
+  model.applySnapshot(snap);check(model.statusFlight?.id==first,"polling does not replay")
+  snap.rows[1].busy=false;snap.rows[1].unread=true;snap.rows[1].lastTurn=NotchLastTurn(at:0,kind:"error",failed:true);model.applySnapshot(snap)
+  check(model.statusFlight?.id==first,"second outcome does not interrupt flight")
+  model.finishStatusFlight(id:first)
+  check(model.statusFlight?.failed==true,"failure queued next")
+  model.finishStatusFlight(id:first)
+  check(model.statusFlight?.failed==true,"stale completion cannot clear new flight")
+  model.finishStatusFlight(id:model.statusFlight!.id)
+  check(model.statusFlight==nil && model.busyCount==0 && model.completedUnreadCount==1 && model.failedRows.count==1,"final counts")
+  let panel=NotchPanel(size:NSSize(width:60,height:110))
+  let host=NotchHostingView(rootView:StatusOrbitView(model:model, reduceMotionOverride:false).frame(width:60,height:110).background(Color.black))
+  host.sizingOptions=[];panel.contentView=host
+  panel.setFrame(NSRect(x:-2000,y:-2000,width:60,height:110),display:true)
+  panel.orderFrontRegardless()
+  Task { @MainActor in
+   for failed in [false,true] {
+    model.rows=snapshot(1,failed ? 0:1,failed ? 1:0).rows
+    for (i,phase) in [0.0,0.12,0.24,0.38,0.50,0.62,0.76,0.90,0.99].enumerated() {
+     model.statusFlight=StatusFlight(failed:failed,startedAt:Date().addingTimeInterval(-phase*StatusFlight.duration),busyBefore:2,destinationBefore:0)
+     try? await Task.sleep(for:.milliseconds(16))
+     host.layoutSubtreeIfNeeded()
+     if let rep=host.bitmapImageRepForCachingDisplay(in:host.bounds) {
+      host.cacheDisplay(in:host.bounds,to:rep)
+      try! rep.representation(using:.png,properties:[:])!.write(to:URL(fileURLWithPath:"\(output.path)/\(failed ? "failure":"success")-\(i).png"))
+     }
+    }
+   }
+   for failed in [false,true] {
+    model.statusFlight=nil
+    var replay=snapshot(2,0,0)
+    model.applySnapshot(replay)
+    replay.rows[0].busy=false;replay.rows[0].unread=true
+    if failed { replay.rows[0].lastTurn=NotchLastTurn(at:0,kind:"error",failed:true) }
+    model.applySnapshot(replay)
+    for i in 0..<100 {
+     try? await Task.sleep(for:.milliseconds(16))
+     host.layoutSubtreeIfNeeded()
+     if let rep=host.bitmapImageRepForCachingDisplay(in:host.bounds) {
+      host.cacheDisplay(in:host.bounds,to:rep)
+      let path="\(output.path)/replay-\(failed ? "failure":"success")-\(String(format:"%03d",i)).png"
+      try! rep.representation(using:.png,properties:[:])!.write(to:URL(fileURLWithPath:path))
+     }
+    }
+   }
+   model.statusFlight=nil;model.updateOrbitLayout();model.tickOrbitLayout(at:Date().addingTimeInterval(2))
+   host.rootView = StatusOrbitView(model:model, reduceMotionOverride:true).frame(width:60,height:110).background(Color.black)
+   try? await Task.sleep(for:.milliseconds(60))
+   @MainActor func pixels() -> Data {
+    host.layoutSubtreeIfNeeded()
+    let rep=host.bitmapImageRepForCachingDisplay(in:host.bounds)!
+    host.cacheDisplay(in:host.bounds,to:rep)
+    return rep.representation(using:.png,properties:[:])!
+   }
+   let firstPixels=pixels()
+   try? await Task.sleep(for:.milliseconds(160))
+   check(firstPixels==pixels(),"reduced motion stays still")
+   try! firstPixels.write(to:URL(fileURLWithPath:"\(output.path)/reduced-motion.png"))
+   print("FAILURES=\(failures)");exit(failures==0 ? 0:1)
+  }
+  app.run()
+ }
+}

package/macos/Tests/OutcomeProbe.swift

@@ -0,0 +1,133 @@
+import AppKit
+import SwiftUI
+
+@main enum OutcomeProbe {
+ @MainActor static func main() {
+  NSApplication.shared.setActivationPolicy(.accessory)
+  var failures=0
+  func check(_ value:Bool,_ label:String) { if !value { failures += 1; print("FAIL \(label)") } }
+  for count in [1,2] { for kind in ["approval","success","failure"] {
+   let model=BoardModel();model.previewMode=true
+   var rows=(0..<count).map { NotchRow(id:"fixture-\($0)",title:"Local fixture",child:false,busy:true,unread:false) }
+   func snap()->NotchSnapshot {NotchSnapshot(ok:true,generatedAt:0,origin:"offline",rows:rows)}
+   model.applySnapshot(snap());model.tickOrbitLayout(at:Date().addingTimeInterval(2))
+   check(model.statusFlight == nil,"cold state has no result replay")
+   if kind == "approval" {rows[0].approval=NotchApproval(id:"local-approval",toolName:"offline")}
+   else {rows[0].busy=false;rows[0].unread=true;rows[0].lastTurn=NotchLastTurn(at:1,kind:kind,failed:kind == "failure")}
+   model.applySnapshot(snap())
+   guard let flight=model.statusFlight else {check(false,"\(count) task \(kind): real snapshot must start travelling brush");continue}
+   check(flight.outcome == (kind == "approval" ? .decision:(kind == "failure" ? .failure:.success)),"\(kind): correct destination colour")
+   check(flight.returnsToRunning == (count > 1),"\(count) task \(kind): return only if work remains")
+   check(flight.busyBefore==count,"source count retained until departure")
+   let id=flight.id;model.applySnapshot(snap());check(model.statusFlight?.id==id,"polling does not restart brush")
+   let start=OrbitMotionFrame(progress:0,failed:flight.failed,returns:flight.returnsToRunning,angle:flight.angle)
+   check(start.tint==0 && start.resultOpacity==0 && start.tailLength>20,"\(kind): starts as visible blue arc")
+   let draw=OrbitMotionFrame(progress:0.72,failed:flight.failed,returns:flight.returnsToRunning,angle:flight.angle)
+   check(draw.tailLength>0,"\(kind): drawing phase contains ink")
+   let end=OrbitMotionFrame(progress:1,failed:flight.failed,returns:flight.returnsToRunning,angle:flight.angle)
+   check(end.resultOpacity==1,"\(kind): result is solid at end")
+   check(count > 1 ? end.tint==0 : end.tailLength==0,"\(kind): returning blue or settled result")
+   model.finishStatusFlight(id:id)
+   check(model.statusFlight==nil,"\(kind): flight ends")
+   check(model.busyCount==count-1,"\(kind): exact remaining work")
+   check(kind == "approval" ? model.needsAction : (kind == "failure" ? model.failedRows.count==1 : model.completedUnreadCount==1),"\(kind): final result retained")
+   print("CHECKED \(count) task \(kind)")
+  }}
+  func busyRows(_ count:Int)->[NotchRow] {(0..<count).map {NotchRow(id:"action-\($0)",title:"Local",child:false,busy:true,unread:false)}}
+  func snapshot(_ rows:[NotchRow])->NotchSnapshot {NotchSnapshot(ok:true,generatedAt:0,origin:"offline",rows:rows)}
+  for cancel in [false,true] {
+    let m=BoardModel();var rows=busyRows(1)
+    m.applySnapshot(snapshot(rows));m.tickOrbitLayout(at:Date().addingTimeInterval(2))
+    rows[0].approval=NotchApproval(id:"approval",toolName:"offline")
+    m.applySnapshot(snapshot(rows));let id=m.statusFlight!.id
+    check(!m.expanded && !m.showingExpanded,"automatic panel must preserve travelling stroke")
+    if cancel {rows[0].approval=nil;m.applySnapshot(snapshot(rows))}
+    m.finishStatusFlight(id:id)
+    check(m.expanded == !cancel,"only current approval may open after ink arrives")
+    check(m.needsAction == !cancel,"cancelled question cannot reappear")
+  }
+  // A result queued before an approval must retain its own identity and order.
+  let queued=BoardModel();queued.previewMode=true;var rows=busyRows(2)
+  queued.applySnapshot(snapshot(rows));queued.tickOrbitLayout(at:Date().addingTimeInterval(2))
+  rows[0].busy=false;rows[0].unread=true
+  queued.applySnapshot(snapshot(rows));let first=queued.statusFlight!.id
+  rows[1].approval=NotchApproval(id:"queued-approval",toolName:"offline")
+  queued.applySnapshot(snapshot(rows));check(queued.statusFlight?.id==first,"decision does not replace moving success stroke")
+  queued.finishStatusFlight(id:first);let second=queued.statusFlight!.id
+  check(queued.statusFlight?.decision == true,"decision uses next brush slot")
+  queued.finishStatusFlight(id:first);check(queued.statusFlight?.id==second,"old callback cannot clear current stroke")
+  queued.finishStatusFlight(id:second)
+  check(queued.completedUnreadCount==1 && queued.needsAction,"green result survives yellow arrival")
+  // A decision reply resumes the same task; never increment the visible blue
+  // count before the yellow lamp has returned to it.
+  for count in [1,2] {
+    let m=BoardModel();m.previewMode=true;var rows=busyRows(count)
+    m.applySnapshot(snapshot(rows));m.tickOrbitLayout(at:Date().addingTimeInterval(2))
+    rows[0].approval=NotchApproval(id:"roundtrip",toolName:"offline")
+    m.applySnapshot(snapshot(rows));m.finishStatusFlight(id:m.statusFlight!.id)
+    m.tickOrbitLayout(at:Date().addingTimeInterval(2))
+    check(m.busyCount==count-1 && m.needsAction,"awaiting preserves remaining task count")
+    rows[0].approval=nil;m.applySnapshot(snapshot(rows))
+    if count==2 {check(m.retainedBusyCount==1,"yellow reply must not show blue 2 before merging")}
+    guard let reply=m.decisionReturn else {check(false,"reply must own a continuous return timeline");continue}
+    check(reply.travelling == (count==2),"reply draws locally or travels to remaining blue")
+    m.applySnapshot(snapshot(rows));check(m.decisionReturn?.id==reply.id,"polling does not restart reply")
+    m.tickOrbitLayout(at:reply.startedAt.addingTimeInterval(reply.duration*0.1))
+    if count==2 {check(m.orbitLayout.decision==1 && m.retainedBusyCount==1,"yellow clears before shell closes and count merges")}
+    let finalAngle=m.decisionAngle(at:reply.startedAt.addingTimeInterval(reply.duration))
+    m.finishDecisionReturn(id:reply.id)
+    check(m.decisionReturn==nil,"reply releases presentation state")
+    check(abs(m.decisionAngle(at:reply.startedAt.addingTimeInterval(reply.duration))-finalAngle)<0.00001,"spin phase survives reply handoff")
+    m.tickOrbitLayout(at:Date().addingTimeInterval(2))
+    check(m.busyCount==count && !m.needsAction,"reply returns original task count")
+    check(m.orbitLayout==OrbitLayout(middle:1),"reply leaves one blue lamp without yellow slot")
+  }
+  for count in [1,2] {
+    let m=BoardModel();m.previewMode=true;var rows=busyRows(count)
+    m.applySnapshot(snapshot(rows));m.tickOrbitLayout(at:Date().addingTimeInterval(2))
+    rows[0].approval=NotchApproval(id:"fast",toolName:"offline")
+    m.applySnapshot(snapshot(rows));let outward=m.statusFlight!.id
+    rows[0].approval=nil;m.applySnapshot(snapshot(rows))
+    check(m.statusFlight?.id==outward && m.decisionReturn==nil,"fast reply finishes its outgoing ink first")
+    check(m.orbitBusyCount==count-1,"fast reply cannot prematurely change outgoing blue count")
+    m.finishStatusFlight(id:outward)
+    guard let reply=m.decisionReturn else {check(false,"fast reply starts return after arrival");continue}
+    m.finishStatusFlight(id:outward);check(m.decisionReturn?.id==reply.id,"old outbound callback cannot erase reply")
+    m.finishDecisionReturn(id:reply.id)
+    check(m.orbitLayout==OrbitLayout(middle:1) && m.busyCount==count,"fast reply ends on original blue count")
+  }
+  // A folded panel must reveal the beginning of the return, not its last frame.
+  let panel=BoardModel();var panelRows=busyRows(2)
+  panel.applySnapshot(snapshot(panelRows));panel.tickOrbitLayout(at:Date().addingTimeInterval(2))
+  panelRows[0].approval=NotchApproval(id:"panel",toolName:"offline")
+  panel.applySnapshot(snapshot(panelRows));panel.finishStatusFlight(id:panel.statusFlight!.id)
+  check(panel.expanded && panel.showingExpanded,"approval expanded after arrival")
+  panelRows[0].approval=nil;let replyTime=Date();panel.applySnapshot(snapshot(panelRows))
+  check(!panel.expanded && panel.showingExpanded,"reply folds panel")
+  check((panel.decisionReturn?.startedAt.timeIntervalSince(replyTime) ?? 0)>=NotchGeometryAnimation.duration-0.02,"return waits for folded lamp surface")
+  // Cancelling a question without resuming that row must not increment unrelated work.
+  let cancel=BoardModel();cancel.previewMode=true;var cancelRows=busyRows(2)
+  cancelRows[0].approval=NotchApproval(id:"cancel",toolName:"offline")
+  cancel.applySnapshot(snapshot(cancelRows));cancel.tickOrbitLayout(at:Date().addingTimeInterval(2))
+  cancelRows[0].approval=nil;cancelRows[0].busy=false;cancel.applySnapshot(snapshot(cancelRows))
+  check(cancel.decisionReturn==nil && cancel.busyCount==1,"cancel is not a task resume")
+  for angle in stride(from:0.0,to:2 * Double.pi,by:Double.pi/4) {
+    let route=OrbitBrushRoute(failed:false,angle:angle)
+    var previous=DecisionReturnFrame(progress:0,angle:angle)
+    check(previous.fill==1 && previous.countMix==0,"return starts as existing yellow and existing count")
+    for i in 1...240 {
+      let frame=DecisionReturnFrame(progress:Double(i)/240,angle:angle)
+      check(frame.distance>=previous.distance && frame.distance-previous.distance<3,"return brush advances continuously")
+      check(frame.tint<=previous.tint+0.00001 && abs(frame.tint-previous.tint)<0.08,"return colour blends into blue")
+      check(frame.collapse==0 || frame.fill==0,"yellow solid clears before lamps converge")
+      check(frame.countMix==0 || frame.distance>=route.returned,"count changes only after ink enters blue ring")
+      previous=frame
+    }
+    check(previous.fill==0 && previous.tint==0 && previous.countMix==1,"return settles on blue new count")
+    let near=DecisionReturnFrame(progress:0.9999,angle:angle)
+    let velocity=(previous.distance-near.distance)/(StatusFlight.duration*0.0001)
+    check(abs(velocity-9.5*DecisionSpin.runningVelocity)<0.05,"pen speed matches final rotating ring")
+  }
+  print("FAILURES=\(failures)");exit(failures==0 ? 0:1)
+ }
+}

package/macos/Tests/ScrollbarProbe.swift

@@ -0,0 +1,91 @@
+import AppKit
+import SwiftUI
+import Combine
+
+@main enum ScrollbarProbe {
+  @MainActor static func main() {
+    let app = NSApplication.shared
+    app.setActivationPolicy(.accessory)
+    let model = BoardModel()
+    model.previewMode = true
+    model.maximumExpandedHeight = 800
+    let panel = NotchPanel(size:NSSize(width:38,height:44))
+    let host = NotchHostingView(rootView:RootView(model:model,panelSize:CGSize(width:480,height:800),restSize:CGSize(width:38,height:44)))
+    host.sizingOptions = []
+    panel.embedHost(host)
+    panel.setFrame(NSRect(x:-2000,y:-2000,width:38,height:44),display:true)
+    panel.orderFrontRegardless()
+    var subscriptions = Set<AnyCancellable>()
+    Publishers.CombineLatest(model.$currentIslandWidth,model.$currentIslandHeight)
+      .receive(on:DispatchQueue.main).sink {w,h in panel.resizeAnchored(to:NSSize(width:w,height:h))}
+      .store(in:&subscriptions)
+    @MainActor func scrollViews(_ view:NSView)->[NSScrollView] {
+      ((view as? NSScrollView).map {[$0]} ?? []) + view.subviews.flatMap(scrollViews)
+    }
+    Task { @MainActor in
+      let rows=(0..<5).map {NotchRow(id:"fixture-\($0)",title:"Running task \($0+1)",child:false,busy:true,unread:false)}
+      model.applySnapshot(NotchSnapshot(ok:true,generatedAt:0,origin:"offline",rows:rows))
+      try? await Task.sleep(for:.milliseconds(800))
+      var failures=0, samples=0, flashFrames=0
+      @MainActor func check(_ condition:Bool,_ message:String) {
+        if !condition {failures += 1;print("FAIL \(message)")}
+      }
+      @MainActor func inspectShortExpansion(_ scenario:String) async {
+        model.expanded=true
+        for frame in 0..<45 {
+          try? await Task.sleep(for:.milliseconds(16))
+          host.layoutSubtreeIfNeeded()
+          let scrolls=scrollViews(host)
+          for (i,scroll) in scrolls.enumerated() {
+            guard let bar=scroll.verticalScroller else {continue}
+            let visible=scroll.hasVerticalScroller && !bar.isHiddenOrHasHiddenAncestor && bar.alphaValue>0 && bar.bounds.height>0 && bar.knobProportion<0.999
+            if visible {failures += 1;flashFrames += 1}
+            if frame<4 || visible || frame==44 {
+              print("SCENARIO=\(scenario) FRAME=\(frame) SCROLL=\(i) PANEL=\(Int(panel.frame.height)) DOCUMENT=\(Int(scroll.documentView?.frame.height ?? 0)) VIEWPORT=\(Int(scroll.contentView.bounds.height)) HAS_BAR=\(scroll.hasVerticalScroller) HIDDEN=\(bar.isHiddenOrHasHiddenAncestor) ALPHA=\(bar.alphaValue) KNOB=\(bar.knobProportion) VISIBLE=\(visible)")
+            }
+          }
+          samples += scrolls.count
+        }
+      }
+      await inspectShortExpansion("five-tasks")
+      model.expanded=false
+      try? await Task.sleep(for:.milliseconds(600))
+      await inspectShortExpansion("reopen")
+      model.expanded=false
+      try? await Task.sleep(for:.milliseconds(70))
+      await inspectShortExpansion("reverse-collapse")
+      check(samples>0,"no native scroll views reached")
+
+      // A real overflow must keep both its indicator and a movable viewport.
+      model.maximumExpandedHeight=400
+      let question=NotchQuestion(id:"long",question:"Long question",options:[NotchOption(label:"Option",description:String(repeating:"Long offline content. ",count:150))])
+      let row=NotchRow(id:"question",title:"Local fixture",child:false,busy:true,unread:false,ask:NotchAsk(id:"ask",questions:[question]))
+      model.applySnapshot(NotchSnapshot(ok:true,generatedAt:0,origin:"offline",rows:[row]))
+      try? await Task.sleep(for:.milliseconds(850))
+      host.layoutSubtreeIfNeeded()
+      check(abs(panel.frame.height-400)<2,"long content reaches the screen cap")
+      if let scroll=scrollViews(host).first,let document=scroll.documentView {
+        let overflow=document.frame.height-scroll.contentView.bounds.height
+        check(overflow>20,"long fixture actually overflows")
+        check(scroll.hasVerticalScroller,"real overflow retains its indicator")
+        let before=scroll.contentView.bounds.origin.y
+        scroll.contentView.scroll(to:NSPoint(x:0,y:overflow))
+        scroll.reflectScrolledClipView(scroll.contentView)
+        check(scroll.contentView.bounds.origin.y>before+20,"long content remains scrollable")
+        print("LONG_OVERFLOW=\(Int(overflow)) SCROLLED=\(Int(scroll.contentView.bounds.origin.y)) INDICATOR=\(scroll.hasVerticalScroller)")
+      } else {check(false,"long fixture has a native scroll view")}
+      model.maximumExpandedHeight=800
+      model.applySnapshot(NotchSnapshot(ok:true,generatedAt:0,origin:"offline",rows:rows))
+      try? await Task.sleep(for:.milliseconds(850))
+      check(panel.frame.height<400,"short content shrinks after long content")
+      model.expanded=false
+      try? await Task.sleep(for:.milliseconds(600))
+      await inspectShortExpansion("after-long-content")
+      print("SCROLLBAR_FLASH_FRAMES=\(flashFrames)")
+      print("FAILURES=\(failures)")
+      exit(failures==0 ? 0:1)
+    }
+    app.run()
+    withExtendedLifetime(subscriptions) {}
+  }
+}

package/macos/Tests/expanded-height.sh

@@ -0,0 +1,13 @@
+#!/bin/sh
+set -eu
+base=$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd)
+work="$base/.build/expanded-height-probe"
+mkdir -p "$work/Sources"
+cp -R "$base/Sources/Resources" "$work/Sources/"
+cp "$base/Package.swift" "$work/Package.swift"
+for file in IdleRobot.swift NotchMarkdown.swift RootView.swift Panel.swift Client.swift StatusOrbit.swift; do
+  cp "$base/Sources/$file" "$work/Sources/$file"
+done
+cp "$base/Tests/ExpandedHeightProbe.swift" "$work/Sources/main.swift"
+swift build --package-path "$work" -c release
+"$work/.build/release/dsh-notch"

package/macos/Tests/geometry.sh

@@ -0,0 +1,14 @@
+#!/bin/sh
+set -eu
+base=$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd)
+work=$(mktemp -d "${TMPDIR:-/tmp}/notch-geometry.XXXXXX")
+trap 'rm -rf "$work"' EXIT
+mkdir "$work/Sources"
+cp -R "$base/Sources/Resources" "$work/Sources/Resources"
+cp "$base/Sources/IdleRobot.swift" "$work/Sources/"
+cp "$base/Sources/NotchMarkdown.swift" "$work/Sources/"
+cp "$base/Package.swift" "$work/Package.swift"
+cp "$base/Sources/RootView.swift" "$base/Sources/Panel.swift" "$base/Sources/Client.swift" "$base/Sources/StatusOrbit.swift" "$work/Sources/"
+cp "$base/Tests/GeometryProbe.swift" "$work/Sources/main.swift"
+swift build --package-path "$work" -c release
+"$work/.build/release/dsh-notch"

package/macos/Tests/idle.sh

@@ -0,0 +1,14 @@
+#!/bin/sh
+set -eu
+base=$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd)
+work=$(mktemp -d "${TMPDIR:-/tmp}/notch-idle.XXXXXX")
+trap 'rm -rf "$work"' EXIT
+mkdir "$work/Sources"
+cp -R "$base/Sources/Resources" "$work/Sources/Resources"
+cp "$base/Sources/IdleRobot.swift" "$work/Sources/"
+cp "$base/Sources/NotchMarkdown.swift" "$work/Sources/"
+cp "$base/Package.swift" "$work/Package.swift"
+cp "$base/Sources/RootView.swift" "$base/Sources/Panel.swift" "$base/Sources/Client.swift" "$base/Sources/StatusOrbit.swift" "$work/Sources/"
+cp "$base/Tests/IdleProbe.swift" "$work/Sources/main.swift"
+swift build --package-path "$work" -c release
+"$work/.build/release/dsh-notch"

package/macos/Tests/motion.sh

@@ -0,0 +1,14 @@
+#!/bin/sh
+set -eu
+base=$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd)
+work=$(mktemp -d "${TMPDIR:-/tmp}/notch-motion.XXXXXX")
+trap 'rm -rf "$work"' EXIT
+mkdir "$work/Sources"
+cp -R "$base/Sources/Resources" "$work/Sources/Resources"
+cp "$base/Sources/IdleRobot.swift" "$work/Sources/"
+cp "$base/Sources/NotchMarkdown.swift" "$work/Sources/"
+cp "$base/Package.swift" "$work/Package.swift"
+cp "$base/Sources/RootView.swift" "$base/Sources/Panel.swift" "$base/Sources/Client.swift" "$base/Sources/StatusOrbit.swift" "$work/Sources/"
+cp "$base/Tests/MotionProbe.swift" "$work/Sources/main.swift"
+swift build --package-path "$work" -c release
+"$work/.build/release/dsh-notch"

package/macos/Tests/outcome.sh

@@ -0,0 +1,14 @@
+#!/bin/sh
+set -eu
+base=$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd)
+work=$(mktemp -d "${TMPDIR:-/tmp}/notch-outcome.XXXXXX")
+trap 'rm -rf "$work"' EXIT
+mkdir "$work/Sources"
+cp -R "$base/Sources/Resources" "$work/Sources/Resources"
+cp "$base/Sources/IdleRobot.swift" "$work/Sources/"
+cp "$base/Sources/NotchMarkdown.swift" "$work/Sources/"
+cp "$base/Package.swift" "$work/Package.swift"
+cp "$base/Sources/RootView.swift" "$base/Sources/Panel.swift" "$base/Sources/Client.swift" "$base/Sources/StatusOrbit.swift" "$work/Sources/"
+cp "$base/Tests/OutcomeProbe.swift" "$work/Sources/main.swift"
+swift build --package-path "$work" -c release
+"$work/.build/release/dsh-notch"

package/macos/Tests/scrollbar.sh

@@ -0,0 +1,13 @@
+#!/bin/sh
+set -eu
+base=$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd)
+work="$base/.build/scrollbar-probe"
+mkdir -p "$work/Sources"
+cp -R "$base/Sources/Resources" "$work/Sources/"
+cp "$base/Package.swift" "$work/Package.swift"
+for file in IdleRobot.swift NotchMarkdown.swift RootView.swift Panel.swift Client.swift StatusOrbit.swift; do
+  cp "$base/Sources/$file" "$work/Sources/$file"
+done
+cp "$base/Tests/ScrollbarProbe.swift" "$work/Sources/main.swift"
+swift build --package-path "$work" -c release
+"$work/.build/release/dsh-notch"

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "dsh-notch",
+  "version": "0.3.1",
+  "type": "module",
+  "main": "src/dsh-notch.ts",
+  "description": "Native macOS notch for live DSH sessions, approvals, and model questions.",
+  "scripts": {
+    "test": "node --import tsx --test tests/*.test.mjs",
+    "test:motion": "sh macos/Tests/motion.sh",
+    "test:geometry": "sh macos/Tests/geometry.sh",
+    "build:macos": "swift build --package-path macos -c release",
+    "test:outcome": "sh macos/Tests/outcome.sh",
+    "test:idle": "sh macos/Tests/idle.sh",
+    "build:demo": "sh tools/recording/build.sh",
+    "test:scrollbar": "sh macos/Tests/scrollbar.sh",
+    "test:expanded-height": "sh macos/Tests/expanded-height.sh"
+  },
+  "devDependencies": {
+    "tsx": "4.22.4"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/dsh": ">=0.1.7-rc.1 <0.1.8",
+    "@deepseek-ai/dsh-host-webserver": ">=0.1.7-rc.1 <0.1.8",
+    "@deepseek-ai/dsh-session": ">=0.1.7-rc.1 <0.1.8",
+    "@deepseek-ai/dsh-user-approval": ">=0.1.7-rc.1 <0.1.8",
+    "@deepseek-ai/dsh-user-questions": ">=0.1.7-rc.1 <0.1.8"
+  },
+  "peerDependenciesMeta": {
+    "@deepseek-ai/dsh": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-host-webserver": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-session": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-user-approval": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-user-questions": {
+      "optional": true
+    }
+  },
+  "license": "MIT"
+}