chore: print alert corpus surfaces through the Swift owner

apple/snapshot-presentation/Package.swift

@@ -21,13 +21,14 @@ let package = Package(
   ],
   targets: [
     .target(name: "AgentDeviceSnapshotPresentation"),
+    .target(name: "RecordingSupport", dependencies: ["AgentDeviceSnapshotPresentation"]),
     .executableTarget(
       name: "SnapshotPresentationConformance",
-      dependencies: ["AgentDeviceSnapshotPresentation"]
+      dependencies: ["AgentDeviceSnapshotPresentation", "RecordingSupport"]
     ),
     .testTarget(
       name: "AgentDeviceSnapshotPresentationTests",
-      dependencies: ["AgentDeviceSnapshotPresentation"]
+      dependencies: ["AgentDeviceSnapshotPresentation", "RecordingSupport"]
     ),
   ]
 )

apple/snapshot-presentation/Sources/RecordingSupport/FixtureRect.swift

@@ -0,0 +1,30 @@
+import CoreGraphics
+import Foundation
+
+/// A rect as a `contracts/fixtures/` table spells it. JSON has no infinity, so the two unusable
+/// boxes are named: `{"infinite": true}` is `CGRect.infinite`, and `{"nonFinite": true}` is a
+/// box whose components are infinite.
+package struct FixtureRect: Decodable {
+  private enum CodingKeys: String, CodingKey {
+    case x, y, width, height, infinite, nonFinite
+  }
+
+  package let cgRect: CGRect
+
+  package init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: CodingKeys.self)
+    if try container.decodeIfPresent(Bool.self, forKey: .infinite) == true {
+      self.cgRect = .infinite
+    } else if try container.decodeIfPresent(Bool.self, forKey: .nonFinite) == true {
+      self.cgRect = CGRect(x: -.infinity, y: -.infinity, width: .infinity, height: .infinity)
+    } else {
+      self.cgRect = CGRect(
+        x: try container.decode(Double.self, forKey: .x),
+        y: try container.decode(Double.self, forKey: .y),
+        width: try container.decode(Double.self, forKey: .width),
+        height: try container.decode(Double.self, forKey: .height)
+      )
+    }
+  }
+}
+

apple/snapshot-presentation/Sources/RecordingSupport/RawAlertRecording.swift

@@ -0,0 +1,75 @@
+import Foundation
+import AgentDeviceSnapshotPresentation
+
+package struct RawAlertRecording: Decodable {
+  package struct Node: Decodable {
+    package let index: Int
+    package let parentIndex: Int?
+    package let element: String
+    package let type: String
+    package let identifier: String
+    package let label: String
+    package let rect: FixtureRect
+  }
+
+  let format: Int
+  package let plain: [Node]
+  package let honorModal: [Node]
+
+  package static func load(_ file: URL) throws -> RawAlertRecording {
+    func invalid(_ detail: String) -> NSError {
+      NSError(domain: "alert-recording", code: 1, userInfo: [NSLocalizedDescriptionKey: "\(file.path): \(detail)"])
+    }
+    let recording: Self
+    do {
+      recording = try JSONDecoder().decode(Self.self, from: Data(contentsOf: file))
+    } catch let error as DecodingError {
+      let context: DecodingError.Context
+      switch error {
+      case let .keyNotFound(_, value), let .valueNotFound(_, value),
+        let .typeMismatch(_, value), let .dataCorrupted(value): context = value
+      @unknown default: throw error
+      }
+      let path = context.codingPath.map { $0.intValue.map { "node \($0)" } ?? $0.stringValue }.joined(separator: ".")
+      throw invalid("\(path): \(context.debugDescription)")
+    }
+    guard recording.format == 2 else { throw invalid("format \(recording.format) is not 2. Capture it again.") }
+    for (name, nodes) in [("plain", recording.plain), ("honorModal", recording.honorModal)] {
+      guard !nodes.isEmpty else { throw invalid("\(name): empty tree") }
+      for (position, node) in nodes.enumerated() {
+        guard node.index == position, node.parentIndex.map({ $0 >= 0 && $0 < position }) ?? (position == 0) else {
+          throw invalid("\(name) node \(position): invalid preorder index or parent")
+        }
+      }
+    }
+    return recording
+  }
+
+  package static func tree(_ nodes: [Node], at root: Int = 0) -> AlertSurfaceNode {
+    var children: [Int: [Int]] = [:]
+    for node in nodes {
+      if let parent = node.parentIndex { children[parent, default: []].append(node.index) }
+    }
+    func build(_ index: Int) -> AlertSurfaceNode {
+      let node = nodes[index]
+      return AlertSurfaceNode(
+        type: node.type,
+        identifier: node.identifier,
+        label: node.label,
+        frame: node.rect.cgRect,
+        children: (children[index] ?? []).map(build)
+      )
+    }
+    return build(root)
+  }
+
+  package static func modalScopeNodes(_ nodes: [Node]) -> [ModalScopeNode] {
+    nodes.map { node in
+      ModalScopeNode(
+        element: node.element,
+        parentElement: node.parentIndex.map { nodes[$0].element },
+        frame: node.rect.cgRect
+      )
+    }
+  }
+}

