@stim-cli/server 1.13.0 → 1.15.0

package/dist/stim-frames/DuoHingeMonitor.swift

@@ -0,0 +1,89 @@
+import Darwin
+import Foundation
+
+enum DuoHingeMonitor {
+  static func run(udid: String) -> Never {
+    let parent = getppid()
+    guard parent > 1 else { exit(1) }
+    let queue = DispatchQueue(label: "stim.frames.hinge-monitor")
+    var child: pid_t = 0
+    var stopping = false
+    let stop = {
+      guard !stopping else { return }
+      stopping = true
+      guard child > 0 else { exit(0) }
+      kill(child, SIGINT)
+      queue.asyncAfter(deadline: .now() + 1) {
+        if child > 0 { kill(child, SIGKILL) }
+      }
+    }
+    let parentExit = DispatchSource.makeProcessSource(identifier: parent, eventMask: .exit, queue: queue)
+    parentExit.setEventHandler(handler: stop)
+    parentExit.resume()
+    let reap = DispatchSource.makeTimerSource(queue: queue)
+    reap.schedule(deadline: .now(), repeating: .milliseconds(100))
+    reap.setEventHandler {
+      guard child > 0 else { return }
+      var status: Int32 = 0
+      if waitpid(child, &status, WNOHANG) == child {
+        child = 0
+        exit(0)
+      }
+    }
+    reap.resume()
+    var signals: [DispatchSourceSignal] = []
+    for value in [SIGTERM, SIGINT] {
+      signal(value, SIG_IGN)
+      let source = DispatchSource.makeSignalSource(signal: value, queue: queue)
+      source.setEventHandler(handler: stop)
+      source.resume()
+      signals.append(source)
+    }
+    Thread.detachNewThread {
+      _ = FileHandle.standardInput.readDataToEndOfFile()
+      queue.async(execute: stop)
+    }
+    queue.asyncAfter(deadline: .now() + 60, execute: stop)
+    queue.async {
+      guard !stopping, getppid() == parent else { return stop() }
+      let arguments = [
+        "/usr/bin/xcrun", "devicectl", "device", "motion", "hinge-angle", "--device", udid,
+        "--session-timeout", "55", "--timeout", "60", "--change-threshold", "1", "--update-interval", "0.5",
+      ]
+      var environment = ProcessInfo.processInfo.environment
+      environment["DEVELOPER_DIR"] = CoreSimulator.developerDir
+      environment["LC_ALL"] = "en_US.UTF-8"
+      let argv = arguments.map { strdup($0) } + [nil]
+      let env = environment.map { strdup("\($0.key)=\($0.value)") } + [nil]
+      defer {
+        for pointer in argv + env { free(pointer) }
+      }
+      var actions: posix_spawn_file_actions_t?
+      guard posix_spawn_file_actions_init(&actions) == 0 else { exit(1) }
+      defer { posix_spawn_file_actions_destroy(&actions) }
+      guard posix_spawn_file_actions_addopen(&actions, STDIN_FILENO, "/dev/null", O_RDONLY, 0) == 0,
+        posix_spawn_file_actions_addopen(&actions, STDERR_FILENO, "/dev/null", O_WRONLY, 0) == 0
+      else { exit(1) }
+      var attributes: posix_spawnattr_t?
+      guard posix_spawnattr_init(&attributes) == 0 else { exit(1) }
+      defer { posix_spawnattr_destroy(&attributes) }
+      var defaults = sigset_t()
+      sigemptyset(&defaults)
+      sigaddset(&defaults, SIGINT)
+      sigaddset(&defaults, SIGTERM)
+      var mask = sigset_t()
+      sigemptyset(&mask)
+      guard posix_spawnattr_setsigdefault(&attributes, &defaults) == 0,
+        posix_spawnattr_setsigmask(&attributes, &mask) == 0,
+        posix_spawnattr_setflags(&attributes, Int16(POSIX_SPAWN_SETSIGDEF | POSIX_SPAWN_SETSIGMASK)) == 0
+      else { exit(1) }
+      let result = argv.withUnsafeBufferPointer { argv in
+        env.withUnsafeBufferPointer { env in
+          posix_spawn(&child, "/usr/bin/xcrun", &actions, &attributes, argv.baseAddress!, env.baseAddress!)
+        }
+      }
+      guard result == 0 else { exit(1) }
+    }
+    withExtendedLifetime((parentExit, reap, signals)) { dispatchMain() }
+  }
+}

