Commit 4695528

- Snapshot capture plan: per-strategy ordered chain of iOS snapshot capture backends (recursive tree,

query sweep, private AX) run by one plan runner under a shared wall-clock budget; recovery ordering

is declared data, never a per-call-site branch.

deepExtension?[RunnerAXSnapshotDeepExtensionNodesAddedKey] as? Int ?? 0

)

return SnapshotBackendCapture(

effectiveDepth: depthLimited ? effectiveDepth : nil,

customActions: Self.privateAXCustomActionCoverage(

response[RunnerAXSnapshotCustomActionsKey]

return try! JSONDecoder().decode(Command.self, from: Data(json.utf8))

}

)

}

let identifier = element.identifier.trimmingCharacters(in: .whitespacesAndNewlines)

let valueText = String(describing: element.value ?? "")

.trimmingCharacters(in: .whitespacesAndNewlines)

)

return Response(

ok: true,

let text: String?

let found: Bool?

let items: [String]?

let truncated: Bool?

let snapshotQuality: SnapshotQuality?

let gestureStartUptimeMs: Double?

text: String? = nil,

found: Bool? = nil,

items: [String]? = nil,

truncated: Bool? = nil,

snapshotQuality: SnapshotQuality? = nil,

gestureStartUptimeMs: Double? = nil,

let height: Double

struct SnapshotOptions {

let interactiveOnly: Bool

let depth: Int?

private static let privateAXProjectionTolerance: CGFloat = 1

func privateAXPresentation(rawRoot: [String: Any], options: SnapshotOptions, viewport: CGRect)

{

var hints: [Int: (above: Bool, below: Bool)] = [:]

appendPrivateAXNode(rawRoot, to: &nodes, hints: &hints, options: options, viewport: viewport,

depth: 0, parentIndex: nil, insideMatchedScope: false, scrollContext: nil,

projectionCursor: .root)

return applyHiddenContentHints(hints, to: nodes)

}

hints: inout [Int: (above: Bool, below: Bool)], options: SnapshotOptions, viewport: CGRect,

depth: Int, parentIndex: Int?, insideMatchedScope: Bool,

scrollContext: (index: Int, rect: CGRect)?, projectionCursor: FlatSnapshotProjectionCursor)

if include {

currentIndex = nodes.count

let typeName = elementType.map(elementTypeName) ?? "Element(\(rawType))"

label: label.isEmpty ? nil : label, identifier: identifier.isEmpty ? nil : identifier,

value: value.isEmpty ? nil : value, rect: snapshotRect(from: rect), enabled: enabled,

focused: privateAXPresentationBool(raw["focused"]) == true ? true : nil,

return result.elements

}

var hiddenContentHintsByNodeIndex: [Int: (above: Bool, below: Bool)] = [:]

let rootEvaluation = evaluateSnapshot(context.rootSnapshot, in: context)

nodes.append(

}

return DataPayload(

truncated: false

)

}

context: SnapshotTraversalContext,

options: SnapshotOptions

) throws -> DataPayload {

func walk(_ snapshot: XCUIElementSnapshot, depth: Int, parentIndex: Int?) throws {

if let limit = options.depth, depth > limit { return }

}

try walk(context.rootSnapshot, depth: 0, parentIndex: nil)

}

func snapshotFlatInteractive(

app: XCUIApplication,

options: SnapshotOptions,

planDeadline: Date = .distantFuture

) -> DataPayload {

interactiveRootNode(rect: .zero)

]

if options.depth == 0 {

}

// Bounded by both its own sweep budget and the umbrella capture-plan deadline, so a

let deadline = min(sweepDeadline, planDeadline)

let viewport = safeSnapshotViewport(app: app)

var seen = Set<String>()

let flatElements = flatInteractiveElements(app: app, deadline: deadline)

var truncated = flatElements.truncated

for element in flatElements.elements {

nodes[0] = interactiveRootNode(rect: rootRect)

for candidate in candidates {

nodes.append(

index: nodes.count,

type: candidate.type,

label: candidate.label,

)

)

}

}

func snapshotAccessibilityUnavailable(failure: SnapshotCaptureFailure) -> DataPayload {

) -> DataPayload {

return DataPayload(

message: message,

truncated: true,

snapshotQuality: snapshotQuality,

runnerFatal: runnerFatal,

}

index: 0,

type: "Application",

label: nil,

)

}

guard !candidates.isEmpty else {

return .zero

}

depth: Int,

index: Int,

parentIndex: Int?

index: index,

type: elementTypeName(snapshot.elementType),

label: evaluation.label.isEmpty ? nil : evaluation.label,

}

private func appendCollapsedTabFallbackNodes(

containerSnapshot: XCUIElementSnapshot,

resolveElements: () -> [XCUIElement],

depth: Int,

func applyHiddenContentHints(

_ hints: [Int: (above: Bool, below: Bool)],

if hints.isEmpty { return nodes }

return nodes.map { node in

guard let hint = hints[node.index] else { return node }

let hiddenContentAbove: Bool? = (node.hiddenContentAbove == true || hint.above) ? true : nil

let hiddenContentBelow: Bool? = (node.hiddenContentBelow == true || hint.below) ? true : nil

index: node.index,

type: node.type,

label: node.label,

startingIndex: Int,

depth: Int,

parentIndex: Int

if !containerSnapshot.children.isEmpty { return [] }

guard shouldExpandCollapsedTabContainer(containerSnapshot) else { return [] }

let containerFrame = containerSnapshot.frame

if uniqueCandidates.count < 2 { return [] }

return uniqueCandidates.enumerated().map { offset, node in

index: startingIndex + offset,

type: node.type,

label: node.label,

element: XCUIElement,

containerSnapshot: XCUIElementSnapshot,

containerFrame: CGRect

let exceptionMessage = RunnerObjCExceptionCatcher.catchException({

if !element.exists { return }

let elementType = element.elementType

return

}

index: 0,

type: elementTypeName(elementType),

label: label.isEmpty ? nil : label,

parentIndex: Int?,

viewport: CGRect,

options: SnapshotOptions

let exceptionMessage = RunnerObjCExceptionCatcher.catchException({

if !element.exists { return }

let frame = element.frame

return

}

index: index,

type: elementTypeName(elementType),

label: label.isEmpty ? nil : label,