apple/snapshot-presentation/Sources/SnapshotPresentationConformance/PrintAlertSurface.swift

@@ -0,0 +1,50 @@
+import AgentDeviceSnapshotPresentation
+import CoreGraphics
+import Foundation
+
+import RecordingSupport
+
+func printAlertSurface(_ arguments: [String]) throws {
+  guard let file = arguments.first, arguments.count <= 2,
+    arguments.count == 1 || ["honorModal", "plain"].contains(arguments[1])
+  else {
+    throw NSError(domain: "print:alert-surface", code: 1, userInfo: [
+      NSLocalizedDescriptionKey: "Usage: pnpm print:alert-surface <recording.json> [honorModal|plain]"
+    ])
+  }
+  let recording = try RawAlertRecording.load(URL(fileURLWithPath: file))
+  let plain = RawAlertRecording.modalScopeNodes(recording.plain)
+  let honorModal = RawAlertRecording.modalScopeNodes(recording.honorModal)
+  let reading = ModalSurface.read(
+    plain: plain, honorModal: honorModal, confirmingHonorModal: honorModal, truncated: false
+  )
+  let answer: String
+  var markers: [Int: String] = [:]
+  switch reading {
+  case let .modal(surfaces):
+    answer = "modal"
+    for surface in surfaces {
+      markers[surface.host] = "  [surface roots: \(surface.roots.map(String.init).joined(separator: ", "))]"
+    }
+  case .noExclusion:
+    answer = "noExclusion"
+  case let .unknown(.unstable(instability)):
+    answer = "unknown(unstable(\(instability.rawValue)))"
+  case let .unknown(reason):
+    answer = "unknown(\(reason))"
+  }
+  print("ModalSurface reads (the rule's answer, not ground truth): \(answer)")
+  let printPlain = arguments.count == 2 && arguments[1] == "plain"
+  let nodes = printPlain ? recording.plain : recording.honorModal
+  var depths: [Int] = []
+  let encoder = JSONEncoder()
+  encoder.outputFormatting = [.withoutEscapingSlashes]
+  for node in nodes {
+    let depth = node.parentIndex.map { depths[$0] + 1 } ?? 0
+    depths.append(depth)
+    let label = String(decoding: try encoder.encode(node.label), as: UTF8.self)
+    let index = String(repeating: " ", count: max(0, 4 - String(node.index).count)) + String(node.index)
+    let marker = printPlain ? "" : markers[node.index] ?? ""
+    print("\(index) \(String(repeating: "  ", count: depth))\(node.type) \(label)\(marker)")
+  }
+}

apple/snapshot-presentation/Sources/SnapshotPresentationConformance/main.swift

@@ -144,12 +144,21 @@ private func reason(for failure: SnapshotPresentationFailure) -> String {
   }
 }
 
