@stim-cli/server 1.10.1 → 1.11.0

package/dist/stim-frames/EmulatorInput.swift

@@ -0,0 +1,141 @@
+import Foundation
+import Network
+
+/// Unary EmulatorController calls over one cleartext HTTP/2 connection to the
+/// emulator's localhost gRPC port. Calls run one at a time, in order, because
+/// the server may handle concurrent streams out of order and a touch must not
+/// overtake the one before it. Response header blocks are never decoded; a
+/// call ends on END_STREAM or RST_STREAM. Calls queued when the connection
+/// fails are dropped, and the next call reconnects. `close` lets queued calls
+/// finish first.
+final class EmulatorInput {
+  private static let window: UInt32 = 1 << 30
+
+  private struct Call {
+    var method: String
+    var message: Data
+    var completion: ((Data?) -> Void)?
+  }
+
+  private let endpoint: EmulatorEndpoint
+  private let queue = DispatchQueue(label: "stim.emulator-input")
+  private var connection: NWConnection?
+  private var ready = false
+  private var inbox: [UInt8] = []
+  private var pending: [Call] = []
+  private var current: (stream: UInt32, call: Call, response: [UInt8])?
+  private var nextStream: UInt32 = 1
+  private var closing = false
+
+  init(endpoint: EmulatorEndpoint) {
+    self.endpoint = endpoint
+  }
+
+  func call(_ method: String, _ message: Data, completion: ((Data?) -> Void)? = nil) {
+    queue.async {
+      self.pending.append(Call(method: method, message: message, completion: completion))
+      self.connect()
+      self.sendNext()
+    }
+  }
+
+  func close() {
+    queue.async {
+      self.closing = true
+      self.closeIfIdle()
+    }
+  }
+
+  private func closeIfIdle() {
+    if closing, current == nil, pending.isEmpty { reset() }
+  }
+
+  private func connect() {
+    guard connection == nil else { return }
+    let connection = NWConnection(
+      host: "127.0.0.1", port: NWEndpoint.Port(integerLiteral: UInt16(endpoint.grpcPort)), using: .tcp)
+    self.connection = connection
+    connection.stateUpdateHandler = { [weak self, weak connection] state in
+      guard let self, let connection, connection === self.connection else { return }
+      switch state {
+      case .ready:
+        self.ready = true
+        self.send(GrpcFraming.preface(window: Self.window))
+        self.receive(on: connection)
+        self.sendNext()
+      case .waiting, .failed, .cancelled:
+        self.reset()
+      default:
+        break
+      }
+    }
+    connection.start(queue: queue)
+  }
+
+  private func sendNext() {
+    guard ready, current == nil, !pending.isEmpty else { return }
+    let call = pending.removeFirst()
+    let stream = nextStream
+    nextStream += 2
+    current = (stream, call, [])
+    send(GrpcFraming.request(method: call.method, message: call.message, endpoint: endpoint, stream: stream))
+  }
+
+  private func receive(on connection: NWConnection) {
+    connection.receive(minimumIncompleteLength: 1, maximumLength: 1 << 16) { [weak self] data, _, complete, error in
+      guard let self, connection === self.connection else { return }
+      var buffer = self.inbox + (data.map { [UInt8]($0) } ?? [])
+      self.inbox = []
+      GrpcFraming.drain(&buffer) { type, flags, stream, payload in
+        self.handle(type: type, flags: flags, stream: stream, payload: payload)
+      }
+      guard connection === self.connection else { return }
+      self.inbox = buffer
+      if complete || error != nil { self.reset() } else { self.receive(on: connection) }
+    }
+  }
+
+  private func handle(type: UInt8, flags: UInt8, stream: UInt32, payload: ArraySlice<UInt8>) {
+    if let reply = GrpcFraming.acknowledgement(type: type, flags: flags, payload: payload) {
+      send(reply)
+      return
+    }
+    if type == 7 { return reset() }
+    guard let current, stream == current.stream else { return }
+    switch type {
+    case 0:
+      var body = payload
+      if flags & 0x8 != 0, let pad = body.first { body = body.dropFirst().dropLast(Int(pad)) }
+      self.current?.response += body
+      if flags & 0x1 != 0 { complete() }
+    case 1 where flags & 0x1 != 0, 3:
+      complete()
+    default:
+      break
+    }
+  }
+
+  private func complete() {
+    guard let current else { return }
+    self.current = nil
+    current.call.completion?(current.response.count >= 5 ? Data(current.response.dropFirst(5)) : nil)
+    sendNext()
+    closeIfIdle()
+  }
+
+  private func send(_ bytes: [UInt8]) {
+    connection?.send(content: Data(bytes), completion: .idempotent)
+  }
+
+  private func reset() {
+    connection?.cancel()
+    connection = nil
+    ready = false
+    inbox = []
+    nextStream = 1
+    let dropped = (current.map { [$0.call] } ?? []) + pending
+    current = nil
+    pending = []
+    for call in dropped { call.completion?(nil) }
+  }
+}

