@stim-cli/server 1.13.0 → 1.15.0

package/dist/stim-frames/DevToolsClient.swift

@@ -0,0 +1,180 @@
+import Foundation
+
+public struct DevToolsError: Error, CustomStringConvertible {
+  public let description: String
+
+  public init(_ description: String) {
+    self.description = description
+  }
+}
+
+/// One JSON message of the DevTools protocol: the reply to a command, or an event.
+enum DevToolsMessage {
+  case reply(id: Int, Result<[String: Any], DevToolsError>)
+  case event(DevToolsClient.Event)
+
+  /// Nil when `data` is not a JSON object with an `id` or a `method`. A message with an `id` is a reply.
+  init?(_ data: Data) {
+    guard let object = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else { return nil }
+    if let id = object["id"] as? Int {
+      if let error = object["error"] as? [String: Any] {
+        self = .reply(id: id, .failure(DevToolsError(error["message"] as? String ?? "DevTools command failed.")))
+      } else {
+        self = .reply(id: id, .success(object["result"] as? [String: Any] ?? [:]))
+      }
+    } else if let method = object["method"] as? String {
+      self = .event((method, object["params"] as? [String: Any] ?? [:], object["sessionId"] as? String))
+    } else {
+      return nil
+    }
+  }
+}
+
+/// A Chrome DevTools Protocol connection to the browser endpoint of a Chrome Stim owns. `connect` refuses an
+/// endpoint whose browser process is not `chromePid`, the pid `stim status` reports, the same rule the CLI's
+/// `connectOwnedBrowser` applies: the loopback port alone does not prove which Chrome answers it.
+public final class DevToolsClient: @unchecked Sendable {
+  public typealias Event = (method: String, params: [String: Any], sessionId: String?)
+
+  private let task: URLSessionWebSocketTask
+  private let session: URLSession
+  private let queue = DispatchQueue(label: "stim.web.devtools")
+  private var pending: [Int: (Result<[String: Any], DevToolsError>) -> Void] = [:]
+  private var nextId = 1
+  private var closed = false
+  private var eventHandler: ((Event) -> Void)?
+  private var closeHandlers: [() -> Void] = []
+
+  private init(url: URL) {
+    session = URLSession(configuration: .ephemeral)
+    task = session.webSocketTask(with: url)
+    task.maximumMessageSize = 64 << 20
+  }
+
+  /// `endpoint` is `web.cdpEndpoint` from `stim status`, `http://127.0.0.1:<port>`.
+  public static func connect(
+    endpoint: URL, chromePid: Int32, completion: @escaping (Result<DevToolsClient, DevToolsError>) -> Void
+  ) {
+    guard endpoint.host == "127.0.0.1", let port = endpoint.port else {
+      return completion(.failure(DevToolsError("\(endpoint) is not a loopback DevTools endpoint.")))
+    }
+    var request = URLRequest(url: endpoint.appendingPathComponent("json/version"))
+    request.timeoutInterval = 3
+    URLSession.shared.dataTask(with: request) { data, _, error in
+      guard let data, let object = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
+        let socket = object["webSocketDebuggerUrl"] as? String, socket.hasPrefix("ws://127.0.0.1:\(port)/"),
+        let url = URL(string: socket)
+      else {
+        let reason = error?.localizedDescription ?? "it does not serve a browser DevTools endpoint"
+        return completion(.failure(DevToolsError("Port \(port): \(reason).")))
+      }
+      let client = DevToolsClient(url: url)
+      client.start()
+      client.send("SystemInfo.getProcessInfo") { result in
+        switch result {
+        case .failure(let failure):
+          client.close()
+          completion(.failure(failure))
+        case .success(let reply):
+          let processes = reply["processInfo"] as? [[String: Any]] ?? []
+          let browser = processes.first { $0["type"] as? String == "browser" }?["id"] as? Int
+          guard browser == Int(chromePid) else {
+            client.close()
+            let found = browser.map(String.init) ?? "unknown"
+            return completion(
+              .failure(DevToolsError("Port \(port) is served by browser pid \(found), not the owned Chrome \(chromePid).")))
+          }
+          completion(.success(client))
+        }
+      }
+    }.resume()
+  }
+
+  private func start() {
+    task.resume()
+    receive()
+  }
+
+  /// Events arrive on the client's private queue, in order.
+  public func onEvent(_ handler: @escaping (Event) -> Void) {
+    queue.async { self.eventHandler = handler }
+  }
+
+  public func onClose(_ handler: @escaping () -> Void) {
+    queue.async {
+      if self.closed { handler() } else { self.closeHandlers.append(handler) }
+    }
+  }
+
+  public func send(
+    _ method: String, _ params: [String: Any] = [:], sessionId: String? = nil,
+    reply: ((Result<[String: Any], DevToolsError>) -> Void)? = nil
+  ) {
+    queue.async {
+      guard !self.closed else {
+        reply?(.failure(DevToolsError("The DevTools connection is closed.")))
+        return
+      }
+      let id = self.nextId
+      self.nextId += 1
+      var message: [String: Any] = ["id": id, "method": method, "params": params]
+      if let sessionId { message["sessionId"] = sessionId }
+      guard let data = try? JSONSerialization.data(withJSONObject: message),
+        let text = String(data: data, encoding: .utf8)
+      else {
+        reply?(.failure(DevToolsError("\(method) has parameters that are not JSON.")))
+        return
+      }
+      if let reply { self.pending[id] = reply }
+      self.task.send(.string(text)) { error in
+        guard let error else { return }
+        self.queue.async { self.pending.removeValue(forKey: id)?(.failure(DevToolsError(error.localizedDescription))) }
+      }
+    }
+  }
+
+  public func close() {
+    queue.async { self.finish() }
+  }
+
+  private func receive() {
+    task.receive { [weak self] result in
+      guard let self else { return }
+      self.queue.async {
+        switch result {
+        case .failure:
+          self.finish()
+        case .success(let message):
+          switch message {
+          case .string(let text): self.handle(Data(text.utf8))
+          case .data(let data): self.handle(data)
+          @unknown default: break
+          }
+          if !self.closed { self.receive() }
+        }
+      }
+    }
+  }
+
+  private func handle(_ data: Data) {
+    switch DevToolsMessage(data) {
+    case .reply(let id, let result): pending.removeValue(forKey: id)?(result)
+    case .event(let event): eventHandler?(event)
+    case nil: break
+    }
+  }
+
+  private func finish() {
+    guard !closed else { return }
+    closed = true
+    eventHandler = nil
+    task.cancel(with: .normalClosure, reason: nil)
+    session.invalidateAndCancel()
+    let replies = pending.values
+    pending = [:]
+    for reply in replies { reply(.failure(DevToolsError("The DevTools connection closed."))) }
+    let handlers = closeHandlers
+    closeHandlers = []
+    for handler in handlers { handler() }
+  }
+}