package/dist/stim-frames/DuoMesh.swift

@@ -0,0 +1,100 @@
+// Copyright (c) 2026 Siniulator contributors. Adapted under the MIT license in Support/Siniulator-LICENSE.txt.
+import SceneKit
+import simd
+
+@MainActor struct DuoMesh {
+  let node: SCNNode
+  let vertices: [SIMD4<Float>]
+  let bones: [SCNNode]
+  let binds: [simd_float4x4]
+  let influences: [[(index: Int, weight: Float)]]
+
+  init?(node: SCNNode) {
+    guard let source = node.geometry?.sources(for: .vertex).first,
+      source.componentsPerVector == 3, let values = Self.components(source),
+      values.allSatisfy({ Float($0).isFinite })
+    else { return nil }
+    self.node = node
+    vertices = stride(from: 0, to: values.count, by: 3).map {
+      SIMD4(Float(values[$0]), Float(values[$0 + 1]), Float(values[$0 + 2]), 1)
+    }
+    guard let skin = node.skinner else {
+      bones = []
+      binds = []
+      influences = []
+      return
+    }
+    bones = skin.bones
+    let bind = simd_float4x4(skin.baseGeometryBindTransform)
+    binds =
+      (skin.boneInverseBindTransforms?.map { simd_float4x4($0.scnMatrix4Value) }
+      ?? Array(repeating: matrix_identity_float4x4, count: bones.count)).map { $0 * bind }
+    guard !bones.isEmpty, binds.count == bones.count else { return nil }
+    if skin.boneWeights.vectorCount == 0, skin.boneIndices.vectorCount == 0 {
+      guard bones.count == 1 else { return nil }
+      influences = vertices.map { _ in [(0, 1)] }
+      return
+    }
+    guard skin.boneWeights.vectorCount == vertices.count,
+      skin.boneIndices.vectorCount == vertices.count,
+      skin.boneWeights.componentsPerVector == skin.boneIndices.componentsPerVector,
+      let indices = Self.components(skin.boneIndices),
+      let weights = Self.components(skin.boneWeights), indices.count == weights.count,
+      indices.allSatisfy({ $0.isFinite && $0 >= 0 && $0 < Double(skin.bones.count) && $0.rounded() == $0 }),
+      weights.allSatisfy({ Float($0).isFinite && $0 >= 0 })
+    else { return nil }
+    let count = skin.boneIndices.componentsPerVector
+    influences = vertices.indices.map { vertex in
+      (0..<count).compactMap { offset in
+        let index = vertex * count + offset
+        return weights[index] > 0 ? (Int(indices[index]), Float(weights[index])) : nil
+      }
+    }
+    guard influences.allSatisfy({ !$0.isEmpty }) else { return nil }
+  }
+
+  var transforms: [simd_float4x4] {
+    bones.isEmpty
+      ? [node.simdWorldTransform]
+      : bones.indices.map {
+        bones[$0].simdWorldTransform * binds[$0]
+      }
+  }
+
+  func position(at index: Int, using transforms: [simd_float4x4]) -> SIMD4<Float> {
+    let vertex = vertices[index]
+    if influences.isEmpty { return transforms[0] * vertex }
+    return influences[index].reduce(SIMD4<Float>.zero) {
+      $0 + transforms[$1.index] * vertex * $1.weight
+    }
+  }
+
+  static func components(_ source: SCNGeometrySource) -> [Double]? {
+    let size = source.bytesPerComponent
+    guard source.vectorCount > 0, source.componentsPerVector > 0,
+      source.dataOffset >= 0, source.dataStride >= source.componentsPerVector * size,
+      [1, 2, 4, 8].contains(size),
+      !source.usesFloatComponents || [4, 8].contains(size),
+      source.dataOffset + (source.vectorCount - 1) * source.dataStride
+        + source.componentsPerVector * size <= source.data.count
+    else { return nil }
+    return source.data.withUnsafeBytes { data in
+      (0..<source.vectorCount).flatMap { vector in
+        (0..<source.componentsPerVector).map { component -> Double in
+          let offset = source.dataOffset + vector * source.dataStride + component * size
+          if source.usesFloatComponents {
+            return size == 4
+              ? Double(data.loadUnaligned(fromByteOffset: offset, as: Float.self))
+              : data.loadUnaligned(fromByteOffset: offset, as: Double.self)
+          }
+          switch size {
+          case 1: return Double(data.loadUnaligned(fromByteOffset: offset, as: UInt8.self))
+          case 2: return Double(data.loadUnaligned(fromByteOffset: offset, as: UInt16.self))
+          case 4: return Double(data.loadUnaligned(fromByteOffset: offset, as: UInt32.self))
+          default: return Double(data.loadUnaligned(fromByteOffset: offset, as: UInt64.self))
+          }
+        }
+      }
+    }
+  }
+}