package/dist/stim-frames/GrpcFraming.swift

@@ -0,0 +1,85 @@
+import Foundation
+
+enum GrpcFraming {
+  static let service = "/android.emulation.control.EmulatorController/"
+
+  static func preface(window: UInt32) -> [UInt8] {
+    var out = Array("PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n".utf8)
+    var settings: [UInt8] = []
+    for (id, value) in [(UInt16(2), UInt32(0)), (4, window)] {
+      settings += [UInt8(id >> 8), UInt8(id & 0xff)] + bigEndian(value)
+    }
+    out += frame(type: 4, flags: 0, stream: 0, payload: settings)
+    out += frame(type: 8, flags: 0, stream: 0, payload: bigEndian(window))
+    return out
+  }
+
+  static func request(method: String, message: Data, endpoint: EmulatorEndpoint, stream: UInt32) -> [UInt8] {
+    var headers: [UInt8] = [0x83, 0x86]
+    headers += literal(index: 4, value: service + method)
+    headers += literal(index: 1, value: "127.0.0.1:\(endpoint.grpcPort)")
+    headers += literal(index: 31, value: "application/grpc")
+    headers += [0x00] + string("te") + string("trailers")
+    if let token = endpoint.token {
+      headers += literal(index: 23, value: "Bearer \(token)")
+    }
+    let body = [UInt8](message)
+    return frame(type: 1, flags: 0x4, stream: stream, payload: headers)
+      + frame(type: 0, flags: 0x1, stream: stream, payload: [0] + bigEndian(UInt32(body.count)) + body)
+  }
+
+  static func frame(type: UInt8, flags: UInt8, stream: UInt32, payload: [UInt8]) -> [UInt8] {
+    let length = UInt32(payload.count)
+    return [UInt8(length >> 16 & 0xff), UInt8(length >> 8 & 0xff), UInt8(length & 0xff), type, flags]
+      + bigEndian(stream) + payload
+  }
+
+  static func drain(_ inbox: inout [UInt8], _ handle: (UInt8, UInt8, UInt32, ArraySlice<UInt8>) -> Void) {
+    var offset = 0
+    while inbox.count - offset >= 9 {
+      let length = Int(inbox[offset]) << 16 | Int(inbox[offset + 1]) << 8 | Int(inbox[offset + 2])
+      guard inbox.count - offset >= 9 + length else { break }
+      let stream = inbox[(offset + 5)..<(offset + 9)].reduce(UInt32(0)) { $0 << 8 | UInt32($1) } & 0x7fff_ffff
+      handle(inbox[offset + 3], inbox[offset + 4], stream, inbox[(offset + 9)..<(offset + 9 + length)])
+      offset += 9 + length
+    }
+    inbox.removeFirst(offset)
+  }
+
+  static func acknowledgement(type: UInt8, flags: UInt8, payload: ArraySlice<UInt8>) -> [UInt8]? {
+    guard flags & 0x1 == 0 else { return nil }
+    switch type {
+    case 4: return frame(type: 4, flags: 0x1, stream: 0, payload: [])
+    case 6: return frame(type: 6, flags: 0x1, stream: 0, payload: Array(payload))
+    default: return nil
+    }
+  }
+
+  static func bigEndian(_ value: UInt32) -> [UInt8] {
+    [UInt8(value >> 24), UInt8(value >> 16 & 0xff), UInt8(value >> 8 & 0xff), UInt8(value & 0xff)]
+  }
+
+  // HPACK (RFC 7541) literal header field without indexing, name taken from
+  // the static table, value as a raw (non-Huffman) string.
+  private static func literal(index: Int, value: String) -> [UInt8] {
+    integer(index, prefixBits: 4, flags: 0x00) + string(value)
+  }
+
+  private static func string(_ value: String) -> [UInt8] {
+    let bytes = Array(value.utf8)
+    return integer(bytes.count, prefixBits: 7, flags: 0x00) + bytes
+  }
+
+  private static func integer(_ value: Int, prefixBits: Int, flags: UInt8) -> [UInt8] {
+    let limit = (1 << prefixBits) - 1
+    if value < limit { return [flags | UInt8(value)] }
+    var out = [flags | UInt8(limit)]
+    var rest = value - limit
+    while rest >= 0x80 {
+      out.append(UInt8(rest & 0x7f) | 0x80)
+      rest >>= 7
+    }
+    out.append(UInt8(rest))
+    return out
+  }
+}