package/dist/stim-frames/DeviceFrameGeometry.swift

@@ -0,0 +1,41 @@
+import CoreGraphics
+
+/// Installed frame coordinates use a top-left origin, with the screen kept at its native aspect ratio.
+public struct DeviceFrameGeometry: Equatable, Sendable {
+  public var size: CGSize
+  public var aperture: CGRect
+
+  public init(size: CGSize, aperture: CGRect) {
+    self.size = size
+    self.aperture = aperture
+  }
+
+  public func rotated(quarterTurns: Int) -> Self {
+    switch (quarterTurns % 4 + 4) % 4 {
+    case 1:
+      return Self(
+        size: CGSize(width: size.height, height: size.width),
+        aperture: CGRect(x: size.height - aperture.maxY, y: aperture.minX, width: aperture.height, height: aperture.width))
+    case 2:
+      return Self(
+        size: size,
+        aperture: CGRect(
+          x: size.width - aperture.maxX, y: size.height - aperture.maxY, width: aperture.width, height: aperture.height))
+    case 3:
+      return Self(
+        size: CGSize(width: size.height, height: size.width),
+        aperture: CGRect(x: aperture.minY, y: size.width - aperture.maxX, width: aperture.height, height: aperture.width))
+    default: return self
+    }
+  }
+
+  public func fitted(in bounds: CGRect, scale: CGFloat? = nil) -> Self {
+    let scale = scale ?? min(bounds.width / size.width, bounds.height / size.height)
+    let origin = CGPoint(x: bounds.midX - size.width * scale / 2, y: bounds.midY - size.height * scale / 2)
+    return Self(
+      size: CGSize(width: size.width * scale, height: size.height * scale),
+      aperture: CGRect(
+        x: origin.x + aperture.minX * scale, y: origin.y + aperture.minY * scale,
+        width: aperture.width * scale, height: aperture.height * scale))
+  }
+}

