@stim-cli/server 1.14.0 → 1.15.0

package/dist/stim-frames/DuoScreenHitMesh.swift

@@ -0,0 +1,200 @@
+// Copyright (c) 2026 Siniulator contributors. Adapted under the MIT license in Support/Siniulator-LICENSE.txt.
+import SceneKit
+import simd
+
+@MainActor final class DuoScreenHitMesh {
+  private let mesh: DuoMesh
+  private struct Triangle {
+    let positions: SIMD3<Int>
+    let uv: [SIMD2<Float>]
+  }
+  private let triangles: [Triangle]
+  private var posed: [SIMD3<Float>] = []
+  private var lastTransforms: [simd_float4x4] = []
+
+  init?(node: SCNNode) {
+    guard let geometry = node.geometry, let mesh = DuoMesh(node: node),
+      let triangles = Self.triangles(geometry)
+    else { return nil }
+    self.mesh = mesh
+    self.triangles = triangles
+  }
+
+  private func updatePose() {
+    let transforms = mesh.transforms
+    if transforms != lastTransforms {
+      posed = mesh.vertices.indices.map { index in
+        let point = mesh.position(at: index, using: transforms)
+        return SIMD3(point.x, point.y, point.z)
+      }
+      lastTransforms = transforms
+    }
+  }
+
+  func textureCoordinate(from near: SCNVector3, to far: SCNVector3) -> CGPoint? {
+    updatePose()
+    let origin = SIMD3<Float>(Float(near.x), Float(near.y), Float(near.z))
+    let direction = SIMD3<Float>(Float(far.x), Float(far.y), Float(far.z)) - origin
+    var closest: Float = 1
+    var result: SIMD2<Float>?
+    for triangle in triangles {
+      let a = posed[triangle.positions.x]
+      let ab = posed[triangle.positions.y] - a
+      let ac = posed[triangle.positions.z] - a
+      let p = simd_cross(direction, ac)
+      let determinant = simd_dot(ab, p)
+      guard abs(determinant) > 1e-8 else { continue }
+      let offset = origin - a
+      let u = simd_dot(offset, p) / determinant
+      guard u >= -1e-5, u <= 1.00001 else { continue }
+      let q = simd_cross(offset, ab)
+      let v = simd_dot(direction, q) / determinant
+      guard v >= -1e-5, u + v <= 1.00001 else { continue }
+      let distance = simd_dot(ac, q) / determinant
+      guard distance >= 0, distance <= closest else { continue }
+      closest = distance
+      result = triangle.uv[0] * (1 - u - v) + triangle.uv[1] * u + triangle.uv[2] * v
+    }
+    return result.map { CGPoint(x: CGFloat($0.x), y: CGFloat($0.y)) }
+  }
+
+  func nearestTextureCoordinate(
+    to point: CGPoint, project: (SCNVector3) -> SCNVector3,
+    unproject: (SCNVector3) -> SCNVector3,
+    maximumDistance: CGFloat = .infinity
+  ) -> CGPoint? {
+    updatePose()
+    let projected = posed.map { position -> SIMD3<Float> in
+      let p = project(SCNVector3(position.x, position.y, position.z))
+      return SIMD3(Float(p.x), Float(p.y), Float(p.z))
+    }
+    let target = SIMD2<Float>(Float(point.x), Float(point.y))
+    var distance = Float.infinity
+    var best: SIMD2<Float>?
+    for triangle in triangles {
+      for edge in 0..<3 {
+        let next = (edge + 1) % 3
+        let a = projected[triangle.positions[edge]]
+        let b = projected[triangle.positions[next]]
+        let t = Self.segmentFraction(target, SIMD2(a.x, a.y), SIMD2(b.x, b.y))
+        let candidate = a + (b - a) * t
+        let squared = simd_length_squared(SIMD2(candidate.x, candidate.y) - target)
+        if squared < distance {
+          let p = unproject(SCNVector3(candidate.x, candidate.y, candidate.z))
+          let start = posed[triangle.positions[edge]]
+          let end = posed[triangle.positions[next]]
+          let length = simd_length_squared(end - start)
+          let fraction =
+            length > 1e-12
+            ? min(1, max(0, simd_dot(SIMD3(Float(p.x), Float(p.y), Float(p.z)) - start, end - start) / length)) : 0
+          best = triangle.uv[edge] * (1 - fraction) + triangle.uv[next] * fraction
+          distance = squared
+        }
+      }
+    }
+    guard distance <= Float(maximumDistance * maximumDistance) else { return nil }
+    return best.map { CGPoint(x: CGFloat($0.x), y: CGFloat($0.y)) }
+  }
+
+  func position(at uv: CGPoint) -> SCNVector3? {
+    updatePose()
+    let target = SIMD2<Float>(Float(uv.x), Float(uv.y))
+    var distance = Float.infinity
+    var best: SIMD3<Float>?
+    func world(_ p: SIMD3<Float>) -> SCNVector3 { SCNVector3(p.x, p.y, p.z) }
+    for triangle in triangles {
+      let a = triangle.uv[0]
+      let ab = triangle.uv[1] - a
+      let ac = triangle.uv[2] - a
+      let offset = target - a
+      let determinant = ab.x * ac.y - ab.y * ac.x
+      if abs(determinant) > 1e-10 {
+        let u = (offset.x * ac.y - offset.y * ac.x) / determinant
+        let v = (ab.x * offset.y - ab.y * offset.x) / determinant
+        if u >= -1e-5, v >= -1e-5, u + v <= 1.00001 {
+          return world(
+            posed[triangle.positions.x] * (1 - u - v)
+              + posed[triangle.positions.y] * u + posed[triangle.positions.z] * v)
+        }
+      }
+      for edge in 0..<3 {
+        let next = (edge + 1) % 3
+        let a = triangle.uv[edge]
+        let b = triangle.uv[next]
+        let t = Self.segmentFraction(target, a, b)
+        let squared = simd_length_squared(a + (b - a) * t - target)
+        if squared < distance {
+          distance = squared
+          best = posed[triangle.positions[edge]] * (1 - t) + posed[triangle.positions[next]] * t
+        }
+      }
+    }
+    return best.map(world)
+  }
+
+  private static func segmentFraction(_ point: SIMD2<Float>, _ a: SIMD2<Float>, _ b: SIMD2<Float>) -> Float {
+    let length = simd_length_squared(b - a)
+    return length > 1e-12 ? min(1, max(0, simd_dot(point - a, b - a) / length)) : 0
+  }
+
+  private static func triangles(_ geometry: SCNGeometry) -> [Triangle]? {
+    guard let positionSource = geometry.sources.firstIndex(where: { $0.semantic == .vertex }),
+      let uvSource = geometry.sources.firstIndex(where: { $0.semantic == .texcoord }),
+      let uvValues = DuoMesh.components(geometry.sources[uvSource]),
+      geometry.sources[uvSource].componentsPerVector == 2
+    else { return nil }
+    let uv = stride(from: 0, to: uvValues.count, by: 2).map {
+      SIMD2<Float>(Float(uvValues[$0]), Float(uvValues[$0 + 1]))
+    }
+    let channels =
+      geometry.geometrySourceChannels?.map(\.intValue)
+      ?? Array(repeating: 0, count: geometry.sources.count)
+    guard channels.count == geometry.sources.count else { return nil }
+    var result: [Triangle] = []
+    for element in geometry.elements {
+      guard element.primitiveType == .triangles || element.primitiveType == .polygon,
+        element.indicesChannelCount > 0,
+        channels.allSatisfy({ $0 >= 0 && $0 < element.indicesChannelCount }),
+        [1, 2, 4].contains(element.bytesPerIndex)
+      else { return nil }
+      let indices: [Int] = element.data.withUnsafeBytes { bytes in
+        stride(from: 0, to: bytes.count - element.bytesPerIndex + 1, by: element.bytesPerIndex).map { offset in
+          switch element.bytesPerIndex {
+          case 1: Int(bytes.loadUnaligned(fromByteOffset: offset, as: UInt8.self))
+          case 2: Int(bytes.loadUnaligned(fromByteOffset: offset, as: UInt16.self))
+          default: Int(bytes.loadUnaligned(fromByteOffset: offset, as: UInt32.self))
+          }
+        }
+      }
+      let header = element.primitiveType == .polygon ? element.primitiveCount : 0
+      guard indices.count >= header else { return nil }
+      let counts = header > 0 ? Array(indices.prefix(header)) : Array(repeating: 3, count: element.primitiveCount)
+      let count = counts.reduce(0, +)
+      guard counts.allSatisfy({ $0 >= 3 }),
+        indices.count == header + count * element.indicesChannelCount
+      else { return nil }
+      func index(_ corner: Int, _ source: Int) -> Int {
+        indices[
+          header
+            + (element.hasInterleavedIndicesChannels
+              ? corner * element.indicesChannelCount + channels[source]
+              : channels[source] * count + corner)]
+      }
+      var start = 0
+      for corners in counts {
+        for corner in 1..<(corners - 1) {
+          let corners = [start, start + corner, start + corner + 1]
+          let positions = corners.map { index($0, positionSource) }
+          let texcoords = corners.map { index($0, uvSource) }
+          guard positions.allSatisfy({ $0 < geometry.sources[positionSource].vectorCount }),
+            texcoords.allSatisfy({ $0 < uv.count })
+          else { return nil }
+          result.append(Triangle(positions: SIMD3(positions), uv: texcoords.map { uv[$0] }))
+        }
+        start += corners
+      }
+    }
+    return result.isEmpty ? nil : result
+  }
+
+}

