Add container visualization support to AccessibilitySnapshotView

- Add showContainers option to Overlay configuration
- Add internal initializer for sub-struct configuration
- Add static factory method `withContainers()` for easy container config
- Add container overlay rendering with dashed borders (12pt dash, 6pt gap)
- Containers are rendered first (below elements) when showContainers enabled

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: RoyalPineapple

Sources/AccessibilitySnapshot/Core/AccessibilitySnapshotConfiguration.swift

@@ -34,16 +34,22 @@ public struct AccessibilitySnapshotConfiguration {
         /// order, repeating through the array as necessary.
         ///  Defaults to `MarkerColors.defaultColors`.
         public let colors: [UIColor]
-        
+
         /// Controls when to show indicators for elements' accessibility activation points.
         ///  Defaults to `.whenOverridden`.
         public let activationPointDisplay: AccessibilityContentDisplayMode
-        
+
+        /// Controls whether containers are rendered in the overlay (as dashed borders).
+        /// Defaults to `false` for backward compatibility.
+        public let showContainers: Bool
+
         init(colors: [UIColor] = MarkerColors.defaultColors,
-             activationPointDisplay: AccessibilityContentDisplayMode = .whenOverridden
+             activationPointDisplay: AccessibilityContentDisplayMode = .whenOverridden,
+             showContainers: Bool = false
         )  {
             self.colors = colors.isEmpty ? MarkerColors.defaultColors : colors
             self.activationPointDisplay = activationPointDisplay
+            self.showContainers = showContainers
         }
     }
 
