waterplane 0.1.16 → 0.1.18

package/packages/extensions/desktop/helper/Server.swift

@@ -0,0 +1,334 @@
+// Server: the `serve` pipeline. One serial queue owns all state; the source
+// delivers frames on it, commands are applied on it, and only the H.264
+// encoder's output callback (VideoToolbox's thread) writes from elsewhere,
+// through Output's lock.
+
+import CoreGraphics
+import CoreVideo
+import Foundation
+
+final class Server {
+  let q = DispatchQueue(label: "wp-desktop.server", qos: .userInteractive)
+  private let dryInput: Bool
+  private let forceSynthetic: Bool
+  private let input: InputInjector
+  private var params: Params?
+  private var source: FrameSource?
+  private var encoder: FrameEncoder?
+  private var geo: Geometry?
+  private var state = "stopped"
+  private var inConfigure = false
+  private var lastFrame: CVPixelBuffer?
+  private var lastFrameAt: UInt64 = 0
+  private var lastPts: UInt64 = 0
+  private var forceKey = false
+  /// The region the NEXT submitted frame belongs to (see `Region`): bumped by every config that
+  /// moves the crop or the source, and by every source restart.
+  private var regionSeq = 0
+  private var region = Region(seq: 0, crop: Crop())
+  /// Held only while a source is running: App Nap off and no idle system sleep. A helper that sits
+  /// in "error" or "stopped" (Screen Recording not granted, the view left open on that sentence)
+  /// must not keep the Mac awake.
+  private var activity: NSObjectProtocol?
+  private var idle = false
+  private var axCache: (at: UInt64, ok: Bool) = (0, false)
+  private var axToldAt: UInt64 = 0
+  private var statsTimer: DispatchSourceTimer?
+  private var watchdog: DispatchSourceTimer?
+  private let parentAtStart = getppid()
+
+  // Written from the encoder's thread.
+  private let statsLock = NSLock()
+  private var frames = 0, keys = 0, bytes = 0, captured = 0, dropped = 0
+  private var encSum: UInt64 = 0, encMax: UInt64 = 0
+  private var statsSince = nowMicros()
+  private var avc: String?
+
+  init(dryInput: Bool, forceSynthetic: Bool) {
+    self.dryInput = dryInput
+    self.forceSynthetic = forceSynthetic
+    input = InputInjector(dry: dryInput)
+  }
+
+  func run() {
+    StdinReader(
+      onCommand: { [self] c in q.async { self.apply(c) } },
+      onEOF: { [self] in
+        log("stdin closed, exiting")
+        // Never leave a capture running: stop on the queue, and exit regardless after 0.5 s.
+        DispatchQueue.global().asyncAfter(deadline: .now() + 0.5) { exit(0) }
+        q.async {
+          self.source?.stop()
+          self.encoder?.invalidate()
+          exit(0)
+        }
+      }
+    ).start()
+    startTimers()
+    log("serve: ready (\(dryInput ? "dry input, " : "")\(forceSynthetic ? "synthetic source" : "screen source"))")
+  }
+
+  // MARK: commands
+
+  private func apply(_ c: Command) {
+    switch c {
+    case .config(let o): configure(o)
+    case .keyframe: requestKey()
+    case .bitrate(let k):
+      guard var p = params else { return }
+      p.bitrateKbps = Params.clampBitrate(k)
+      params = p
+      encoder?.setBitrate(p.bitrateKbps)
+      emitStatus()
+    case .input(let ev): inject(ev)
+    case .stop: stopAll(reason: nil)
+    case .probe: Output.shared.json(probeObject())
+    }
+  }
+
+  private func configure(_ o: [String: Any]) {
+    var np = Params.parse(o, warn: { log($0) })
+    if forceSynthetic, np.source.kind != "synthetic" { np.source = .synthetic(idle: false) }
+    let old = params
+    params = np
+    inConfigure = true
+    defer { inConfigure = false }
+    let restart: Bool = {
+      guard let old, source != nil, state != "error" else { return true }
+      if !old.source.sameKind(np.source) || old.codec != np.codec { return true }
+      if case .display(let a) = old.source, case .display(let b) = np.source, a != b { return true }
+      if case .synthetic(let a) = old.source, case .synthetic(let b) = np.source, a != b { return true }
+      return false
+    }()
+    if restart || old?.crop != np.crop || old?.source != np.source { regionSeq += 1 }
+    region = Region(seq: regionSeq, crop: np.crop)
+    if restart {
+      teardown()
+      if np.source.kind != "synthetic" && !screenRecordingGranted() {
+        fail(screenRecordingSentence)
+        return
+      }
+      state = "starting"
+      let cb = SourceCallbacks(
+        onGeometry: { [weak self] g in self?.geometryChanged(g) },
+        onFrame: { [weak self] pb, pts in self?.frame(pb, pts) },
+        onIdle: { [weak self] in self?.idle = true },
+        onError: { [weak self] s in self?.fail(s) })
+      let s: FrameSource =
+        np.source.kind == "synthetic"
+        ? SyntheticSource(queue: q, params: np, callbacks: cb)
+        : ScreenSource(queue: q, params: np, callbacks: cb)
+      source = s
+      s.start()
+      if state == "error" { return }  // fail() already said why
+      holdActivity()
+    } else {
+      // A new region (crop, or another window) must start on a key OF THAT REGION: the phone
+      // treats the next key after a crop change as the new picture. Forget the old frame so a
+      // keyframe request cannot re-encode the previous region, and key the next captured one.
+      if old?.crop != np.crop || old?.source != np.source {
+        lastFrame = nil
+        forceKey = true
+      }
+      source?.update(np)
+      encoder?.update(np)
+    }
+    emitStatus()  // "running" (synthetic knows its size at once) or "starting" (SCK resolving)
+  }
+
+  private func holdActivity() {
+    guard activity == nil else { return }
+    // A background CLI gets App Nap timer coalescing: a 66 ms timer fired at ~180 ms.
+    activity = ProcessInfo.processInfo.beginActivity(
+      options: [.userInitiated, .latencyCritical, .idleSystemSleepDisabled], reason: "live desktop stream")
+    log("activity: held")
+  }
+
+  private func releaseActivity() {
+    guard let a = activity else { return }
+    ProcessInfo.processInfo.endActivity(a)
+    activity = nil
+    log("activity: released")
+  }
+
+  private func teardown() {
+    releaseActivity()
+    source?.stop()
+    source = nil
+    encoder?.invalidate()
+    encoder = nil
+    geo = nil
+    lastFrame = nil
+    statsLock.lock()
+    avc = nil
+    statsLock.unlock()
+  }
+
+  private func stopAll(reason: String?) {
+    teardown()
+    state = "stopped"
+    emitStatus(reason: reason)
+  }
+
+  private func fail(_ sentence: String) {
+    teardown()
+    state = "error"
+    log("error: \(sentence)")
+    emitStatus(reason: sentence)
+  }
+
+  private func requestKey() {
+    guard let p = params, let enc = encoder else {
+      forceKey = true
+      return
+    }
+    // On a still screen no frame will come: re-encode the last one as an IDR now.
+    let interval = UInt64(1_000_000 / p.fps)
+    if let last = lastFrame, nowMicros() - lastFrameAt > 2 * interval {
+      lastPts = max(nowMicros(), lastPts + 1)
+      enc.encode(last, pts: lastPts, forceKey: true, region: region)
+    } else {
+      forceKey = true
+    }
+  }
+
+  private func inject(_ ev: [String: Any]) {
+    if !dryInput {
+      let now = nowMicros()
+      if now - axCache.at > 2_000_000 { axCache = (now, accessibilityTrusted()) }
+      if !axCache.ok {
+        if now - axToldAt > 10_000_000 {
+          axToldAt = now
+          emitStatus(reason: accessibilitySentence)
+        }
+        return
+      }
+    }
+    var bounds = geo?.globalBounds ?? CGDisplayBounds(CGMainDisplayID())
+    if bounds.width < 1 { bounds = CGRect(x: 0, y: 0, width: 1280, height: 800) }
+    if let why = input.handle(ev, bounds: bounds) { log("input ignored: \(why)") }
+  }
+
+  // MARK: source callbacks (on q)
+
+  private func geometryChanged(_ g: Geometry) {
+    geo = g
+    if state != "error" { state = "running" }
+    if !inConfigure { emitStatus() }
+  }
+
+  private func frame(_ pb: CVPixelBuffer, _ ptsIn: UInt64) {
+    guard let p = params else { return }
+    idle = false
+    statsLock.lock()
+    captured += 1
+    statsLock.unlock()
+    let w = CVPixelBufferGetWidth(pb), h = CVPixelBufferGetHeight(pb)
+    if encoder == nil || encoder!.width != w || encoder!.height != h || encoder!.codec != p.codec {
+      encoder?.invalidate()
+      let sink: (EncodedFrame) -> Void = { [weak self] f in self?.encoded(f) }
+      encoder =
+        p.codec == .h264
+        ? H264Encoder(width: w, height: h, params: p, sink: sink)
+        : JpegEncoder(width: w, height: h, params: p, sink: sink)
+      if encoder == nil {
+        fail("The H.264 encoder could not start at \(w)×\(h). Try JPEG or a smaller size.")
+        return
+      }
+      forceKey = true
+    }
+    guard let enc = encoder else { return }
+    if enc.inFlight > 2 && !forceKey {
+      statsLock.lock()
+      dropped += 1
+      statsLock.unlock()
+      return
+    }
+    let pts = max(ptsIn, lastPts + 1)
+    lastPts = pts
+    lastFrame = pb
+    lastFrameAt = nowMicros()
+    let k = forceKey
+    forceKey = false
+    enc.encode(pb, pts: pts, forceKey: k, region: region)
+  }
+
+  /// Encoder output: H.264 on VideoToolbox's thread, JPEG on q.
+  private func encoded(_ f: EncodedFrame) {
+    var newAvc = false
+    statsLock.lock()
+    frames += 1
+    bytes += f.data.count
+    if f.key { keys += 1 }
+    encSum += f.encodeMicros
+    encMax = max(encMax, f.encodeMicros)
+    if let a = f.avc, a != avc {
+      avc = a
+      newAvc = true
+    }
+    statsLock.unlock()
+    // The region the frame was SUBMITTED for: Output announces it (a status) before its first frame.
+    Output.shared.frame(f.kind, key: f.key, pts: f.pts, payload: f.data, region: f.region)
+    if newAvc { q.async { self.emitStatus() } }
+  }
+
+  // MARK: status + stats
+
+  private func emitStatus(reason: String? = nil) {
+    let p = params
+    var o: [String: Any] = [
+      "t": "status", "state": state,
+      "width": geo?.outWidth ?? 0, "height": geo?.outHeight ?? 0,
+      "srcWidth": geo?.srcWidth ?? 0, "srcHeight": geo?.srcHeight ?? 0,
+      "fps": p?.fps ?? 0, "codec": (p?.codec ?? .h264).rawValue,
+      "bitrateKbps": p?.bitrateKbps ?? 0, "source": p?.source.kind ?? "none",
+      "screenRecording": screenRecordingGranted(), "accessibility": accessibilityTrusted(),
+      "responsibleSelf": { let r = responsibility(); return r.pid == r.responsible }(),
+      "helperVersion": helperVersion,
+    ]
+    if let reason { o["reason"] = reason }
+    statsLock.lock()
+    if let avc, p?.codec == .h264 { o["avc"] = avc }
+    statsLock.unlock()
+    Output.shared.status(o)
+    log("status \(state) \(o["width"]!)x\(o["height"]!) \(o["codec"]!) \(o["fps"]!)fps\(reason.map { " — " + $0 } ?? "")")
+  }
+
+  private func startTimers() {
+    let t = DispatchSource.makeTimerSource(queue: q)
+    t.schedule(deadline: .now() + 2, repeating: 2)
+    t.setEventHandler { [weak self] in self?.reportStats() }
+    t.resume()
+    statsTimer = t
+    // The host dying closes stdin, which is the main exit path. Being re-parented is the backstop.
+    let w = DispatchSource.makeTimerSource(queue: .global())
+    w.schedule(deadline: .now() + 1, repeating: 1)
+    w.setEventHandler { [parentAtStart] in
+      if getppid() != parentAtStart {
+        log("parent went away, exiting")
+        exit(0)
+      }
+    }
+    w.resume()
+    watchdog = w
+  }
+
+  private func reportStats() {
+    let now = nowMicros()
+    statsLock.lock()
+    let span = Double(now - statsSince) / 1e6
+    let s = (frames, keys, bytes, captured, dropped, encSum, encMax)
+    frames = 0; keys = 0; bytes = 0; captured = 0; dropped = 0; encSum = 0; encMax = 0
+    statsSince = now
+    statsLock.unlock()
+    guard state == "running", span > 0, s.0 > 0 || s.3 > 0 else { return }
+    let fps = Double(s.0) / span, kbps = Double(s.2) * 8 / 1000 / span
+    let encAvg = s.0 > 0 ? Double(s.5) / Double(s.0) / 1000 : 0, encMaxMs = Double(s.6) / 1000
+    log(String(format: "stats fps=%.1f kbps=%.0f keys=%d enc=%.2fms max=%.2fms captured=%d dropped=%d", fps, kbps, s.1, encAvg, encMaxMs, s.3, s.4))
+    Output.shared.json([
+      "t": "stats", "fps": (fps * 10).rounded() / 10, "kbps": kbps.rounded(), "keys": s.1,
+      "encodeMsAvg": (encAvg * 100).rounded() / 100, "encodeMsMax": (encMaxMs * 100).rounded() / 100,
+      "captured": s.3, "dropped": s.4, "periodMs": Int(span * 1000), "idle": idle,
+    ])
+  }
+}