-private let input = try JSONDecoder().decode(
-  BatchInput.self,
-  from: FileHandle.standardInput.readDataToEndOfFile()
-)
-private let output = try JSONEncoder().encode(
-  BatchOutput(cases: input.cases.map(present))
-)
-FileHandle.standardOutput.write(output)
-FileHandle.standardOutput.write(Data([0x0a]))
+if CommandLine.arguments.dropFirst().first == "print-alert-surface" {
+  do {
+    try printAlertSurface(Array(CommandLine.arguments.dropFirst(2)))
+  } catch {
+    FileHandle.standardError.write(Data("\(error.localizedDescription)\n".utf8))
+    exit(1)
+  }
+} else {
+  let input = try JSONDecoder().decode(
+    BatchInput.self,
+    from: FileHandle.standardInput.readDataToEndOfFile()
+  )
+  let output = try JSONEncoder().encode(
+    BatchOutput(cases: input.cases.map(present))
+  )
+  FileHandle.standardOutput.write(output)
+  FileHandle.standardOutput.write(Data([0x0a]))
+}

apple/snapshot-presentation/Tests/AgentDeviceSnapshotPresentationTests/ActionabilityPolicyTests.swift

@@ -1,3 +1,4 @@
+import RecordingSupport
 import AgentDeviceSnapshotPresentation
 import CoreGraphics
 import Foundation

apple/snapshot-presentation/Tests/AgentDeviceSnapshotPresentationTests/CoordinateSpaceTests.swift

@@ -1,3 +1,4 @@
+import RecordingSupport
 import AgentDeviceSnapshotPresentation
 import CoreGraphics
 import Foundation

apple/snapshot-presentation/Tests/AgentDeviceSnapshotPresentationTests/FixtureRect.swift

@@ -1,32 +1,5 @@
-import CoreGraphics
 import Foundation