package/dist/stim-frames/DeviceFrameView.swift

@@ -0,0 +1,167 @@
+import AppKit
+
+/// Artwork is loaded from the user's installed developer tools, never bundled with Stim.
+@MainActor
+public final class DeviceFrameArtwork {
+  public let geometry: DeviceFrameGeometry
+  public let cornerRadius: CGFloat
+  let background: (CGRect) -> Void
+  let foreground: (CGRect) -> Void
+
+  public init(
+    geometry: DeviceFrameGeometry, cornerRadius: CGFloat = 0,
+    background: @escaping (CGRect) -> Void, foreground: @escaping (CGRect) -> Void = { _ in }
+  ) {
+    self.geometry = geometry
+    self.cornerRadius = cornerRadius
+    self.background = background
+    self.foreground = foreground
+  }
+
+  /// Rasterizes installed artwork in upright frame coordinates, keeping screen pixels out of both PNG layers.
+  public func pngLayers(quarterTurns: Int) -> (background: Data, foreground: Data)? {
+    let size = geometry.rotated(quarterTurns: quarterTurns).size
+    let scale = min(1, 2048 / max(size.width, size.height))
+    let bounds = CGRect(x: 0, y: 0, width: ceil(size.width * scale), height: ceil(size.height * scale))
+    func layer(foreground: Bool) -> Data? {
+      guard
+        let bitmap = NSBitmapImageRep(
+          bitmapDataPlanes: nil, pixelsWide: Int(bounds.width), pixelsHigh: Int(bounds.height),
+          bitsPerSample: 8, samplesPerPixel: 4, hasAlpha: true, isPlanar: false,
+          colorSpaceName: .deviceRGB, bytesPerRow: 0, bitsPerPixel: 0),
+        let context = NSGraphicsContext(bitmapImageRep: bitmap)
+      else { return nil }
+      NSGraphicsContext.saveGraphicsState()
+      defer { NSGraphicsContext.restoreGraphicsState() }
+      context.cgContext.clear(bounds)
+      context.cgContext.translateBy(x: 0, y: bounds.height)
+      context.cgContext.scaleBy(x: 1, y: -1)
+      NSGraphicsContext.current = NSGraphicsContext(cgContext: context.cgContext, flipped: true)
+      drawFrameArtwork(self, quarterTurns: quarterTurns, in: bounds, scale: nil, offset: .zero, foreground: foreground)
+      return bitmap.representation(using: .png, properties: [:])
+    }
+    guard let background = layer(foreground: false), let foreground = layer(foreground: true) else { return nil }
+    return (background, foreground)
+  }
+}
+
+/// Keeps the existing display/input view inside the installed artwork's screen aperture.
+@MainActor
+public final class DeviceFrameNSView: NSView {
+  public let screen: NSView
+  public var artwork: DeviceFrameArtwork? { didSet { updateFrame() } }
+  public var showsFrame = false { didSet { if oldValue != showsFrame { updateFrame() } } }
+  public var quarterTurns = 0 { didSet { if oldValue != quarterTurns { updateFrame() } } }
+  public var artworkScale: CGFloat? { didSet { if oldValue != artworkScale { updateFrame() } } }
+  public var accurateScreenSize: CGSize? { didSet { if oldValue != accurateScreenSize { updateFrame() } } }
+  public var onFrameSizeChange: (CGSize?) -> Void = { _ in }
+  private let overlay = FrameOverlay()
+  private var reportedSize: CGSize?
+  private var artworkOffset = CGPoint.zero
+  public override var isFlipped: Bool { true }
+
+  public init(screen: NSView) {
+    self.screen = screen
+    super.init(frame: .zero)
+    addSubview(screen)
+    addSubview(overlay)
+  }
+
+  required init?(coder: NSCoder) { nil }
+
+  private var activeArtwork: DeviceFrameArtwork? { showsFrame ? artwork : nil }
+
+  private func updateFrame() {
+    needsLayout = true
+    needsDisplay = true
+    overlay.needsDisplay = true
+    let size = artwork?.geometry.rotated(quarterTurns: quarterTurns).size
+    guard size != reportedSize else { return }
+    reportedSize = size
+    DispatchQueue.main.async { [weak self] in self?.onFrameSizeChange(size) }
+  }
+
+  public override func layout() {
+    super.layout()
+    overlay.frame = bounds
+    overlay.artwork = activeArtwork
+    overlay.quarterTurns = quarterTurns
+    overlay.scale = artworkScale
+    artworkOffset = .zero
+    var aperture = bounds
+    if let art = activeArtwork {
+      let geometry = art.geometry.rotated(quarterTurns: quarterTurns)
+      aperture = geometry.fitted(in: bounds, scale: artworkScale).aperture
+    } else if let size = accurateScreenSize {
+      aperture = CGRect(x: bounds.midX - size.width / 2, y: bounds.midY - size.height / 2, width: size.width, height: size.height)
+    }
+    if artworkScale != nil || accurateScreenSize != nil {
+      let backing = window?.backingScaleFactor ?? 1
+      let origin = convert(aperture.origin, to: nil)
+      let aligned = convert(
+        CGPoint(x: (origin.x * backing).rounded() / backing, y: (origin.y * backing).rounded() / backing), from: nil)
+      artworkOffset = CGPoint(x: aligned.x - aperture.minX, y: aligned.y - aperture.minY)
+      aperture.origin = aligned
+    }
+    screen.frame = aperture
+    if let art = activeArtwork {
+      let geometry = art.geometry.rotated(quarterTurns: quarterTurns)
+      screen.layer?.cornerRadius = art.cornerRadius * aperture.width / geometry.aperture.width
+    } else {
+      screen.layer?.cornerRadius = 0
+    }
+    screen.layer?.masksToBounds = activeArtwork != nil
+    overlay.offset = artworkOffset
+    needsDisplay = true
+    overlay.needsDisplay = true
+  }
+
+  public override func draw(_ dirtyRect: NSRect) {
+    drawFrameArtwork(
+      activeArtwork, quarterTurns: quarterTurns, in: bounds, scale: artworkScale, offset: artworkOffset, foreground: false)
+  }
+}
+
+@MainActor
+private final class FrameOverlay: NSView {
+  var artwork: DeviceFrameArtwork?
+  var quarterTurns = 0
+  var scale: CGFloat?
+  var offset = CGPoint.zero
+  override var isFlipped: Bool { true }
+  override func hitTest(_ point: NSPoint) -> NSView? { nil }
+  override func draw(_ dirtyRect: NSRect) {
+    drawFrameArtwork(artwork, quarterTurns: quarterTurns, in: bounds, scale: scale, offset: offset, foreground: true)
+  }
+}
+
+@MainActor
+private func drawFrameArtwork(
+  _ artwork: DeviceFrameArtwork?, quarterTurns: Int, in bounds: CGRect, scale: CGFloat?, offset: CGPoint, foreground: Bool
+) {
+  guard let artwork, let context = NSGraphicsContext.current?.cgContext else { return }
+  let turns = (quarterTurns % 4 + 4) % 4
+  let size = artwork.geometry.rotated(quarterTurns: turns).size
+  let scale = scale ?? min(bounds.width / size.width, bounds.height / size.height)
+  context.saveGState()
+  defer { context.restoreGState() }
+  context.translateBy(x: bounds.midX - size.width * scale / 2 + offset.x, y: bounds.midY - size.height * scale / 2 + offset.y)
+  context.scaleBy(x: scale, y: scale)
+  switch turns {
+  case 1:
+    context.translateBy(x: artwork.geometry.size.height, y: 0)
+    context.rotate(by: .pi / 2)
+  case 2:
+    context.translateBy(x: artwork.geometry.size.width, y: artwork.geometry.size.height)
+    context.rotate(by: .pi)
+  case 3:
+    context.translateBy(x: 0, y: artwork.geometry.size.width)
+    context.rotate(by: -.pi / 2)
+  default: break
+  }
+  if foreground {
+    artwork.foreground(CGRect(origin: .zero, size: artwork.geometry.size))
+  } else {
+    artwork.background(CGRect(origin: .zero, size: artwork.geometry.size))
+  }
+}