package/packages/extensions/desktop/helper/Synthetic.swift

@@ -0,0 +1,281 @@
+// Synthetic source: a desktop-like test pattern rendered without any capture
+// API, fed into the same encoder/output path as a real capture. Every test uses
+// it, so nothing in a test can touch the real screen or ask for a permission.
+//
+// The pattern lives on a virtual 2560×1600 "desktop" so `crop` and `maxWidth`
+// behave exactly as they do on a display:
+//   - a light, mostly static background and menu bar
+//   - an editor window whose text-like lines scroll ~3 lines per second
+//   - a dark terminal panel whose glyphs churn every frame (the part that costs bits)
+//   - a cursor-like square on a slow Lissajous path
+
+import CoreGraphics
+import CoreVideo
+import Foundation
+
+protocol FrameSource: AnyObject {
+  func start()
+  /// Same source kind, new params: re-steer without a restart where possible.
+  func update(_ p: Params)
+  func stop()
+}
+
+/// All callbacks arrive on the server's queue.
+struct SourceCallbacks {
+  let onGeometry: (Geometry) -> Void
+  let onFrame: (CVPixelBuffer, UInt64) -> Void
+  let onIdle: () -> Void
+  let onError: (String) -> Void
+}
+
+func pixelFormat(for codec: Codec) -> OSType {
+  codec == .h264 ? kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange : kCVPixelFormatType_32BGRA
+}
+
+@inline(__always) private func mix(_ a: Int, _ b: Int, _ c: Int) -> UInt32 {
+  var x = UInt32(truncatingIfNeeded: (a &* 73_856_093) ^ (b &* 19_349_663) ^ (c &* 83_492_791))
+  x ^= x >> 13
+  x = x &* 0x5bd1_e995
+  x ^= x >> 15
+  return x
+}
+
+final class SyntheticSource: FrameSource {
+  static let VW = 2560, VH = 1600
+  private let q: DispatchQueue
+  private var p: Params
+  private let cb: SourceCallbacks
+  private var timer: DispatchSourceTimer?
+  private var pool: CVPixelBufferPool?
+  private var poolKey: (Int, Int, OSType) = (0, 0, 0)
+  private var geo: Geometry?
+  private let t0 = nowMicros()
+  private var frameNo = 0
+  private var wasIdle = false
+  private var colMap = [Int32]()
+  private var row = [UInt8]()
+  private let yLut: [UInt8] = (0..<256).map { UInt8(16 + $0 * 219 / 255) }
+
+  init(queue: DispatchQueue, params: Params, callbacks: SourceCallbacks) {
+    q = queue
+    p = params
+    cb = callbacks
+  }
+
+  func start() {
+    recomputeGeometry()
+    startTimer()
+  }
+
+  func update(_ np: Params) {
+    let fpsChanged = np.fps != p.fps
+    p = np
+    recomputeGeometry()
+    if fpsChanged { startTimer() }
+  }
+
+  func stop() {
+    timer?.cancel()
+    timer = nil
+  }
+
+  private func recomputeGeometry() {
+    var bounds = CGDisplayBounds(CGMainDisplayID())
+    if bounds.width < 1 { bounds = CGRect(x: 0, y: 0, width: 1280, height: 800) }
+    let (w, h) = outputSize(srcW: Self.VW, srcH: Self.VH, crop: p.crop, maxWidth: p.maxWidth, codec: p.codec)
+    let g = Geometry(srcWidth: Self.VW, srcHeight: Self.VH, globalBounds: bounds, outWidth: w, outHeight: h)
+    if g != geo {
+      geo = g
+      cb.onGeometry(g)
+    }
+  }
+
+  private func startTimer() {
+    timer?.cancel()
+    let t = DispatchSource.makeTimerSource(flags: .strict, queue: q)
+    let interval = 1.0 / Double(p.fps)
+    t.schedule(deadline: .now() + interval, repeating: interval, leeway: .milliseconds(1))
+    t.setEventHandler { [weak self] in self?.tick() }
+    t.resume()
+    timer = t
+  }
+
+  private func tick() {
+    guard let g = geo else { return }
+    let now = nowMicros()
+    let t = Double(now - t0) / 1e6
+    if case .synthetic(let idle) = p.source, idle, t.truncatingRemainder(dividingBy: 6) >= 3 {
+      if !wasIdle { cb.onIdle() }
+      wasIdle = true
+      return
+    }
+    wasIdle = false
+    let fmt = pixelFormat(for: p.codec)
+    if pool == nil || poolKey != (g.outWidth, g.outHeight, fmt) {
+      pool = makePool(g.outWidth, g.outHeight, fmt)
+      poolKey = (g.outWidth, g.outHeight, fmt)
+    }
+    guard let pool else { return }
+    var pbOut: CVPixelBuffer?
+    guard CVPixelBufferPoolCreatePixelBuffer(nil, pool, &pbOut) == kCVReturnSuccess, let pb = pbOut else {
+      log("synthetic: no pixel buffer from the pool")
+      return
+    }
+    frameNo += 1
+    render(pb, g, t)
+    cb.onFrame(pb, now)
+  }
+
+  private func makePool(_ w: Int, _ h: Int, _ fmt: OSType) -> CVPixelBufferPool? {
+    let attrs: [String: Any] = [
+      kCVPixelBufferPixelFormatTypeKey as String: fmt,
+      kCVPixelBufferWidthKey as String: w,
+      kCVPixelBufferHeightKey as String: h,
+      kCVPixelBufferIOSurfacePropertiesKey as String: [String: Any](),
+    ]
+    var pool: CVPixelBufferPool?
+    CVPixelBufferPoolCreate(nil, nil, attrs as CFDictionary, &pool)
+    return pool
+  }
+
+  // MARK: rendering
+
+  private func render(_ pb: CVPixelBuffer, _ g: Geometry, _ t: Double) {
+    let W = g.outWidth, H = g.outHeight
+    let c = p.crop
+    let cx0 = c.x * Double(Self.VW), cw = c.w * Double(Self.VW)
+    let cy0 = c.y * Double(Self.VH), ch = c.h * Double(Self.VH)
+    if colMap.count != W {
+      colMap = [Int32](repeating: 0, count: W)
+      row = [UInt8](repeating: 0, count: W)
+    }
+    for x in 0..<W { colMap[x] = Int32(cx0 + (Double(x) + 0.5) * cw / Double(W)) }
+    let scroll = Int(t * 3 * 32)  // 3 lines of 32 px per second
+    let curX = Int(1280 + 900 * sin(t * 0.7)), curY = Int(800 + 500 * sin(t * 1.1))
+    let frame = frameNo
+    let bgra = CVPixelBufferGetPixelFormatType(pb) == kCVPixelFormatType_32BGRA
+
+    CVPixelBufferLockBaseAddress(pb, [])
+    defer { CVPixelBufferUnlockBaseAddress(pb, []) }
+    let plane0 = bgra ? CVPixelBufferGetBaseAddress(pb)! : CVPixelBufferGetBaseAddressOfPlane(pb, 0)!
+    let stride0 = bgra ? CVPixelBufferGetBytesPerRow(pb) : CVPixelBufferGetBytesPerRowOfPlane(pb, 0)
+    let out = plane0.assumingMemoryBound(to: UInt8.self)
+
+    colMap.withUnsafeBufferPointer { cm in
+      row.withUnsafeMutableBufferPointer { rw in
+        for y in 0..<H {
+          let vy = Int(cy0 + (Double(y) + 0.5) * ch / Double(H))
+          fillRow(vy: vy, scroll: scroll, frame: frame, curX: curX, curY: curY, cm: cm, row: rw)
+          let dst = out + y * stride0
+          if bgra {
+            for x in 0..<W {
+              let v = rw[x]
+              dst[4 * x] = v
+              dst[4 * x + 1] = v
+              dst[4 * x + 2] = v
+              dst[4 * x + 3] = 255
+            }
+          } else {
+            yLut.withUnsafeBufferPointer { lut in for x in 0..<W { dst[x] = lut[Int(rw[x])] } }
+          }
+        }
+      }
+    }
+
+    // Colour: the cursor square is orange so the chroma path is exercised too.
+    let ox0 = Int((Double(curX) - cx0) * Double(W) / cw), ox1 = Int((Double(curX + 28) - cx0) * Double(W) / cw)
+    let oy0 = Int((Double(curY) - cy0) * Double(H) / ch), oy1 = Int((Double(curY + 28) - cy0) * Double(H) / ch)
+    if bgra {
+      for y in max(0, oy0)..<max(max(0, oy0), min(H, oy1)) {
+        let dst = out + y * stride0
+        for x in max(0, ox0)..<max(max(0, ox0), min(W, ox1)) {
+          dst[4 * x] = 20
+          dst[4 * x + 1] = 120
+          dst[4 * x + 2] = 240
+        }
+      }
+    } else {
+      let uv = CVPixelBufferGetBaseAddressOfPlane(pb, 1)!.assumingMemoryBound(to: UInt8.self)
+      let strideUV = CVPixelBufferGetBytesPerRowOfPlane(pb, 1)
+      let hw = (W + 1) / 2
+      for y in 0..<((H + 1) / 2) {
+        let dst = uv + y * strideUV
+        let inCur = 2 * y >= oy0 && 2 * y < oy1
+        for x in 0..<hw {
+          if inCur && 2 * x >= ox0 && 2 * x < ox1 {
+            dst[2 * x] = 70
+            dst[2 * x + 1] = 200
+          } else {
+            dst[2 * x] = 128
+            dst[2 * x + 1] = 128
+          }
+        }
+      }
+    }
+  }
+
+  /// One row of luma (0 = black, 255 = white) at virtual row `vy`.
+  @inline(__always)
+  private func fillRow(
+    vy: Int, scroll: Int, frame: Int, curX: Int, curY: Int,
+    cm: UnsafeBufferPointer<Int32>, row: UnsafeMutableBufferPointer<UInt8>
+  ) {
+    let W = row.count
+    if vy < 48 {  // menu bar: static
+      for x in 0..<W { row[x] = 238 }
+      return
+    }
+    let base: UInt8 = 206 &+ UInt8((vy >> 6) & 1) &* 4
+    // Editor window rows.
+    let inEditor = vy >= 120 && vy < 1450
+    let edTitle = vy < 170
+    let ly = vy - 170 + scroll
+    let eLine = ly >> 5, eR = ly & 31
+    let eGlyphRow = !edTitle && eR >= 8 && eR < 26
+    let eGy = (eR - 8) / 3
+    let eHash = mix(eLine, 0, 7)
+    let eLen = 16 + Int(eHash % 72), eIndent = Int((eHash >> 8) % 4) * 2
+    // Terminal panel rows.
+    let inTerm = vy >= 300 && vy < 1100
+    let tTitle = vy < 340
+    let tl = vy - 340
+    let tLine = tl >> 5, tR = tl & 31
+    let tGlyphRow = !tTitle && tR >= 8 && tR < 26
+    let tGy = (tR - 8) / 3
+    let tHash = mix(tLine, frame, 11)
+    let tLen = 8 + Int(tHash % 32)
+    let inCursor = vy >= curY && vy < curY + 28
+
+    for x in 0..<W {
+      let vx = Int(cm[x])
+      var v = base
+      if inEditor && vx >= 200 && vx < 1700 {
+        if edTitle {
+          v = 214
+        } else {
+          v = 252
+          if eGlyphRow {
+            let col = (vx - 216) >> 4, cx = (vx - 216) & 15
+            if vx >= 216 && col >= eIndent && col < eIndent + eLen && cx < 12 && mix(eLine, col, 1) % 7 != 0 {
+              if (mix(eLine, col, eGy + 2) >> UInt32(cx >> 1)) & 1 == 1 { v = 28 }
+            }
+          }
+        }
+      } else if inTerm && vx >= 1800 && vx < 2450 {
+        if tTitle {
+          v = 64
+        } else {
+          v = 30
+          if tGlyphRow {
+            let col = (vx - 1812) >> 4, cx = (vx - 1812) & 15
+            if vx >= 1812 && col < tLen && cx < 12 && mix(tLine, col, frame) % 5 != 0 {
+              if (mix(tLine &+ frame, col, tGy + 2) >> UInt32(cx >> 1)) & 1 == 1 { v = 224 }
+            }
+          }
+        }
+      }
+      if inCursor && vx >= curX && vx < curX + 28 { v = 12 }
+      row[x] = v
+    }
+  }
+}