package/dist/stim-frames/DuoModelView.swift

@@ -0,0 +1,275 @@
+// Copyright (c) 2026 Siniulator contributors. Adapted under the MIT license in Support/Siniulator-LICENSE.txt.
+import AppKit
+import IOSurface
+import Metal
+import SceneKit
+
+@MainActor
+final class DuoModelView: SCNView {
+  private let clip: DuoPoseClip
+  private let cameraNode = SCNNode()
+  private let inner: SCNNode
+  private let cover: SCNNode
+  private let innerHits: DuoScreenHitMesh
+  private let coverHits: DuoScreenHitMesh
+  private let metal: MTLDevice
+  private var textures: [UInt32: MTLTexture] = [:]
+  private var surfaces: [UInt32: IOSurface] = [:]
+  private var frozen: [UInt32: MTLTexture] = [:]
+  private var pendingSnapshot: (id: UInt32, texture: MTLTexture)?
+  let innerID: UInt32
+  let coverID: UInt32
+  private let nativeTurns: [UInt32: Int]
+  private var angle: CGFloat = 180
+  private var quarterTurns = 0
+  var activeID: UInt32
+
+  static var assetURL: URL {
+    URL(fileURLWithPath: CoreSimulator.developerDir)
+      .deletingLastPathComponent()
+      .appendingPathComponent(
+        "SharedFrameworks/DeviceKit.framework/Versions/A/PlugIns/CoreDevicePopDeviceKitExtension.devicekitplugin/Contents/Resources/V68.usdz"
+      )
+  }
+
+  static func load(innerID: UInt32, coverID: UInt32, nativeTurns: [UInt32: Int], assetURL: URL? = nil) -> DuoModelView? {
+    guard let source = SCNSceneSource(url: assetURL ?? Self.assetURL, options: nil),
+      let scene = source.scene(options: [.animationImportPolicy: SCNSceneSource.AnimationImportPolicy.play]),
+      let inner = scene.rootNode.childNode(withName: "mQHVkATpIwJRVQx", recursively: true),
+      let cover = scene.rootNode.childNode(withName: "zaWsadDZpWAUDAX", recursively: true),
+      let clip = DuoPoseClip(root: scene.rootNode),
+      let innerHits = DuoScreenHitMesh(node: inner),
+      let coverHits = DuoScreenHitMesh(node: cover),
+      let metal = MTLCreateSystemDefaultDevice()
+    else { return nil }
+    return DuoModelView(
+      scene: scene, inner: inner, cover: cover, clip: clip,
+      innerHits: innerHits, coverHits: coverHits, metal: metal, innerID: innerID, coverID: coverID, nativeTurns: nativeTurns)
+  }
+
+  private init(
+    scene: SCNScene, inner: SCNNode, cover: SCNNode, clip: DuoPoseClip,
+    innerHits: DuoScreenHitMesh, coverHits: DuoScreenHitMesh, metal: MTLDevice,
+    innerID: UInt32, coverID: UInt32, nativeTurns: [UInt32: Int]
+  ) {
+    self.inner = inner
+    self.cover = cover
+    self.clip = clip
+    self.innerHits = innerHits
+    self.coverHits = coverHits
+    self.metal = metal
+    self.innerID = innerID
+    self.coverID = coverID
+    activeID = innerID
+    self.nativeTurns = nativeTurns
+    super.init(frame: .zero, options: [SCNView.Option.preferredRenderingAPI.rawValue: SCNRenderingAPI.metal.rawValue])
+    self.scene = scene
+    scene.rootNode.addChildNode(cameraNode)
+    let camera = SCNCamera()
+    camera.fieldOfView = 31
+    camera.zNear = 0.01
+    camera.zFar = 200
+    camera.wantsHDR = false
+    cameraNode.camera = camera
+    pointOfView = cameraNode
+    backgroundColor = .clear
+    wantsLayer = true
+    layer?.backgroundColor = NSColor.clear.cgColor
+    antialiasingMode = .multisampling4X
+    allowsCameraControl = false
+    rendersContinuously = false
+    isPlaying = false
+    prepare(inner)
+    prepare(cover)
+    let ambient = SCNNode()
+    ambient.light = SCNLight()
+    ambient.light?.type = .ambient
+    ambient.light?.color = NSColor(white: 0.5, alpha: 1)
+    scene.rootNode.addChildNode(ambient)
+    let key = SCNNode()
+    key.light = SCNLight()
+    key.light?.type = .omni
+    key.light?.intensity = 900
+    key.position = SCNVector3(-4, 24, -8)
+    scene.rootNode.addChildNode(key)
+    setPose(angle: 180, orientation: 1, activeID: innerID)
+  }
+
+  required init?(coder: NSCoder) { nil }
+  override func hitTest(_ point: NSPoint) -> NSView? { nil }
+
+  func updateSurface(_ surface: IOSurface?, screenID: UInt32) {
+    guard let surface else {
+      surfaces[screenID] = nil
+      textures[screenID] = nil
+      if frozen[screenID] == nil {
+        for material in node(screenID).geometry?.materials ?? [] { material.diffuse.contents = nil }
+      }
+      needsDisplay = true
+      return
+    }
+    let changed = surfaces[screenID] !== surface
+    surfaces[screenID] = surface
+    guard frozen[screenID] == nil else { return }
+    if changed || textures[screenID] == nil {
+      textures[screenID] = texture(surface)
+    }
+    let matrix = textureTransform(turns: nativeTurns[screenID] ?? 0)
+    for material in node(screenID).geometry?.materials ?? [] {
+      material.diffuse.contents = textures[screenID]
+      material.diffuse.contentsTransform = matrix
+    }
+    needsDisplay = true
+  }
+
+  func preparePanelChange() {
+    guard let surface = surfaces[activeID], let texture = textures[activeID] else { return }
+    let descriptor = MTLTextureDescriptor.texture2DDescriptor(
+      pixelFormat: texture.pixelFormat,
+      width: texture.width, height: texture.height, mipmapped: false)
+    descriptor.storageMode = .shared
+    descriptor.usage = .shaderRead
+    guard let snapshot = metal.makeTexture(descriptor: descriptor) else { return }
+    surface.lock(options: .readOnly, seed: nil)
+    snapshot.replace(
+      region: MTLRegionMake2D(0, 0, texture.width, texture.height), mipmapLevel: 0,
+      withBytes: surface.baseAddress, bytesPerRow: surface.bytesPerRow)
+    surface.unlock(options: .readOnly, seed: nil)
+    pendingSnapshot = (activeID, snapshot)
+  }
+
+  func setPose(angle: CGFloat, orientation: UInt32, activeID: UInt32) {
+    let nextAngle = min(180, max(0, angle))
+    let uiTurns = orientation == 3 ? 1 : orientation == 4 ? 3 : orientation == 2 ? 2 : 0
+    let nextTurns = (uiTurns - (nativeTurns[activeID] ?? 0) + 4) % 4
+    guard self.angle != nextAngle || quarterTurns != nextTurns || self.activeID != activeID else { return }
+    if self.activeID != activeID {
+      if let snapshot = pendingSnapshot, snapshot.id == self.activeID {
+        frozen[snapshot.id] = snapshot.texture
+        for material in node(snapshot.id).geometry?.materials ?? [] { material.diffuse.contents = snapshot.texture }
+      }
+      pendingSnapshot = nil
+      frozen[activeID] = nil
+      textures[activeID] = nil
+    }
+    self.activeID = activeID
+    self.angle = nextAngle
+    quarterTurns = nextTurns
+    SCNTransaction.begin()
+    SCNTransaction.disableActions = true
+    clip.apply(angle: self.angle)
+    updateCamera()
+    SCNTransaction.commit()
+    if let surface = surfaces[activeID] { updateSurface(surface, screenID: activeID) }
+    needsDisplay = true
+  }
+
+  override func layout() {
+    super.layout()
+    updateCamera()
+  }
+
+  func nativeScreenPoint(_ point: CGPoint, clamped: Bool) -> CGPoint? {
+    let mesh = activeID == coverID ? coverHits : innerHits
+    let near = unprojectPoint(SCNVector3(point.x, point.y, 0))
+    let far = unprojectPoint(SCNVector3(point.x, point.y, 1))
+    var uv = mesh.textureCoordinate(from: near, to: far)
+    if uv == nil, clamped {
+      uv = mesh.nearestTextureCoordinate(to: point, project: { self.projectPoint($0) }, unproject: { self.unprojectPoint($0) })
+    }
+    return uv.map { rotate($0, turns: nativeTurns[activeID] ?? 0) }
+  }
+
+  func viewPoint(_ native: CGPoint) -> CGPoint? {
+    let mesh = activeID == coverID ? coverHits : innerHits
+    let uv = rotate(native, turns: -(nativeTurns[activeID] ?? 0))
+    guard let world = mesh.position(at: uv) else { return nil }
+    let p = projectPoint(world)
+    return CGPoint(x: p.x, y: p.y)
+  }
+
+  private func node(_ id: UInt32) -> SCNNode { id == coverID ? cover : inner }
+
+  private func prepare(_ node: SCNNode) {
+    node.geometry?.materials = (node.geometry?.materials ?? []).map { source in
+      let material = source.copy() as? SCNMaterial ?? source
+      material.lightingModel = .constant
+      material.isDoubleSided = true
+      material.blendMode = .replace
+      material.transparency = 1
+      material.transparent.contents = nil
+      material.diffuse.intensity = 1
+      material.multiply.contents = NSColor.white
+      material.diffuse.wrapS = .clamp
+      material.diffuse.wrapT = .clamp
+      return material
+    }
+  }
+
+  private func texture(_ surface: IOSurface) -> MTLTexture? {
+    let format: MTLPixelFormat
+    switch surface.pixelFormat {
+    case 0x42475241: format = .bgra8Unorm_srgb
+    case 0x52474241: format = .rgba8Unorm_srgb
+    default: return nil
+    }
+    let descriptor = MTLTextureDescriptor.texture2DDescriptor(
+      pixelFormat: format,
+      width: surface.width, height: surface.height, mipmapped: false)
+    descriptor.storageMode = .shared
+    descriptor.usage = .shaderRead
+    return metal.makeTexture(descriptor: descriptor, iosurface: surface, plane: 0)
+  }
+
+  private func updateCamera() {
+    guard bounds.width > 0, bounds.height > 0 else { return }
+    let t = min(1, max(0, (angle - 40) / 70))
+    let orbit = -.pi / 2 * (1 - t * t * (3 - 2 * t))
+    let direction = SIMD3<Float>(Float(sin(orbit)), Float(cos(orbit)), 0)
+    let modelUp = SIMD3<Float>(0, 0, -1)
+    let right = simd_cross(modelUp, direction)
+    let rotation = Float(quarterTurns) * .pi / 2
+    let up = modelUp * cos(rotation) - right * sin(rotation)
+    let halfFOV = Float(31.0 * .pi / 360)
+    let vertical = tan(halfFOV) * 0.9
+    let horizontal = vertical * Float(bounds.width / bounds.height)
+    let posed = clip.bounds()
+    let cameraRight = simd_cross(up, direction)
+    let distance = posed.points.reduce(Float(0)) { distance, point in
+      let delta = point - posed.center
+      let depth = simd_dot(delta, direction)
+      return max(distance, depth + max(abs(simd_dot(delta, cameraRight)) / horizontal, abs(simd_dot(delta, up)) / vertical))
+    }
+    cameraNode.simdPosition = posed.center + direction * distance
+    cameraNode.look(
+      at: SCNVector3(posed.center.x, posed.center.y, posed.center.z),
+      up: SCNVector3(up.x, up.y, up.z), localFront: SCNVector3(0, 0, -1))
+  }
+
+  private func rotate(_ p: CGPoint, turns: Int) -> CGPoint {
+    switch (turns % 4 + 4) % 4 {
+    case 1: return CGPoint(x: p.y, y: 1 - p.x)
+    case 2: return CGPoint(x: 1 - p.x, y: 1 - p.y)
+    case 3: return CGPoint(x: 1 - p.y, y: p.x)
+    default: return p
+    }
+  }
+
+  private func textureTransform(turns: Int) -> SCNMatrix4 {
+    switch (turns % 4 + 4) % 4 {
+    case 1:
+      return SCNMatrix4(
+        m11: 0, m12: -1, m13: 0, m14: 0, m21: 1, m22: 0, m23: 0, m24: 0,
+        m31: 0, m32: 0, m33: 1, m34: 0, m41: 0, m42: 1, m43: 0, m44: 1)
+    case 2:
+      return SCNMatrix4(
+        m11: -1, m12: 0, m13: 0, m14: 0, m21: 0, m22: -1, m23: 0, m24: 0,
+        m31: 0, m32: 0, m33: 1, m34: 0, m41: 1, m42: 1, m43: 0, m44: 1)
+    case 3:
+      return SCNMatrix4(
+        m11: 0, m12: 1, m13: 0, m14: 0, m21: -1, m22: 0, m23: 0, m24: 0,
+        m31: 0, m32: 0, m33: 1, m34: 0, m41: 1, m42: 0, m43: 0, m44: 1)
+    default: return SCNMatrix4Identity
+    }
+  }
+}