package/dist/stim-frames/EmulatorFrameArtwork.swift

@@ -0,0 +1,113 @@
+import AppKit
+
+#if canImport(StimKit)
+  import StimKit
+#endif
+
+struct EmulatorSkinLayout {
+  var geometry: DeviceFrameGeometry
+  var image: String
+  var mask: String?
+  var cornerRadius: CGFloat
+
+  init?(_ contents: String) {
+    let text = contents.split(whereSeparator: \.isNewline).map {
+      $0.split(separator: "#", maxSplits: 1).first.map(String.init) ?? ""
+    }.joined(separator: "\n")
+    guard let expression = try? NSRegularExpression(pattern: "[{}]|\"[^\"]*\"|[^\\s{}]+") else { return nil }
+    let tokens = expression.matches(in: text, range: NSRange(text.startIndex..., in: text)).compactMap { match in
+      Range(match.range, in: text).map { String(text[$0]).trimmingCharacters(in: CharacterSet(charactersIn: "\"")) }
+    }
+    var index = 0
+    guard let root = SkinNode.parse(tokens, index: &index), index == tokens.count,
+      let parts = root.children["parts"], let layouts = root.children["layouts"], layouts.children.count == 1,
+      let portrait = layouts.children["portrait"], let display = parts.children["device"]?.children["display"],
+      let placement = portrait.children.values.first(where: { $0.values["name"] == "device" }),
+      let body = parts.children["portrait"], let background = body.children["background"]?.values["image"],
+      let width = portrait.number("width"), let height = portrait.number("height"),
+      let screenWidth = display.number("width"), let screenHeight = display.number("height"),
+      display.number("x") == 0, display.number("y") == 0,
+      let x = placement.number("x"), let y = placement.number("y"),
+      width > 0, height > 0, screenWidth > 0, screenHeight > 0, x >= 0, y >= 0,
+      x + screenWidth <= width, y + screenHeight <= height
+    else { return nil }
+    geometry = DeviceFrameGeometry(
+      size: CGSize(width: width, height: height), aperture: CGRect(x: x, y: y, width: screenWidth, height: screenHeight))
+    image = background
+    mask = body.children["foreground"]?.values["mask"]
+    cornerRadius = display.number("corner_radius") ?? 0
+  }
+}
+
+private struct SkinNode {
+  var values: [String: String] = [:]
+  var children: [String: SkinNode] = [:]
+
+  func number(_ key: String) -> CGFloat? { values[key].flatMap(Double.init).map { CGFloat($0) } }
+
+  static func parse(_ tokens: [String], index: inout Int) -> Self? {
+    var node = Self()
+    while index < tokens.count, tokens[index] != "}" {
+      let key = tokens[index]
+      index += 1
+      guard index < tokens.count else { return nil }
+      if tokens[index] == "{" {
+        index += 1
+        guard let child = parse(tokens, index: &index), index < tokens.count, tokens[index] == "}" else { return nil }
+        node.children[key] = child
+      } else {
+        node.values[key] = tokens[index]
+      }
+      index += 1
+    }
+    return node
+  }
+}
+
+@MainActor
+enum EmulatorFrameArtwork {
+  static func load(avdName: String) -> DeviceFrameArtwork? {
+    let environment = ProcessInfo.processInfo.environment
+    let home = FileManager.default.homeDirectoryForCurrentUser
+    let avdRoot = URL(fileURLWithPath: StoragePaths(home: home.path, environment: environment).avds)
+    let ini = values(avdRoot.appendingPathComponent(avdName).appendingPathExtension("ini"))
+    guard let path = ini["path"] else { return nil }
+    let config = values(URL(fileURLWithPath: path).appendingPathComponent("config.ini"))
+    guard config["hw.sensor.hinge"] != "yes", config["hw.lcd.circular"] != "true" else { return nil }
+    let skin: URL
+    if let path = config["skin.path"], path.hasPrefix("/") {
+      skin = URL(fileURLWithPath: path)
+    } else if let name = config["hw.device.name"], !name.contains("/") {
+      skin = URL(fileURLWithPath: "/Applications/Android Studio.app/Contents/plugins/android/resources/device-art-resources")
+        .appendingPathComponent(name)
+    } else {
+      return nil
+    }
+    guard let contents = try? String(contentsOf: skin.appendingPathComponent("layout"), encoding: .utf8),
+      let layout = EmulatorSkinLayout(contents),
+      config["hw.lcd.width"].flatMap(Double.init) == Double(layout.geometry.aperture.width),
+      config["hw.lcd.height"].flatMap(Double.init) == Double(layout.geometry.aperture.height),
+      let background = NSImage(contentsOf: skin.appendingPathComponent(layout.image))
+    else { return nil }
+    let foreground = layout.mask.flatMap { NSImage(contentsOf: skin.appendingPathComponent($0)) }
+    guard layout.mask == nil || foreground != nil else { return nil }
+    return DeviceFrameArtwork(
+      geometry: layout.geometry, cornerRadius: layout.cornerRadius,
+      background: { rect in draw(background, in: rect) },
+      foreground: { _ in if let foreground { draw(foreground, in: layout.geometry.aperture) } })
+  }
+
+  static func values(_ url: URL) -> [String: String] {
+    guard let text = try? String(contentsOf: url, encoding: .utf8) else { return [:] }
+    var values: [String: String] = [:]
+    for line in text.split(whereSeparator: \.isNewline) {
+      let pair = line.split(separator: "=", maxSplits: 1)
+      if pair.count == 2 { values[String(pair[0])] = String(pair[1]) }
+    }
+    return values
+  }
+
+  private static func draw(_ image: NSImage, in rect: CGRect) {
+    image.draw(in: rect, from: .zero, operation: .sourceOver, fraction: 1, respectFlipped: true, hints: nil)
+  }
+}