-
-/// A rect as a `contracts/fixtures/` table spells it. JSON has no infinity, so the two unusable
-/// boxes are named: `{"infinite": true}` is `CGRect.infinite`, and `{"nonFinite": true}` is a
-/// box whose components are infinite.
-struct FixtureRect: Decodable {
-  private enum CodingKeys: String, CodingKey {
-    case x, y, width, height, infinite, nonFinite
-  }
-
-  let cgRect: CGRect
-
-  init(from decoder: Decoder) throws {
-    let container = try decoder.container(keyedBy: CodingKeys.self)
-    if try container.decodeIfPresent(Bool.self, forKey: .infinite) == true {
-      self.cgRect = .infinite
-    } else if try container.decodeIfPresent(Bool.self, forKey: .nonFinite) == true {
-      self.cgRect = CGRect(x: -.infinity, y: -.infinity, width: .infinity, height: .infinity)
-    } else {
-      self.cgRect = CGRect(
-        x: try container.decode(Double.self, forKey: .x),
-        y: try container.decode(Double.self, forKey: .y),
-        width: try container.decode(Double.self, forKey: .width),
-        height: try container.decode(Double.self, forKey: .height)
-      )
-    }
-  }
-}
+import RecordingSupport
 
 func contractsFixtureURL(_ name: String, from filePath: String = #filePath) -> URL {
   URL(fileURLWithPath: filePath)

apple/snapshot-presentation/Tests/AgentDeviceSnapshotPresentationTests/PrintAlertSurfaceTests.swift

@@ -0,0 +1,24 @@
+import Foundation
+import XCTest
+
+final class PrintAlertSurfaceTests: XCTestCase {
+  func testPrintModeDispatchAndCorpusOutput() throws {
+    let package = URL(fileURLWithPath: #filePath)
+      .deletingLastPathComponent().deletingLastPathComponent().deletingLastPathComponent()
+    let process = Process()
+    process.executableURL = package.appendingPathComponent(".build/debug/snapshot-presentation-conformance")
+    process.arguments = [
+      "print-alert-surface",
+      package.appendingPathComponent("Tests/AlertSurfaceCorpus/iphone-duo-folded-safari-open-this-page-in-app.json").path,
+    ]
+    let output = Pipe()
+    process.standardOutput = output
+    try process.run()
+    let text = String(decoding: output.fileHandleForReading.readDataToEndOfFile(), as: UTF8.self)
+    process.waitUntilExit()
+    XCTAssertEqual(process.terminationStatus, 0)
+    XCTAssertTrue(text.hasPrefix("ModalSurface reads (the rule's answer, not ground truth): modal\n"))
+    XCTAssertTrue(text.contains("[surface roots:"))
+    XCTAssertTrue(text.contains("Application"))
+  }
+}

apple/snapshot-presentation/Tests/AgentDeviceSnapshotPresentationTests/RecordedAlertSurface.swift

@@ -1,24 +1,14 @@
 import CoreGraphics
 import Foundation
 @testable import AgentDeviceSnapshotPresentation
+import RecordingSupport
 
 /// Two trees of one screen recorded by `pnpm capture:alert-surface`, and what the rules must find in
 /// them. Trees are never edited by hand. `expect` names, for each alert source, the one surface that
 /// source must find in the honor-modal tree; a source it does not name must find nothing.
 /// `expectModalScope` is what `ModalSurface` must read from the pair.
-struct RecordedAlertSurface: Decodable {
-  static let format = 2
-
-  struct Node: Decodable {
-    let index: Int
-    let parentIndex: Int?
-    let element: String
-    let type: String
-    let identifier: String
-    let label: String
-    let rect: FixtureRect
-  }
-
+struct RecordedAlertSurface {
+  typealias Node = RawAlertRecording.Node
   struct Expectation: Decodable {
     let title: String
     let buttons: [String]
@@ -41,57 +31,30 @@ struct RecordedAlertSurface: Decodable {
     let excludedActions: [String]?
   }
 
-  let format: Int
-  let expect: [String: Expectation]
-  let expectModalScope: ModalScopeExpectation
-  let plain: [Node]
-  let honorModal: [Node]
-
-  static func load(_ file: URL) throws -> RecordedAlertSurface {
-    let recorded = try JSONDecoder().decode(RecordedAlertSurface.self, from: Data(contentsOf: file))
-    guard recorded.format == format, isPreorder(recorded.plain), isPreorder(recorded.honorModal) else {
-      throw CocoaError(.coderReadCorrupt)
-    }
-    return recorded
+  private struct Expectations: Decodable {
+    let expect: [String: Expectation]
+    let expectModalScope: ModalScopeExpectation
   }
 
-  // Each node's index is its position, and its parent comes before it.
-  private static func isPreorder(_ nodes: [Node]) -> Bool {
-    !nodes.isEmpty && nodes.indices.allSatisfy { position in
-      let node = nodes[position]
-      guard node.index == position else { return false }
-      guard let parent = node.parentIndex else { return position == 0 }
-      return parent >= 0 && parent < position
-    }
+  private let recording: RawAlertRecording
+  private let expectations: Expectations
+  var expect: [String: Expectation] { expectations.expect }
+  var expectModalScope: ModalScopeExpectation { expectations.expectModalScope }
+  var plain: [Node] { recording.plain }
+  var honorModal: [Node] { recording.honorModal }
+
+  static func load(_ file: URL) throws -> RecordedAlertSurface {
+    RecordedAlertSurface(
+      recording: try RawAlertRecording.load(file),
+      expectations: try JSONDecoder().decode(Expectations.self, from: Data(contentsOf: file))
+    )
   }
 
   static func tree(_ nodes: [Node], at root: Int = 0) -> AlertSurfaceNode {
-    var children: [Int: [Int]] = [:]
-    for node in nodes {
-      if let parent = node.parentIndex { children[parent, default: []].append(node.index) }
-    }
-    func build(_ index: Int) -> AlertSurfaceNode {
-      let node = nodes[index]
-      return AlertSurfaceNode(
-        type: node.type,
-        identifier: node.identifier,
-        label: node.label,
-        frame: node.rect.cgRect,
-        children: (children[index] ?? []).map(build)
-      )
-    }
-    return build(root)
+    RawAlertRecording.tree(nodes, at: root)
   }
+  static let modalScopeNodes = RawAlertRecording.modalScopeNodes
 
-  static func modalScopeNodes(_ nodes: [Node]) -> [ModalScopeNode] {
-    nodes.map { node in
-      ModalScopeNode(
-        element: node.element,
-        parentElement: node.parentIndex.map { nodes[$0].element },
-        frame: node.rect.cgRect
-      )
-    }
-  }
 }
 
 func recordedAlertSurfaces() throws -> [(name: String, recorded: RecordedAlertSurface)] {