package/dist/stim-frames/InputMessages.swift

@@ -0,0 +1,73 @@
+import Foundation
+
+// Field numbers and enum values follow MouseEvent, KeyboardEvent and
+// EmulatorStatus in the emulator's emulator_controller.proto (sdk/emulator/lib).
+enum InputMessages {
+  static let macKeyCodeType: UInt64 = 4
+  static let keyup: UInt64 = 1
+
+  /// A MouseEvent on the main display. `pressed` sets the primary button; the
+  /// emulator turns it into a single touch on a touchscreen device.
+  static func mouse(x: Int, y: Int, pressed: Bool) -> Data {
+    message([(1, UInt64(max(x, 0))), (2, UInt64(max(y, 0))), (3, pressed ? 1 : 0)])
+  }
+
+  /// A KeyboardEvent the emulator types as a key press per character.
+  static func text(_ text: String) -> Data {
+    var out = Data()
+    appendBytes(field: 5, Data(text.utf8), to: &out)
+    return out
+  }
+
+  /// A KeyboardEvent for a physical key named by its macOS virtual key code,
+  /// which the emulator translates to an evdev code.
+  static func key(macKeyCode: UInt16, down: Bool) -> Data {
+    message([(1, macKeyCodeType), (2, down ? 0 : keyup), (3, UInt64(macKeyCode))])
+  }
+
+  /// The main display's size in pixels, read from `hw.lcd.width` and
+  /// `hw.lcd.height` in an EmulatorStatus's hardwareConfig.
+  static func displaySize(fromStatus bytes: Data) -> (width: Int, height: Int)? {
+    var reader = ProtoReader(bytes)
+    var width: Int?
+    var height: Int?
+    while let (field, value) = reader.next() {
+      guard field == 5, case .bytes(let list) = value else { continue }
+      var entries = ProtoReader(list)
+      while let (entryField, entryValue) = entries.next() {
+        guard entryField == 1, case .bytes(let entry) = entryValue, let (key, value) = pair(entry) else { continue }
+        if key == "hw.lcd.width" { width = Int(value) }
+        if key == "hw.lcd.height" { height = Int(value) }
+      }
+    }
+    guard let width, let height, width > 0, height > 0 else { return nil }
+    return (width, height)
+  }
+
+  private static func pair(_ bytes: Data) -> (String, String)? {
+    var reader = ProtoReader(bytes)
+    var key: String?
+    var value = ""
+    while let (field, item) = reader.next() {
+      guard case .bytes(let data) = item else { continue }
+      if field == 1 { key = String(decoding: data, as: UTF8.self) }
+      if field == 2 { value = String(decoding: data, as: UTF8.self) }
+    }
+    return key.map { ($0, value) }
+  }
+
+  private static func message(_ fields: [(Int, UInt64)]) -> Data {
+    var out = Data()
+    for (field, value) in fields where value != 0 {
+      ScreenshotMessages.appendVarint(UInt64(field << 3), to: &out)
+      ScreenshotMessages.appendVarint(value, to: &out)
+    }
+    return out
+  }
+
+  private static func appendBytes(field: Int, _ bytes: Data, to out: inout Data) {
+    ScreenshotMessages.appendVarint(UInt64(field << 3 | 2), to: &out)
+    ScreenshotMessages.appendVarint(UInt64(bytes.count), to: &out)
+    out += bytes
+  }
+}

