@stim-cli/server 1.10.1 → 1.12.0

package/dist/stim-frames/EmulatorDiscovery.swift

@@ -0,0 +1,49 @@
+import Foundation
+
+/// The gRPC endpoint a running Android emulator advertises in its discovery file.
+public struct EmulatorEndpoint: Equatable, Sendable {
+  public var consolePort: Int
+  public var grpcPort: Int
+  public var token: String?
+}
+
+public enum EmulatorDiscovery {
+  // The emulator writes pid_<pid>.ini here on macOS, ignoring XDG_RUNTIME_DIR,
+  // and only when it was started with -grpc. `adb emu avd discoverypath`
+  // prints the same path.
+  static var directory: URL {
+    FileManager.default.homeDirectoryForCurrentUser
+      .appendingPathComponent("Library/Caches/TemporaryItems/avd/running", isDirectory: true)
+  }
+
+  public static func parse(_ contents: String) -> EmulatorEndpoint? {
+    var values: [Substring: Substring] = [:]
+    for line in contents.split(whereSeparator: \.isNewline) {
+      guard let separator = line.firstIndex(of: "=") else { continue }
+      values[line[..<separator]] = line[line.index(after: separator)...]
+    }
+    guard let console = values["port.serial"].flatMap({ Int($0) }),
+      let grpc = values["grpc.port"].flatMap({ Int($0) })
+    else { return nil }
+    return EmulatorEndpoint(consolePort: console, grpcPort: grpc, token: values["grpc.token"].map(String.init))
+  }
+
+  public static func consolePort(serial: String) -> Int? {
+    guard serial.hasPrefix("emulator-") else { return nil }
+    return Int(serial.dropFirst("emulator-".count))
+  }
+
+  public static func endpoint(serial: String) -> EmulatorEndpoint? {
+    guard let console = consolePort(serial: serial),
+      let names = try? FileManager.default.contentsOfDirectory(atPath: directory.path)
+    else { return nil }
+    for name in names where name.hasPrefix("pid_") && name.hasSuffix(".ini") {
+      guard let pid = Int32(name.dropFirst(4).dropLast(4)), kill(pid, 0) == 0,
+        let contents = try? String(contentsOf: directory.appendingPathComponent(name), encoding: .utf8),
+        let endpoint = parse(contents), endpoint.consolePort == console
+      else { continue }
+      return endpoint
+    }
+    return nil
+  }
+}

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/EmulatorPosture.swift

@@ -0,0 +1,73 @@
+import Foundation
+
+/// The posture of a foldable emulator, as the emulator's Posture.PostureValue
+/// numbers it.
+public enum EmulatorPosture: Int, CaseIterable, Sendable {
+  case closed = 1
+  case halfOpened = 2
+  case opened = 3
+  case flipped = 4
+  case tent = 5
+
+  public var label: String {
+    switch self {
+    case .closed: return "Folded"
+    case .halfOpened: return "Half open"
+    case .opened: return "Unfolded"
+    case .flipped: return "Flipped"
+    case .tent: return "Tent"
+    }
+  }
+
+  /// The emulator's current posture; nil for an emulator without a hinge, or
+  /// one whose endpoint cannot be reached.
+  public static func current(serial: String) async -> EmulatorPosture? {
+    guard let endpoint = EmulatorDiscovery.endpoint(serial: serial) else { return nil }
+    let input = EmulatorInput(endpoint: endpoint)
+    defer { input.close() }
+    return await input.call("getPhysicalModel", PostureMessages.postureTarget).flatMap(PostureMessages.posture)
+  }
+
+  /// Moves the hinge to this posture. Returns false when the emulator has no
+  /// endpoint or refuses the call.
+  public func apply(serial: String) async -> Bool {
+    guard let endpoint = EmulatorDiscovery.endpoint(serial: serial) else { return false }
+    let input = EmulatorInput(endpoint: endpoint)
+    defer { input.close() }
+    return await input.call("setPosture", PostureMessages.setPosture(self)) != nil
+  }
+}
+
+// Field numbers follow PhysicalModelValue, ParameterValue and Posture in the
+// emulator's emulator_controller.proto (sdk/emulator/lib); POSTURE is
+// PhysicalType 16, and its single value is the PostureValue as a float.
+enum PostureMessages {
+  static let postureTarget = Data([0x08, 0x10])
+
+  static func setPosture(_ posture: EmulatorPosture) -> Data {
+    Data([0x18, UInt8(posture.rawValue)])
+  }
+
+  static func posture(fromPhysicalModel bytes: Data) -> EmulatorPosture? {
+    var reader = ProtoReader(bytes)
+    while let (field, value) = reader.next() {
+      if field == 2, case .varint(let status) = value, status != 0 { return nil }
+      guard field == 3, case .bytes(let parameter) = value else { continue }
+      var values = ProtoReader(parameter)
+      while let (valueField, packed) = values.next() {
+        guard valueField == 1, case .bytes(let data) = packed, data.count >= 4 else { continue }
+        let raw = Float(bitPattern: data.prefix(4).reversed().reduce(0) { $0 << 8 | UInt32($1) })
+        return EmulatorPosture(rawValue: Int(raw.rounded()))
+      }
+    }
+    return nil
+  }
+}
+
+extension EmulatorInput {
+  func call(_ method: String, _ message: Data) async -> Data? {
+    await withCheckedContinuation { continuation in
+      call(method, message) { continuation.resume(returning: $0) }
+    }
+  }
+}