package/dist/stim-frames/DuoCaptureSource.swift

@@ -0,0 +1,132 @@
+import AppKit
+import IOSurface
+
+@MainActor
+final class DuoCaptureSource {
+  private let udid: String
+  private let changed: () -> Void
+  private let renderer: DuoFrameRenderer?
+  private var requested: DuoCapture?
+  private var monitor: Process?
+  private var input: Pipe?
+  private var angle: Double?
+  private var available: Bool?
+
+  init(udid: String, changed: @escaping () -> Void) {
+    self.udid = udid
+    self.changed = changed
+    renderer = DuoFrameRenderer.load(udid: udid)
+  }
+
+  func configure(_ requested: DuoCapture?) -> DuoFrameRenderer.Touch? {
+    self.requested = requested
+    guard requested != nil, renderer != nil else {
+      input?.fileHandleForWriting.closeFile()
+      input = nil
+      angle = nil
+      publish(false)
+      return renderer?.release()
+    }
+    if monitor == nil { startMonitor() }
+    return nil
+  }
+
+  func render(
+    surfaces: [(screenID: UInt32, surface: IOSurface?)], activeID: UInt32,
+    orientation: UInt32, viewport: CGSize, config: Config
+  ) {
+    guard let requested, let renderer, let angle else { return publish(false) }
+    var composed = config
+    composed.maxEdge = requested.maxEdge
+    let scale = min(1, CGFloat(requested.maxEdge) / max(viewport.width, viewport.height))
+    let canvas = CGSize(width: viewport.width * scale, height: viewport.height * scale)
+    guard
+      let frame = renderer.render(
+        surfaces: surfaces, activeID: activeID, orientation: orientation,
+        angle: angle, viewport: canvas, config: composed
+      )
+    else { return publish(false) }
+    Output.duoFrame(frame)
+    publish(true)
+  }
+
+  func touch(_ phase: TouchPhase, point: CGPoint, revision: String) -> DuoFrameRenderer.Touch? {
+    guard requested != nil else { return nil }
+    return renderer?.touch(phase: phase, at: point, revision: revision)
+  }
+
+  func release() -> DuoFrameRenderer.Touch? { renderer?.release() }
+
+  private func publish(_ next: Bool) {
+    guard next != available else { return }
+    available = next
+    Output.notice(["duoAvailable": next])
+  }
+
+  private func startMonitor() {
+    guard requested != nil, renderer != nil, monitor == nil else { return }
+    let process = Process()
+    process.executableURL = URL(fileURLWithPath: CommandLine.arguments[0])
+    process.arguments = ["hinge-monitor", udid]
+    var environment = ProcessInfo.processInfo.environment
+    environment["DEVELOPER_DIR"] = CoreSimulator.developerDir
+    process.environment = environment
+    let hold = Pipe()
+    let output = Pipe()
+    process.standardInput = hold
+    process.standardOutput = output
+    process.standardError = FileHandle.nullDevice
+    let buffer = DuoMonitorLines()
+    output.fileHandleForReading.readabilityHandler = { [weak self] handle in
+      let bytes = handle.availableData
+      if bytes.isEmpty {
+        handle.readabilityHandler = nil
+        return
+      }
+      let samples = buffer.append(bytes).compactMap(SimulatorHingeAngle.parse)
+      guard let newest = samples.last else { return }
+      DispatchQueue.main.async {
+        MainActor.assumeIsolated {
+          guard let self, self.monitor === process else { return }
+          self.angle = newest
+          self.changed()
+        }
+      }
+    }
+    process.terminationHandler = { [weak self] _ in
+      output.fileHandleForReading.readabilityHandler = nil
+      DispatchQueue.main.async {
+        MainActor.assumeIsolated {
+          guard let self, self.monitor === process else { return }
+          self.monitor = nil
+          self.input = nil
+          self.angle = nil
+          self.publish(false)
+          self.changed()
+          DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
+            MainActor.assumeIsolated { self.startMonitor() }
+          }
+        }
+      }
+    }
+    do {
+      try process.run()
+      monitor = process
+      input = hold
+    } catch {
+      output.fileHandleForReading.readabilityHandler = nil
+      publish(false)
+    }
+  }
+}
+
+private final class DuoMonitorLines: @unchecked Sendable {
+  private let lock = NSLock()
+  private var buffer = LineBuffer()
+
+  func append(_ data: Data) -> [String] {
+    lock.lock()
+    defer { lock.unlock() }
+    return buffer.append(data)
+  }
+}