package/dist/stim-frames/ScreenshotMessages.swift

@@ -0,0 +1,129 @@
+import Foundation
+
+/// One RGBA8888 frame of an emulator display.
+public struct EmulatorFrame: Sendable {
+  public var width: Int
+  public var height: Int
+  /// The Rotation.SkinRotation the emulator turned the image upright by.
+  public var rotation: Int
+  public var rgba: Data
+}
+
+// Field numbers follow ImageFormat and Image in the emulator's
+// emulator_controller.proto (sdk/emulator/lib).
+enum ScreenshotMessages {
+  static let rgba8888: UInt64 = 1
+
+  static func imageFormat(width: Int, height: Int) -> Data {
+    var out = Data()
+    for (field, value) in [(1, rgba8888), (3, UInt64(width)), (4, UInt64(height))] {
+      appendVarint(UInt64(field << 3), to: &out)
+      appendVarint(value, to: &out)
+    }
+    return out
+  }
+
+  static func frame(fromImage bytes: Data) -> EmulatorFrame? {
+    var reader = ProtoReader(bytes)
+    var size: (width: Int, height: Int, rotation: Int)?
+    var image: Data?
+    while let (field, value) = reader.next() {
+      switch (field, value) {
+      case (1, .bytes(let nested)): size = rgbaSize(nested)
+      case (4, .bytes(let data)): image = data
+      default: break
+      }
+    }
+    guard let size, let image, size.width > 0, size.height > 0,
+      image.count == size.width * size.height * 4
+    else { return nil }
+    return EmulatorFrame(width: size.width, height: size.height, rotation: size.rotation, rgba: image)
+  }
+
+  private static func rgbaSize(_ bytes: Data) -> (width: Int, height: Int, rotation: Int)? {
+    var reader = ProtoReader(bytes)
+    var format: UInt64 = 0
+    var width = 0
+    var height = 0
+    var rotation = 0
+    while let (field, value) = reader.next() {
+      switch (field, value) {
+      case (1, .varint(let v)): format = v
+      case (2, .bytes(let nested)): rotation = skinRotation(nested)
+      case (3, .varint(let v)): width = Int(v)
+      case (4, .varint(let v)): height = Int(v)
+      default: break
+      }
+    }
+    guard format == rgba8888 else { return nil }
+    return (width, height, rotation)
+  }
+
+  private static func skinRotation(_ bytes: Data) -> Int {
+    var reader = ProtoReader(bytes)
+    while let (field, value) = reader.next() {
+      if field == 1, case .varint(let v) = value { return Int(v & 3) }
+    }
+    return 0
+  }
+
+  static func appendVarint(_ value: UInt64, to out: inout Data) {
+    var v = value
+    while v >= 0x80 {
+      out.append(UInt8(v & 0x7f) | 0x80)
+      v >>= 7
+    }
+    out.append(UInt8(v))
+  }
+}
+
+struct ProtoReader {
+  enum Value {
+    case varint(UInt64)
+    case bytes(Data)
+    case fixed
+  }
+
+  private let data: Data
+  private var index: Data.Index
+
+  init(_ data: Data) {
+    self.data = data
+    index = data.startIndex
+  }
+
+  mutating func next() -> (Int, Value)? {
+    guard index < data.endIndex, let key = varint() else { return nil }
+    let field = Int(key >> 3)
+    switch key & 7 {
+    case 0:
+      guard let v = varint() else { return nil }
+      return (field, .varint(v))
+    case 1, 5:
+      let size = key & 7 == 1 ? 8 : 4
+      guard data.endIndex - index >= size else { return nil }
+      index += size
+      return (field, .fixed)
+    case 2:
+      guard let length = varint(), UInt64(data.endIndex - index) >= length else { return nil }
+      let end = index + Int(length)
+      defer { index = end }
+      return (field, .bytes(data[index..<end]))
+    default:
+      return nil
+    }
+  }
+
+  private mutating func varint() -> UInt64? {
+    var result: UInt64 = 0
+    var shift: UInt64 = 0
+    while index < data.endIndex, shift < 64 {
+      let byte = data[index]
+      index += 1
+      result |= UInt64(byte & 0x7f) << shift
+      if byte < 0x80 { return result }
+      shift += 7
+    }
+    return nil
+  }
+}