package/packages/extensions/desktop/helper/build.sh

@@ -0,0 +1,53 @@
+#!/bin/bash
+# Build wp-desktop. Usage:
+#   build.sh [OUT]     compile to OUT (default: $OUT, else $TMPDIR/wp-desktop/wp-desktop), ad-hoc sign
+#   build.sh --hash    print the source hash only (the host rebuilds only when it changes)
+#
+# A TCC grant is bound to the binary's code signature. An ad-hoc signature is
+# its cdhash, so EVERY rebuild means granting Screen Recording and
+# Accessibility again: rebuild only when --hash changes. The identifier is
+# stable and the Info.plist is embedded so the System Settings row reads
+# "wp-desktop", not a hash.
+#
+# The product's name is not spelled here: the host (helperbin.mts) reads it from
+# the brand table and passes it in the environment, for --hash and for a build
+# alike (the identifier is part of the hash):
+#   WP_DESKTOP_ID    the code-signing identifier / CFBundleIdentifier (TCC keys the grant on it)
+#   WP_DESKTOP_NAME  CFBundleDisplayName
+# A hand build (selftest.sh) gets a neutral local identifier; the host then sees
+# a different hash and builds its own.
+set -euo pipefail
+HERE="$(cd "$(dirname "$0")" && pwd)"
+SOURCES=(main.swift Protocol.swift Params.swift Server.swift Capture.swift Synthetic.swift H264.swift Jpeg.swift Input.swift Probe.swift Request.swift Responsibility.swift)
+
+ID="${WP_DESKTOP_ID:-local.wp-desktop}"
+NAME="${WP_DESKTOP_NAME:-wp-desktop helper}"
+
+srchash() {
+  { (cd "$HERE" && cat "${SOURCES[@]}" Info.plist build.sh); printf '%s\n%s\n' "$ID" "$NAME"; } | shasum -a 256 | cut -c1-16
+}
+
+if [ "${1:-}" = "--hash" ]; then
+  srchash
+  exit 0
+fi
+
+OUT="${1:-${OUT:-${TMPDIR:-/tmp}/wp-desktop/wp-desktop}}"
+SWIFTC="${SWIFTC:-$(command -v swiftc || true)}"
+SDK="$(xcrun --sdk macosx --show-sdk-path 2>/dev/null || true)"
+if [ -z "$SWIFTC" ] || [ -z "$SDK" ]; then
+  echo "build.sh: no swiftc or macOS SDK. Install the command line tools: xcode-select --install" >&2
+  exit 3
+fi
+mkdir -p "$(dirname "$OUT")"
+TMP_OUT="$OUT.build.$$"
+PLIST="$OUT.plist.$$"
+trap 'rm -f "$TMP_OUT" "$PLIST"' EXIT
+sed -e "s|@WP_DESKTOP_ID@|$ID|" -e "s|@WP_DESKTOP_NAME@|$NAME|" "$HERE/Info.plist" > "$PLIST"
+(cd "$HERE" && "$SWIFTC" -O -swift-version 5 -target arm64-apple-macos14 -sdk "$SDK" \
+  -Xlinker -sectcreate -Xlinker __TEXT -Xlinker __info_plist -Xlinker "$PLIST" \
+  "${SOURCES[@]}" -o "$TMP_OUT")
+codesign -s - --force --identifier "$ID" "$TMP_OUT"
+mv -f "$TMP_OUT" "$OUT"
+srchash > "$OUT.srchash"
+echo "built $OUT ($(cat "$OUT.srchash"))" >&2