package/dist/stim-frames/DuoDeviceProfile.swift

@@ -0,0 +1,37 @@
+import Foundation
+
+@MainActor
+struct DuoDeviceProfile {
+  let inner: UInt32
+  let cover: UInt32
+  let turns: [UInt32: Int]
+
+  static func load(udid: String) -> DuoDeviceProfile? {
+    guard let resources = SimulatorFrameArtwork.resources(udid: udid),
+      Bundle(url: resources.deletingLastPathComponent().deletingLastPathComponent())?.bundleIdentifier
+        == "com.apple.CoreSimulator.SimDeviceType.iPhone-Duo",
+      let data = try? Data(contentsOf: resources.appendingPathComponent("capabilities.plist")),
+      let plist = try? PropertyListSerialization.propertyList(from: data, format: nil) as? [String: Any],
+      let capabilities = plist["capabilities"] as? [String: Any],
+      let all = capabilities["displays"] as? [[String: Any]]
+    else { return nil }
+    let integrated = all.filter { $0["displayType"] as? String == "integrated" }
+    guard integrated.count == 2 else { return nil }
+    let sorted = integrated.sorted { area($0) < area($1) }
+    guard let cover = sorted[0]["screenID"] as? NSNumber,
+      let inner = sorted[1]["screenID"] as? NSNumber, cover != inner
+    else { return nil }
+    var turns: [UInt32: Int] = [:]
+    for display in sorted {
+      guard let id = display["screenID"] as? NSNumber,
+        let rotation = display["nativeRotation"] as? NSNumber, rotation.intValue % 90 == 0
+      else { return nil }
+      turns[id.uint32Value] = (-rotation.intValue / 90 % 4 + 4) % 4
+    }
+    return DuoDeviceProfile(inner: inner.uint32Value, cover: cover.uint32Value, turns: turns)
+  }
+
+  private static func area(_ display: [String: Any]) -> Double {
+    ((display["width"] as? NSNumber)?.doubleValue ?? 0) * ((display["height"] as? NSNumber)?.doubleValue ?? 0)
+  }
+}