package/dist/stim-frames/ScreenshotStream.swift

@@ -0,0 +1,130 @@
+import Foundation
+import Network
+
+/// A single `streamScreenshot` call over cleartext HTTP/2 to the emulator's
+/// localhost gRPC port. URLSession speaks HTTP/2 only over TLS, and the
+/// emulator's endpoint is h2c, so this writes the frames itself. It never
+/// decodes response header blocks: the call ends on END_STREAM, RST_STREAM,
+/// GOAWAY, or a closed connection.
+final class ScreenshotStream {
+  private static let window: UInt32 = 1 << 30
+
+  private let connection: NWConnection
+  private let queue = DispatchQueue(label: "stim.emulator-frames")
+  private let request: [UInt8]
+  private let onFrame: (EmulatorFrame) -> Void
+  private let onEnd: () -> Void
+  private var inbox: [UInt8] = []
+  private var messages: [UInt8] = []
+  private var unacknowledged: UInt32 = 0
+  private var ended = false
+
+  init(
+    endpoint: EmulatorEndpoint, width: Int, height: Int,
+    onFrame: @escaping (EmulatorFrame) -> Void, onEnd: @escaping () -> Void
+  ) {
+    connection = NWConnection(
+      host: "127.0.0.1", port: NWEndpoint.Port(integerLiteral: UInt16(endpoint.grpcPort)), using: .tcp)
+    request = Self.requestBytes(endpoint: endpoint, width: width, height: height)
+    self.onFrame = onFrame
+    self.onEnd = onEnd
+  }
+
+  func start() {
+    connection.stateUpdateHandler = { [weak self] state in
+      switch state {
+      case .ready:
+        guard let self else { return }
+        self.send(self.request)
+        self.receive()
+      case .failed, .cancelled:
+        self?.finish()
+      default:
+        break
+      }
+    }
+    connection.start(queue: queue)
+  }
+
+  func cancel() {
+    queue.async {
+      self.ended = true
+      self.connection.cancel()
+    }
+  }
+
+  static func requestBytes(endpoint: EmulatorEndpoint, width: Int, height: Int) -> [UInt8] {
+    GrpcFraming.preface(window: window)
+      + GrpcFraming.request(
+        method: "streamScreenshot", message: ScreenshotMessages.imageFormat(width: width, height: height),
+        endpoint: endpoint, stream: 1)
+  }
+
+  private func receive() {
+    connection.receive(minimumIncompleteLength: 1, maximumLength: 1 << 20) { [weak self] data, _, complete, error in
+      guard let self else { return }
+      if let data { self.inbox += data }
+      self.drainFrames()
+      if complete || error != nil { self.finish() } else if !self.ended { self.receive() }
+    }
+  }
+
+  private func drainFrames() {
+    GrpcFraming.drain(&inbox) { type, flags, _, payload in
+      if !ended { handle(type: type, flags: flags, payload: payload) }
+    }
+  }
+
+  private func handle(type: UInt8, flags: UInt8, payload: ArraySlice<UInt8>) {
+    switch type {
+    case 0:
+      var body = payload
+      if flags & 0x8 != 0, let pad = body.first {
+        body = body.dropFirst().dropLast(Int(pad))
+      }
+      messages += body
+      acknowledge(UInt32(payload.count))
+      drainMessages()
+      if flags & 0x1 != 0 { finish() }
+    case 1:
+      if flags & 0x1 != 0 { finish() }
+    case 3, 7:
+      finish()
+    default:
+      if let reply = GrpcFraming.acknowledgement(type: type, flags: flags, payload: payload) { send(reply) }
+    }
+  }
+
+  private func drainMessages() {
+    var offset = 0
+    while messages.count - offset >= 5 {
+      let length = messages[(offset + 1)..<(offset + 5)].reduce(0) { $0 << 8 | Int($1) }
+      guard messages.count - offset >= 5 + length else { break }
+      let bytes = Data(messages[(offset + 5)..<(offset + 5 + length)])
+      offset += 5 + length
+      if let frame = ScreenshotMessages.frame(fromImage: bytes) { onFrame(frame) }
+    }
+    messages.removeFirst(offset)
+  }
+
+  private func acknowledge(_ count: UInt32) {
+    unacknowledged += count
+    guard unacknowledged >= 1 << 24 else { return }
+    let increment = GrpcFraming.bigEndian(unacknowledged)
+    send(
+      GrpcFraming.frame(type: 8, flags: 0, stream: 0, payload: increment)
+        + GrpcFraming.frame(type: 8, flags: 0, stream: 1, payload: increment))
+    unacknowledged = 0
+  }
+
+  private func send(_ bytes: [UInt8]) {
+    connection.send(content: Data(bytes), completion: .idempotent)
+  }
+
+  private func finish() {
+    guard !ended else { return }
+    ended = true
+    connection.cancel()
+    onEnd()
+  }
+}