@@ -73,7 +79,14 @@ public struct AccessibilitySnapshotConfiguration {
     public let snapshot: Snapshot
     public let overlay: Overlay
     public let legend: Legend
-    
+
+    /// Internal initializer for creating configuration from sub-structs
+    internal init(snapshot: Snapshot, overlay: Overlay, legend: Legend) {
+        self.snapshot = snapshot
+        self.overlay = overlay
+        self.legend = legend
+    }
+
     /// Creates a new accessibility snapshot configuration.
     ///
     /// - Parameters:
@@ -129,3 +142,38 @@ public enum AccessibilityContentDisplayMode {
     /// Never show the accessibility content.
     case never
 }
+
+extension AccessibilitySnapshotConfiguration {
+
+    /// Creates a configuration with container visualization enabled using default settings.
+    ///
+    /// Containers will be rendered as dashed borders (12pt dash, 6pt gap, 4pt line width at 0.8 alpha) and will
+    /// appear in the legend if they have labels.
+    ///
+    /// - parameter viewRenderingMode: The view rendering mode for snapshot generation. Defaults to `.drawHierarchyInRect`.
+    /// - parameter markerColors: Colors for overlays (used for both elements and containers). Defaults to `MarkerColors.defaultColors`.
+    /// - parameter activationPointDisplayMode: When to show activation point indicators. Defaults to `.whenOverridden`.
+    /// - parameter showUserInputLabels: When to show user input labels. Defaults to `.whenOverridden`.
+    /// - returns: Configuration with container visualization enabled
+    public static func withContainers(
+        viewRenderingMode: ViewRenderingMode = .drawHierarchyInRect,
+        markerColors: [UIColor] = MarkerColors.defaultColors,
+        activationPointDisplayMode: AccessibilityContentDisplayMode = .whenOverridden,
+        showUserInputLabels: AccessibilityContentDisplayMode = .whenOverridden
+    ) -> AccessibilitySnapshotConfiguration {
+        return AccessibilitySnapshotConfiguration(
+            snapshot: Snapshot(
+                viewRenderingMode: viewRenderingMode,
+                colorMode: .fullColor
+            ),
+            overlay: Overlay(
+                colors: markerColors,
+                activationPointDisplay: activationPointDisplayMode,
+                showContainers: true
+            ),
+            legend: Legend(
+                includesUserInputLabels: showUserInputLabels
+            )
+        )
+    }
+}

Sources/AccessibilitySnapshot/Core/AccessibilitySnapshotView.swift

@@ -103,6 +103,8 @@ public final class AccessibilitySnapshotView: SnapshotAndLegendView {
 
     private var displayMarkers: [DisplayMarker] = []
 
+    private var containerOverlays: [UIView] = []
+
     // MARK: - Public Methods
 
     /// Parse the `containedView`'s accessibility and add appropriate visual elements to represent it.
@@ -117,6 +119,7 @@ public final class AccessibilitySnapshotView: SnapshotAndLegendView {
             $0.overlayView.removeFromSuperview()
             $0.activationPointView?.removeFromSuperview()
         }
+        self.containerOverlays.forEach { $0.removeFromSuperview() }
 
         let viewController = containedView.next as? UIViewController
         let originalParent = viewController?.parent
@@ -153,26 +156,36 @@ public final class AccessibilitySnapshotView: SnapshotAndLegendView {
         containedView.layoutIfNeeded()
 
         let parser = AccessibilityHierarchyParser()
+
+        // Render containers first if enabled (so they appear below elements in z-order)
+        if snapshotConfiguration.overlay.showContainers {
+            let hierarchy = parser.parseAccessibilityHierarchy(
+                in: containedView,
+                rotorResultLimit: snapshotConfiguration.legend.rotorResultLimit
+            )
+            renderContainers(from: hierarchy)
+        }
+
         let markers = parser.parseAccessibilityElements(in: containedView, rotorResultLimit: snapshotConfiguration.legend.rotorResultLimit)
-        
-        
+
+
         var displayMarkers: [DisplayMarker] = []
         for (index, marker) in markers.enumerated() {
             let color = snapshotConfiguration.overlay.colors[index % snapshotConfiguration.overlay.colors.count]
 
             let legendView = LegendView(marker: marker, color: color, configuration: snapshotConfiguration.legend)
             addSubview(legendView)
-            
+
             let rotorResultsShapes = marker.displayRotors(snapshotConfiguration.legend.includesCustomRotors).flatMap(\.resultMarkers).compactMap(\.shape)
-            
+
             let overlayView = OverlayView(
                 frame: snapshotView.bounds,
                 elementShape: marker.shape,
                 includedShapes: rotorResultsShapes,
                 color: color)
-            
+
             snapshotView.addSubview(overlayView)
-            
+
             var displayMarker = DisplayMarker(
                 marker: marker,
                 legendView: legendView,
@@ -209,6 +222,58 @@ public final class AccessibilitySnapshotView: SnapshotAndLegendView {
         self.displayMarkers = displayMarkers
     }
 
+    // MARK: - Private Methods
+
+    /// Renders container overlays as dashed borders
+    private func renderContainers(from nodes: [AccessibilityHierarchyNode]) {
+        var containerIndex = 0
+        var newOverlays: [UIView] = []
+
+        func collectAndRenderContainers(from nodes: [AccessibilityHierarchyNode]) {
+            for node in nodes {
+                switch node {
+                case .element:
+                    break  // Elements are handled separately
+                case .container(let containerInfo, let children):
+                    let color = snapshotConfiguration.overlay.colors[
+                        containerIndex % snapshotConfiguration.overlay.colors.count
+                    ]
+                    containerIndex += 1
+
+                    let overlayView = createContainerOverlay(for: containerInfo, color: color)
+                    snapshotView.addSubview(overlayView)
+                    newOverlays.append(overlayView)
+
+                    // Recurse into children
+                    collectAndRenderContainers(from: children)
+                }
+            }
+        }
+
+        collectAndRenderContainers(from: nodes)
+        self.containerOverlays = newOverlays
+    }
+
+    /// Creates a visual overlay for a container as a dashed border
+    private func createContainerOverlay(for containerInfo: ContainerInfo, color: UIColor) -> UIView {
+        let overlayView = UIView()
+        overlayView.frame = containerInfo.frame
+        overlayView.backgroundColor = .clear
+        overlayView.isUserInteractionEnabled = false
+
+        // Create dashed border layer
+        let borderLayer = CAShapeLayer()
+        borderLayer.path = UIBezierPath(rect: overlayView.bounds).cgPath
+        borderLayer.fillColor = nil
+        borderLayer.strokeColor = color.withAlphaComponent(0.8).cgColor
+        borderLayer.lineWidth = 4
+        borderLayer.lineDashPattern = [12, 6]  // 12pt dash, 6pt gap
+
+        overlayView.layer.addSublayer(borderLayer)
+
+        return overlayView
+    }
+
     // MARK: - Private Types
 
     private struct DisplayMarker {