package/dist/stim-frames/EmulatorInput.swift

@@ -12,11 +12,14 @@ final class EmulatorInput {
   private static let window: UInt32 = 1 << 30
 
   private struct Call {
+    var id = UUID()
     var method: String
     var message: Data
     var completion: ((Data?) -> Void)?
   }
 
+  var onDisconnect: (() -> Void)?
+
   private let endpoint: EmulatorEndpoint
   private let queue = DispatchQueue(label: "stim.emulator-input")
   private var connection: NWConnection?
@@ -31,9 +34,15 @@ final class EmulatorInput {
     self.endpoint = endpoint
   }
 
-  func call(_ method: String, _ message: Data, completion: ((Data?) -> Void)? = nil) {
+  func call(_ method: String, _ message: Data, timeout: TimeInterval? = nil, completion: ((Data?) -> Void)? = nil) {
     queue.async {
-      self.pending.append(Call(method: method, message: message, completion: completion))
+      let call = Call(method: method, message: message, completion: completion)
+      self.pending.append(call)
+      if let timeout {
+        self.queue.asyncAfter(deadline: .now() + timeout) {
+          if self.current?.call.id == call.id || self.pending.contains(where: { $0.id == call.id }) { self.reset() }
+        }
+      }
       self.connect()
       self.sendNext()
     }
@@ -128,6 +137,7 @@ final class EmulatorInput {
   }
 
   private func reset() {
+    let disconnected = connection != nil && !closing
     connection?.cancel()
     connection = nil
     ready = false
@@ -137,5 +147,6 @@ final class EmulatorInput {
     current = nil
     pending = []
     for call in dropped { call.completion?(nil) }
+    if disconnected { onDisconnect?() }
   }
 }

package/dist/stim-frames/EmulatorPosture.swift

@@ -65,9 +65,9 @@ enum PostureMessages {
 }
 
 extension EmulatorInput {
-  func call(_ method: String, _ message: Data) async -> Data? {
+  func call(_ method: String, _ message: Data, timeout: TimeInterval? = nil) async -> Data? {
     await withCheckedContinuation { continuation in
-      call(method, message) { continuation.resume(returning: $0) }
+      call(method, message, timeout: timeout) { continuation.resume(returning: $0) }
     }
   }
 }

package/dist/stim-frames/FrameArtwork.swift

@@ -0,0 +1,37 @@
+import AppKit
+
+final class FrameArtworkPublisher {
+  private let load: @MainActor () -> DeviceFrameArtwork?
+  private var artwork: DeviceFrameArtwork?
+  private var loaded = false
+
+  init(load: @escaping @MainActor () -> DeviceFrameArtwork?) { self.load = load }
+
+  func send(quarterTurns: Int) {
+    Task { @MainActor in
+      if !loaded {
+        loaded = true
+        artwork = load()
+      }
+      guard let artwork, let images = artwork.pngLayers(quarterTurns: quarterTurns),
+        images.background.count + images.foreground.count <= 10 * 1024 * 1024
+      else {
+        Output.notice(["deviceFrame": NSNull()])
+        return
+      }
+      let geometry = artwork.geometry.rotated(quarterTurns: quarterTurns)
+      Output.notice([
+        "deviceFrame": [
+          "width": geometry.size.width, "height": geometry.size.height,
+          "aperture": [
+            "x": geometry.aperture.minX, "y": geometry.aperture.minY,
+            "width": geometry.aperture.width, "height": geometry.aperture.height,
+          ],
+          "cornerRadius": artwork.cornerRadius, "quarterTurns": quarterTurns,
+          "background": images.background.base64EncodedString(),
+          "foreground": images.foreground.base64EncodedString(),
+        ]
+      ])
+    }
+  }
+}

package/dist/stim-frames/H264Decoder.swift

@@ -0,0 +1,109 @@
+import CoreMedia
+import CoreVideo
+import Foundation
+import VideoToolbox
+
+/// Decodes an Annex-B H.264 stream into BGRA pixel buffers, one per access unit. A config packet (SPS and
+/// PPS) with new parameter sets replaces the session, and one that repeats them keeps it. A session VideoToolbox
+/// reports invalid (`kVTInvalidSessionErr`, for example after sleep) is dropped, so the next config packet makes a
+/// new one. Packets before the first config are dropped.
+public final class H264Decoder {
+  private var format: CMVideoFormatDescription?
+  private var session: VTDecompressionSession?
+  private var parameterSets: [Data] = []
+  private let output: (CVPixelBuffer) -> Void
+
+  public init(output: @escaping (CVPixelBuffer) -> Void) {
+    self.output = output
+  }
+
+  deinit {
+    invalidate()
+  }
+
+  public func invalidate() {
+    if let session {
+      VTDecompressionSessionWaitForAsynchronousFrames(session)
+      VTDecompressionSessionInvalidate(session)
+    }
+    session = nil
+    format = nil
+    parameterSets = []
+  }
+
+  /// Returns false when the parameter sets could not make a decoder.
+  @discardableResult
+  public func configure(_ annexB: Data) -> Bool {
+    let units = AnnexB.units(annexB)
+    guard let sps = units.first(where: { ($0.first ?? 0) & 0x1f == 7 }),
+      let pps = units.first(where: { ($0.first ?? 0) & 0x1f == 8 })
+    else {
+      invalidate()
+      return false
+    }
+    if session != nil, parameterSets == [sps, pps] { return true }
+    invalidate()
+    var description: CMVideoFormatDescription?
+    let status = sps.withUnsafeBytes { spsBytes in
+      pps.withUnsafeBytes { ppsBytes in
+        let pointers = [
+          spsBytes.bindMemory(to: UInt8.self).baseAddress!, ppsBytes.bindMemory(to: UInt8.self).baseAddress!,
+        ]
+        return CMVideoFormatDescriptionCreateFromH264ParameterSets(
+          allocator: nil, parameterSetCount: 2, parameterSetPointers: pointers, parameterSetSizes: [sps.count, pps.count],
+          nalUnitHeaderLength: 4, formatDescriptionOut: &description)
+      }
+    }
+    guard status == noErr, let description else { return false }
+    let attributes: [CFString: Any] = [
+      kCVPixelBufferPixelFormatTypeKey: kCVPixelFormatType_32BGRA,
+      kCVPixelBufferIOSurfacePropertiesKey: [:] as CFDictionary,
+    ]
+    var created: VTDecompressionSession?
+    guard
+      VTDecompressionSessionCreate(
+        allocator: nil, formatDescription: description, decoderSpecification: nil,
+        imageBufferAttributes: attributes as CFDictionary, outputCallback: nil, decompressionSessionOut: &created)
+        == noErr, let created
+    else { return false }
+    format = description
+    session = created
+    parameterSets = [sps, pps]
+    return true
+  }
+
+  /// Returns false once there is no session, so the caller waits for or asks for a config packet.
+  @discardableResult
+  public func decode(_ annexB: Data) -> Bool {
+    guard let session, let format else { return false }
+    let units = AnnexB.units(annexB).filter { !$0.isEmpty && ![7, 8].contains($0[0] & 0x1f) }
+    guard !units.isEmpty else { return true }
+    let sample = AnnexB.lengthPrefixed(units)
+    var block: CMBlockBuffer?
+    guard
+      CMBlockBufferCreateWithMemoryBlock(
+        allocator: nil, memoryBlock: nil, blockLength: sample.count, blockAllocator: nil, customBlockSource: nil,
+        offsetToData: 0, dataLength: sample.count, flags: kCMBlockBufferAssureMemoryNowFlag, blockBufferOut: &block)
+        == noErr, let block,
+      sample.withUnsafeBytes({
+        CMBlockBufferReplaceDataBytes(
+          with: $0.baseAddress!, blockBuffer: block, offsetIntoDestination: 0, dataLength: sample.count)
+      }) == noErr
+    else { return true }
+    var buffer: CMSampleBuffer?
+    var size = sample.count
+    guard
+      CMSampleBufferCreateReady(
+        allocator: nil, dataBuffer: block, formatDescription: format, sampleCount: 1, sampleTimingEntryCount: 0,
+        sampleTimingArray: nil, sampleSizeEntryCount: 1, sampleSizeArray: &size, sampleBufferOut: &buffer) == noErr,
+      let buffer
+    else { return true }
+    let output = self.output
+    let status = VTDecompressionSessionDecodeFrame(session, sampleBuffer: buffer, flags: [], infoFlagsOut: nil) {
+      status, _, image, _, _ in
+      if status == noErr, let image { output(image) }
+    }
+    if status == kVTInvalidSessionErr { invalidate() }
+    return self.session != nil
+  }
+}

package/dist/stim-frames/InputMessages.swift

@@ -3,6 +3,21 @@ import Foundation
 // Field numbers and enum values follow MouseEvent, KeyboardEvent and
 // EmulatorStatus in the emulator's emulator_controller.proto (sdk/emulator/lib).
 enum InputMessages {
+  // ClipData.text is field 1, UTF-8, in emulator_controller.proto.
+  static func clipboard(_ text: String) -> Data {
+    var out = Data()
+    appendBytes(field: 1, Data(text.utf8), to: &out)
+    return out
+  }
+
+  static func clipboardText(_ bytes: Data) -> String? {
+    var reader = ProtoReader(bytes)
+    while let (field, value) = reader.next() {
+      if field == 1, case .bytes(let text) = value { return String(data: text, encoding: .utf8) }
+    }
+    return ""
+  }
+
   static let macKeyCodeType: UInt64 = 4
   static let keyup: UInt64 = 1
   static let keypress: UInt64 = 2
@@ -17,13 +32,19 @@ enum InputMessages {
   /// is false (pressure 0). Unlike a MouseEvent, Android sees a touchscreen
   /// finger, not a mouse or stylus.
   static func touch(x: Int, y: Int, pressed: Bool) -> Data {
-    var touch = Data()
-    for (field, value) in [(1, UInt64(max(x, 0))), (2, UInt64(max(y, 0))), (4, pressed ? 1 : 0)] where value != 0 {
-      ScreenshotMessages.appendVarint(UInt64(field << 3), to: &touch)
-      ScreenshotMessages.appendVarint(value, to: &touch)
-    }
+    touches([(x, y)], pressed: pressed)
+  }
+
+  /// Contacts keep their list index as their tracking identifier until pressure-zero release.
+  static func touches(_ points: [(x: Int, y: Int)], pressed: Bool) -> Data {
     var out = Data()
-    appendBytes(field: 1, touch, to: &out)
+    for (identifier, point) in points.enumerated() {
+      let touch = message([
+        (1, UInt64(max(point.x, 0))), (2, UInt64(max(point.y, 0))),
+        (3, UInt64(identifier)), (4, pressed ? 1 : 0),
+      ])
+      appendBytes(field: 1, touch, to: &out)
+    }
     return out
   }
 

package/dist/stim-frames/KeyboardLayoutMap.swift

@@ -0,0 +1,70 @@
+import Carbon
+import Foundation
+
+public struct KeyboardLayoutMap: Sendable {
+  private var layers: [Bool: [Bool: [Character: UInt16]]] = [:]
+
+  public init(translate: (UInt16, Bool, Bool) -> String?) {
+    for command in [false, true] {
+      for control in [false, true] {
+        var codes: [Character: UInt16] = [:]
+        for keyCode: UInt16 in 0...50 {
+          guard let text = translate(keyCode, command, false), text.unicodeScalars.count == 1,
+            let scalar = text.unicodeScalars.first, let character = text.first,
+            "abcdefghijklmnopqrstuvwxyz0123456789".contains(character), codes[character] == nil
+          else { continue }
+          if control {
+            guard let controlled = translate(keyCode, command, true), controlled.unicodeScalars.count == 1,
+              controlled == text
+                || (scalar.value >= 0x61 && controlled.unicodeScalars.first?.value == scalar.value - 0x60)
+            else { continue }
+          }
+          codes[character] = keyCode
+        }
+        layers[command, default: [:]][control] = codes
+      }
+    }
+  }
+
+  public init(layoutData: CFData) {
+    let layout = UnsafeRawPointer(CFDataGetBytePtr(layoutData)!).assumingMemoryBound(to: UCKeyboardLayout.self)
+    let keyboardType = UInt32(LMGetKbdType())
+    self.init { keyCode, command, control in
+      var deadKeyState: UInt32 = 0
+      var length = 0
+      var output = [UniChar](repeating: 0, count: 255)
+      let modifiers = (command ? UInt32(cmdKey >> 8) : 0) | (control ? UInt32(controlKey >> 8) : 0)
+      let status = UCKeyTranslate(
+        layout, keyCode, UInt16(kUCKeyActionDown), modifiers,
+        keyboardType, 0, &deadKeyState, output.count, &length, &output)
+      guard status == noErr, deadKeyState == 0, length > 0 else { return nil }
+      return String(utf16CodeUnits: output, count: length)
+    }
+  }
+
+  public func keyCode(for character: Character, command: Bool, control: Bool) -> UInt16? {
+    layers[command]?[control]?[character]
+  }
+}
+
+public final class KeyboardLayoutCache {
+  private var maps: [String: KeyboardLayoutMap] = [:]
+
+  public init() {}
+
+  public func current() -> (id: String, map: KeyboardLayoutMap)? {
+    // Apple TextInputSources requires main-thread access.
+    precondition(Thread.isMainThread)
+    guard let source = TISCopyCurrentKeyboardLayoutInputSource()?.takeRetainedValue(),
+      let idProperty = TISGetInputSourceProperty(source, kTISPropertyInputSourceID),
+      let dataProperty = TISGetInputSourceProperty(source, kTISPropertyUnicodeKeyLayoutData)
+    else { return nil }
+    let id = Unmanaged<CFString>.fromOpaque(idProperty).takeUnretainedValue() as String
+    let data = Unmanaged<CFData>.fromOpaque(dataProperty).takeUnretainedValue()
+    guard CFDataGetLength(data) > 0 else { return nil }
+    if let map = maps[id] { return (id, map) }
+    let map = KeyboardLayoutMap(layoutData: data)
+    maps[id] = map
+    return (id, map)
+  }
+}