package/dist/stim-frames/EmulatorRotation.swift

@@ -0,0 +1,59 @@
+import Foundation
+
+/// Turns a running emulator a quarter turn through its gRPC endpoint. It sets
+/// the z angle of the ROTATION physical model, as turning a real device would,
+/// so the screen follows the app's and the system's rotation rules; with
+/// auto-rotate off, Android offers its rotate suggestion instead.
+public enum EmulatorRotation {
+  /// Returns false when the emulator has no endpoint or refuses the call.
+  public static func rotate(serial: String, clockwise: Bool) async -> Bool {
+    guard let endpoint = EmulatorDiscovery.endpoint(serial: serial) else { return false }
+    let input = EmulatorInput(endpoint: endpoint)
+    defer { input.close() }
+    guard let current = await input.call("getPhysicalModel", RotationMessages.rotationTarget) else { return false }
+    let angles = RotationMessages.angles(fromPhysicalModel: current)
+    let turned = RotationMessages.quarterTurn(z: angles.z, clockwise: clockwise)
+    let message = RotationMessages.rotation(x: angles.x, y: angles.y, z: turned)
+    return await input.call("setPhysicalModel", message) != nil
+  }
+}
+
+// Field numbers follow PhysicalModelValue and ParameterValue in the emulator's
+// emulator_controller.proto (sdk/emulator/lib); ROTATION is PhysicalType 1 and
+// its values are x, y and z angles in degrees.
+enum RotationMessages {
+  static let rotationTarget = Data([0x08, 0x01])
+
+  static func rotation(x: Float, y: Float, z: Float) -> Data {
+    var floats = Data()
+    for value in [x, y, z] { withUnsafeBytes(of: value.bitPattern.littleEndian) { floats += $0 } }
+    let parameter = Data([0x0a, UInt8(floats.count)]) + floats
+    return rotationTarget + Data([0x1a, UInt8(parameter.count)]) + parameter
+  }
+
+  /// The angles in a PhysicalModelValue; proto3 omits an all-zero value.
+  static func angles(fromPhysicalModel bytes: Data) -> (x: Float, y: Float, z: Float) {
+    var reader = ProtoReader(bytes)
+    while let (field, value) = reader.next() {
+      guard field == 3, case .bytes(let parameter) = value else { continue }
+      var values = ProtoReader(parameter)
+      while let (valueField, packed) = values.next() {
+        guard valueField == 1, case .bytes(let data) = packed, data.count >= 12 else { continue }
+        let floats = stride(from: 0, to: 12, by: 4).map { offset in
+          Float(bitPattern: data.dropFirst(offset).prefix(4).reversed().reduce(0) { $0 << 8 | UInt32($1) })
+        }
+        return (floats[0], floats[1], floats[2])
+      }
+    }
+    return (0, 0, 0)
+  }
+
+  /// The next z angle, in (-180, 180]; a positive angle turns the device counterclockwise.
+  static func quarterTurn(z: Float, clockwise: Bool) -> Float {
+    let quarter = (z / 90).rounded() * 90
+    var next = quarter + (clockwise ? -90 : 90)
+    if next > 180 { next -= 360 }
+    if next <= -180 { next += 360 }
+    return next
+  }
+}

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,123 @@
+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
+  static let keypress: UInt64 = 2
+
+  /// 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 TouchEvent with one finger on the main display, lifted when `pressed`
+  /// 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)
+    }
+    var out = Data()
+    appendBytes(field: 1, touch, to: &out)
+    return out
+  }
+
+  /// 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))])
+  }
+
+  /// A KeyboardEvent that presses and releases the key a DOM key name such as
+  /// `GoHome` or `Power` names.
+  static func namedKey(_ key: String) -> Data {
+    var out = message([(2, keypress)])
+    appendBytes(field: 4, Data(key.utf8), to: &out)
+    return out
+  }
+
+  /// 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)? {
+    let config = hardwareConfig(fromStatus: bytes)
+    guard let width = config["hw.lcd.width"].flatMap({ Int($0) }), let height = config["hw.lcd.height"].flatMap({ Int($0) }),
+      width > 0, height > 0
+    else { return nil }
+    return (width, height)
+  }
+
+  /// Whether the emulator has a hardware keyboard (`hw.keyboard` in an
+  /// EmulatorStatus's hardwareConfig). Without one it drops every KeyboardEvent.
+  static func hasKeyboard(fromStatus bytes: Data) -> Bool {
+    hardwareConfig(fromStatus: bytes)["hw.keyboard"] == "true"
+  }
+
+  private static func hardwareConfig(fromStatus bytes: Data) -> [String: String] {
+    var reader = ProtoReader(bytes)
+    var config: [String: String] = [:]
+    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 }
+        config[key] = value
+      }
+    }
+    return config
+  }
+
+  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
+  }
+}
+
+/// Maps a fraction of the upright image, origin top-left, to a pixel of the
+/// display in its native orientation, which is where the emulator places
+/// touches. `rotation` is the image's Rotation.SkinRotation.
+func displayPixel(_ point: CGPoint, rotation: Int, displaySize: CGSize) -> (x: Int, y: Int) {
+  let native: CGPoint
+  switch rotation {
+  case 1: native = CGPoint(x: 1 - point.y, y: point.x)
+  case 2: native = CGPoint(x: 1 - point.x, y: 1 - point.y)
+  case 3: native = CGPoint(x: point.y, y: 1 - point.x)
+  default: native = point
+  }
+  let x = Int((native.x * displaySize.width).rounded(.down))
+  let y = Int((native.y * displaySize.height).rounded(.down))
+  return (min(max(x, 0), Int(displaySize.width) - 1), min(max(y, 0), Int(displaySize.height) - 1))
+}