package/dist/stim-frames/DuoPoseClip.swift

@@ -0,0 +1,140 @@
+// Copyright (c) 2026 Siniulator contributors. Adapted under the MIT license in Support/Siniulator-LICENSE.txt.
+import SceneKit
+import simd
+
+@MainActor final class DuoPoseClip {
+  static let openTime = 260.0 / 24
+  static let closedTime = 380.0 / 24
+  private enum Property { case position, orientation, scale }
+  private struct Track {
+    let node: SCNNode
+    let property: Property
+    let times: [Double]
+    let values: [SIMD4<Float>]
+  }
+  private let tracks: [Track]
+  private let supports: [(node: SCNNode, points: [SIMD4<Float>])]
+
+  init?(root: SCNNode) {
+    var nodes = [root]
+    root.enumerateChildNodes { node, _ in nodes.append(node) }
+    let geometryNodes = nodes.filter { $0.geometry != nil }
+    let meshes = geometryNodes.compactMap(DuoMesh.init)
+    guard !meshes.isEmpty, meshes.count == geometryNodes.count else { return nil }
+    var tracks: [Track] = []
+    for owner in nodes {
+      for key in owner.animationKeys {
+        guard let player = owner.animationPlayer(forKey: key),
+          let group = CAAnimation(scnAnimation: player.animation) as? CAAnimationGroup
+        else { continue }
+        for case let animation as CAKeyframeAnimation in group.animations ?? [] {
+          guard let path = animation.keyPath,
+            let separator = path.lastIndex(of: "."),
+            let values = animation.values as? [NSValue], !values.isEmpty
+          else { continue }
+          let name = String(path[..<separator]).split(separator: "/").last.map(String.init)
+          guard let node = nodes.first(where: { $0.name == name }) else { continue }
+          let property: Property
+          switch path[path.index(after: separator)...] {
+          case "position": property = .position
+          case "orientation": property = .orientation
+          case "scale": property = .scale
+          default: continue
+          }
+          let keyTimes: [Double]
+          if let authoredTimes = animation.keyTimes {
+            keyTimes = authoredTimes.map { $0.doubleValue }
+          } else {
+            let intervals = Double(max(1, values.count - 1))
+            keyTimes = values.indices.map { Double($0) / intervals }
+          }
+          let times: [Double] = keyTimes.map { animation.beginTime + $0 * animation.duration }
+          guard times.count == values.count else { continue }
+          tracks.append(
+            Track(
+              node: node, property: property, times: times,
+              values: values.map { value in
+                if property == .orientation {
+                  let q = value.scnVector4Value
+                  return SIMD4(Float(q.x), Float(q.y), Float(q.z), Float(q.w))
+                }
+                let v = value.scnVector3Value
+                return SIMD4(Float(v.x), Float(v.y), Float(v.z), 0)
+              }))
+        }
+      }
+      owner.removeAllAnimations()
+    }
+    guard !tracks.isEmpty else { return nil }
+    self.tracks = tracks
+
+    supports = meshes.flatMap { mesh -> [(node: SCNNode, points: [SIMD4<Float>])] in
+      let box = mesh.node.boundingBox
+      let minimum = SIMD3<Float>(Float(box.min.x), Float(box.min.y), Float(box.min.z))
+      let maximum = SIMD3<Float>(Float(box.max.x), Float(box.max.y), Float(box.max.z))
+      guard !mesh.bones.isEmpty else { return [(mesh.node, Self.corners(minimum, maximum))] }
+      var boxes = Array(
+        repeating: (SIMD3<Float>(repeating: .infinity), SIMD3<Float>(repeating: -.infinity)), count: mesh.bones.count)
+      for vertex in mesh.vertices.indices {
+        let v = mesh.vertices[vertex]
+        let point = SIMD3(v.x, v.y, v.z)
+        for influence in mesh.influences[vertex] {
+          boxes[influence.index].0 = simd_min(boxes[influence.index].0, point)
+          boxes[influence.index].1 = simd_max(boxes[influence.index].1, point)
+        }
+      }
+      return mesh.bones.enumerated().map { index, bone in
+        let box = boxes[index]
+        return (bone, box.0.x.isFinite ? Self.corners(box.0, box.1).map { mesh.binds[index] * $0 } : [])
+      }
+    }
+    Self.apply(tracks, time: Self.openTime)
+  }
+
+  func bounds() -> (center: SIMD3<Float>, points: [SIMD3<Float>]) {
+    let points = supports.flatMap { support in
+      support.points.map { point in
+        let transformed = support.node.simdWorldTransform * point
+        return SIMD3(transformed.x, transformed.y, transformed.z)
+      }
+    }
+    let minimum = points.reduce(SIMD3<Float>(repeating: .infinity)) { simd_min($0, $1) }
+    let maximum = points.reduce(SIMD3<Float>(repeating: -.infinity)) { simd_max($0, $1) }
+    return ((minimum + maximum) / 2, points)
+  }
+
+  func apply(angle: CGFloat) {
+    let t = Double(min(180, max(0, angle))) / 180
+    Self.apply(tracks, time: Self.closedTime + (Self.openTime - Self.closedTime) * t)
+  }
+
+  private static func corners(_ minimum: SIMD3<Float>, _ maximum: SIMD3<Float>) -> [SIMD4<Float>] {
+    [minimum.x, maximum.x].flatMap { x in
+      [minimum.y, maximum.y].flatMap { y in
+        [minimum.z, maximum.z].map { z in SIMD4(x, y, z, 1) }
+      }
+    }
+  }
+
+  private static func apply(_ tracks: [Track], time: Double) {
+    for track in tracks {
+      var lower = 0
+      var upper = track.times.count - 1
+      while lower + 1 < upper {
+        let middle = (lower + upper) / 2
+        if track.times[middle] <= time { lower = middle } else { upper = middle }
+      }
+      let span = track.times[upper] - track.times[lower]
+      let fraction = span > 0 ? Float(min(1, max(0, (time - track.times[lower]) / span))) : 0
+      let a = track.values[lower]
+      let b = track.values[upper]
+      if track.property == .orientation {
+        track.node.simdOrientation = simd_slerp(simd_quatf(vector: a), simd_quatf(vector: b), fraction)
+      } else {
+        let value = simd_mix(a, b, SIMD4(repeating: fraction))
+        let vector = SIMD3(value.x, value.y, value.z)
+        if track.property == .position { track.node.simdPosition = vector } else { track.node.simdScale = vector }
+      }
+    }
+  }
+}