package/dist/stim-frames/SimulatorDisplay.swift

@@ -0,0 +1,116 @@
+import Foundation
+import IOSurface
+import ObjectiveC
+
+// CoreSimulator and SimulatorKit are private Apple frameworks. These selectors
+// match the SimDisplayIOSurfaceRenderable, SimDisplayRenderable, SimScreen and
+// SimScreenProperties protocols that Xcode 27 ships; Apple can change them in
+// any Xcode release.
+@objc protocol SimDisplayIOSurfaceRenderable {
+  var framebufferSurface: IOSurface? { get }
+  @objc(registerCallbackWithUUID:ioSurfacesChangeCallback:)
+  func registerSurfacesCallback(_ uuid: NSUUID, _ callback: @escaping (AnyObject?) -> Void)
+  @objc(unregisterIOSurfacesChangeCallbackWithUUID:)
+  func unregisterSurfacesCallback(_ uuid: NSUUID)
+}
+
+@objc protocol SimDisplayRenderable {
+  @objc(registerCallbackWithUUID:damageRectanglesCallback:)
+  func registerDamageCallback(_ uuid: NSUUID, _ callback: @escaping (AnyObject?) -> Void)
+  @objc(unregisterDamageRectanglesCallbackWithUUID:)
+  func unregisterDamageCallback(_ uuid: NSUUID)
+  @objc(registerCallbackWithUUID:displayPropertiesChanged:)
+  func registerPropertiesCallback(_ uuid: NSUUID, _ callback: @escaping (AnyObject?) -> Void)
+  @objc(unregisterDisplayPropertiesChangedCallbackWithUUID:)
+  func unregisterPropertiesCallback(_ uuid: NSUUID)
+}
+
+@objc protocol SimScreen {
+  var screenProperties: SimScreenProperties? { get }
+}
+
+// uiOrientation is a UIInterfaceOrientation; the framebuffer stays in the
+// display's native portrait orientation when the device rotates. screenType 0
+// is a built-in display with a digitizer; TV out, CarPlay and resizable
+// displays have other types.
+@objc protocol SimScreenProperties {
+  var uiOrientation: UInt32 { get }
+  var screenID: UInt32 { get }
+  var screenType: UInt { get }
+}
+
+typealias SimDisplay = SimDisplayIOSurfaceRenderable & SimDisplayRenderable & SimScreen
+
+public enum CoreSimulator {
+  /// The Xcode developer directory CoreSimulator loads SimulatorKit from.
+  /// Set it once at launch, before any view shows simulator frames.
+  public static var developerDir = defaultDeveloperDir
+
+  private static var defaultDeveloperDir: String {
+    ProcessInfo.processInfo.environment["DEVELOPER_DIR"] ?? "/Applications/Xcode.app/Contents/Developer"
+  }
+
+  /// The developer directory `xcode-select -p` reports, or `DEVELOPER_DIR`,
+  /// or `/Applications/Xcode.app`, when the selected one has no SimulatorKit.
+  public static func selectedDeveloperDir() -> String {
+    let process = Process()
+    process.executableURL = URL(fileURLWithPath: "/usr/bin/xcode-select")
+    process.arguments = ["-p"]
+    let out = Pipe()
+    process.standardOutput = out
+    process.standardError = FileHandle.nullDevice
+    guard (try? process.run()) != nil else { return defaultDeveloperDir }
+    let path = String(decoding: out.fileHandleForReading.readDataToEndOfFile(), as: UTF8.self)
+      .trimmingCharacters(in: .whitespacesAndNewlines)
+    return FileManager.default.fileExists(atPath: simulatorKitPath(path)) ? path : defaultDeveloperDir
+  }
+
+  static func simulatorKitPath(_ developerDir: String) -> String {
+    "\(developerDir)/../SharedFrameworks/SimulatorKit.framework/SimulatorKit"
+  }
+
+  static let deviceSet: NSObject? = {
+    guard dlopen("/Library/Developer/PrivateFrameworks/CoreSimulator.framework/CoreSimulator", RTLD_NOW) != nil
+    else { return nil }
+    dlopen(simulatorKitPath(developerDir), RTLD_NOW)
+    guard let contextClass = NSClassFromString("SimServiceContext") as? NSObject.Type,
+      let context = contextClass.perform(
+        NSSelectorFromString("sharedServiceContextForDeveloperDir:error:"), with: developerDir, with: nil
+      )?.takeUnretainedValue() as? NSObject
+    else { return nil }
+    return context.perform(NSSelectorFromString("defaultDeviceSetWithError:"), with: nil)?
+      .takeUnretainedValue() as? NSObject
+  }()
+
+  static func device(udid: String) -> NSObject? {
+    guard let devices = deviceSet?.value(forKey: "devices") as? [NSObject] else { return nil }
+    return devices.first { ($0.value(forKey: "UDID") as? NSUUID)?.uuidString == udid }
+  }
+
+  /// The screen IDs of the device's built-in displays that have a
+  /// framebuffer, main display first. An iPhone Duo has two; it is empty until
+  /// the device boots.
+  public static func screenIDs(udid: String) -> [UInt32] {
+    displays(udid: udid).compactMap { display in
+      display.screenProperties.flatMap { $0.screenType == 0 ? $0.screenID : nil }
+    }
+  }
+
+  static func displays(udid: String) -> [SimDisplay] {
+    guard let device = device(udid: udid),
+      let io = device.perform(NSSelectorFromString("io"))?.takeUnretainedValue() as? NSObject,
+      let ports = io.perform(NSSelectorFromString("ioPorts"))?.takeUnretainedValue() as? [NSObject],
+      let surfaceRenderable = objc_getProtocol("SimDisplayIOSurfaceRenderable"),
+      let renderable = objc_getProtocol("SimDisplayRenderable"),
+      let screen = objc_getProtocol("SimScreen")
+    else { return [] }
+    let displays = ports.compactMap { port -> SimDisplay? in
+      guard let descriptor = port.perform(NSSelectorFromString("descriptor"))?.takeUnretainedValue() as? NSObject,
+        descriptor.conforms(to: surfaceRenderable), descriptor.conforms(to: renderable), descriptor.conforms(to: screen)
+      else { return nil }
+      let display = unsafeBitCast(descriptor, to: SimDisplay.self)
+      return display.framebufferSurface == nil ? nil : display
+    }
+    return displays.sorted { ($0.screenProperties?.screenID ?? .max) < ($1.screenProperties?.screenID ?? .max) }
+  }
+}