package/dist/stim-frames/ScreenshotMessages.swift

@@ -0,0 +1,152 @@
+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
+  /// The display's own size while a foldable is folded; the frame already
+  /// shows only that display. Touches address its pixels, not the unfolded
+  /// display's.
+  public var folded: (width: Int, height: 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, folded: (width: Int, height: 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, folded: size.folded, rgba: image)
+  }
+
+  private static func rgbaSize(_ bytes: Data) -> (
+    width: Int, height: Int, rotation: Int, folded: (width: Int, height: Int)?
+  )? {
+    var reader = ProtoReader(bytes)
+    var format: UInt64 = 0
+    var width = 0
+    var height = 0
+    var rotation = 0
+    var folded: (width: Int, height: Int)?
+    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)
+      case (7, .bytes(let nested)): folded = foldedSize(nested)
+      default: break
+      }
+    }
+    guard format == rgba8888 else { return nil }
+    return (width, height, rotation, folded)
+  }
+
+  private static func foldedSize(_ bytes: Data) -> (width: Int, height: Int)? {
+    var reader = ProtoReader(bytes)
+    var width = 0
+    var height = 0
+    while let (field, value) = reader.next() {
+      switch (field, value) {
+      case (1, .varint(let v)): width = Int(v)
+      case (2, .varint(let v)): height = Int(v)
+      default: break
+      }
+    }
+    return width > 0 && height > 0 ? (width, height) : nil
+  }
+
+  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
+  }
+}