package/dist/stim-frames/DuoFrameRenderer.swift

@@ -0,0 +1,111 @@
+import AppKit
+import CoreImage
+import IOSurface
+import SceneKit
+
+@MainActor
+final class DuoFrameRenderer {
+  struct Frame {
+    let jpeg: Data
+    let width: Int
+    let height: Int
+    let revision: String
+    let screenID: UInt32
+    let angle: Double
+    let orientation: UInt32
+  }
+
+  struct Touch {
+    let point: CGPoint
+    let screenID: UInt32
+  }
+
+  private struct Pose: Equatable {
+    let angle: Double
+    let orientation: UInt32
+    let screenID: UInt32
+    let viewport: CGSize
+  }
+
+  private let model: DuoModelView
+  private let inputModel: DuoModelView
+  private var poses: [(revision: String, pose: Pose)] = []
+  private var gesture: (revision: String, pose: Pose, last: CGPoint)?
+  private var rendered: Pose?
+
+  static func load(udid: String) -> DuoFrameRenderer? {
+    guard let profile = DuoDeviceProfile.load(udid: udid),
+      let model = DuoModelView.load(innerID: profile.inner, coverID: profile.cover, nativeTurns: profile.turns),
+      let inputModel = DuoModelView.load(innerID: profile.inner, coverID: profile.cover, nativeTurns: profile.turns)
+    else { return nil }
+    return DuoFrameRenderer(model: model, inputModel: inputModel)
+  }
+
+  private init(model: DuoModelView, inputModel: DuoModelView) {
+    self.model = model
+    self.inputModel = inputModel
+  }
+
+  func render(
+    surfaces: [(screenID: UInt32, surface: IOSurface?)], activeID: UInt32,
+    orientation: UInt32, angle: Double, viewport: CGSize, config: Config
+  ) -> Frame? {
+    guard angle.isFinite, (0...180).contains(angle), viewport.width > 0, viewport.height > 0,
+      activeID == model.coverID || activeID == model.innerID
+    else { return nil }
+    model.frame = CGRect(origin: .zero, size: viewport)
+    model.layoutSubtreeIfNeeded()
+    model.setPose(angle: CGFloat(angle), orientation: orientation, activeID: activeID)
+    for surface in surfaces where surface.screenID == model.coverID || surface.screenID == model.innerID {
+      model.updateSurface(surface.surface, screenID: surface.screenID)
+    }
+    let pose = Pose(angle: angle, orientation: orientation, screenID: activeID, viewport: viewport)
+    if pose != rendered {
+      // A hidden SCNView can return the previous skinned frame after a pose change; flush and
+      // discard one snapshot first. https://github.com/kmagiera/Siniulator/pull/9
+      SCNTransaction.flush()
+      _ = model.snapshot()
+      rendered = pose
+    }
+    guard let image = model.snapshot().cgImage(forProposedRect: nil, context: nil, hints: nil),
+      let (data, width, height) = jpeg(CIImage(cgImage: image), config: config)
+    else { return nil }
+    model.preparePanelChange()
+    let revision: String
+    if let previous = poses.last, previous.pose == pose {
+      revision = previous.revision
+    } else {
+      revision = UUID().uuidString
+      poses.append((revision, pose))
+      if poses.count > 32 { poses.removeFirst() }
+    }
+    return Frame(
+      jpeg: data, width: width, height: height, revision: revision, screenID: activeID, angle: angle, orientation: orientation)
+  }
+
+  func touch(phase: TouchPhase, at point: CGPoint, revision: String) -> Touch? {
+    let pose: Pose
+    if phase == .down {
+      guard gesture == nil, let shown = poses.first(where: { $0.revision == revision }) else { return nil }
+      pose = shown.pose
+    } else {
+      guard let held = gesture, held.revision == revision else { return nil }
+      pose = held.pose
+    }
+    inputModel.frame = CGRect(origin: .zero, size: pose.viewport)
+    inputModel.layoutSubtreeIfNeeded()
+    inputModel.setPose(angle: CGFloat(pose.angle), orientation: pose.orientation, activeID: pose.screenID)
+    let location = CGPoint(x: point.x * pose.viewport.width, y: (1 - point.y) * pose.viewport.height)
+    guard let native = inputModel.nativeScreenPoint(location, clamped: phase != .down) else {
+      return phase == .up ? release() : nil
+    }
+    gesture = phase == .up ? nil : (revision, pose, native)
+    return Touch(point: native, screenID: pose.screenID)
+  }
+
+  func release() -> Touch? {
+    guard let held = gesture else { return nil }
+    gesture = nil
+    return Touch(point: held.last, screenID: held.pose.screenID)
+  }
+}