@@ -1227,6 +1227,45 @@ final class AccessibilityHierarchyParserTests: XCTestCase {
         XCTAssertEqual(elements, ["emptyPath"], "Element with empty accessibility path should still be parsed")
     }
 
+    // MARK: - Generic Fold Tests
+
+    func testGenericFoldPassesSourceObjects() {
+        let rootView = UIView(frame: .init(x: 0, y: 0, width: 100, height: 100))
+
+        let container = UIView(frame: .init(x: 0, y: 0, width: 100, height: 100))
+        container.accessibilityContainerType = .list
+        rootView.addSubview(container)
+
+        let element = UIView(frame: .init(x: 10, y: 10, width: 30, height: 30))
+        element.isAccessibilityElement = true
+        element.accessibilityLabel = "Item"
+        element.accessibilityFrame = CGRect(x: 10, y: 10, width: 30, height: 30)
+        container.addSubview(element)
+
+        var capturedElementSource: NSObject?
+        var capturedContainerSource: NSObject?
+
+        let parser = AccessibilityHierarchyParser()
+        let _: [String] = parser.parseAccessibilityHierarchy(
+            in: rootView,
+            userInterfaceLayoutDirectionProvider: TestUserInterfaceLayoutDirectionProvider(
+                userInterfaceLayoutDirection: .leftToRight
+            ),
+            userInterfaceIdiomProvider: TestUserInterfaceIdiomProvider(userInterfaceIdiom: .phone),
+            makeElement: { elem, index, source in
+                capturedElementSource = source
+                return "element:\(elem.description)"
+            },
+            makeContainer: { cont, children, source in
+                capturedContainerSource = source
+                return "container:[\(children.joined(separator: ","))]"
+            }
+        )
+
+        XCTAssertTrue(capturedElementSource === element)
+        XCTAssertTrue(capturedContainerSource === container)
+    }
+
     // MARK: - Private Helpers
 
     private func parseMarkers(in view: UIView) -> [AccessibilityMarker] {
 
@@ -163,6 +163,41 @@ public final class AccessibilityHierarchyParser {
         userInterfaceLayoutDirectionProvider: UserInterfaceLayoutDirectionProviding = UIApplication.shared,
         userInterfaceIdiomProvider: UserInterfaceIdiomProviding = UIDevice.current
     ) -> [AccessibilityHierarchy] {
+        parseAccessibilityHierarchy(
+            in: root,
+            rotorResultLimit: rotorResultLimit,
+            userInterfaceLayoutDirectionProvider: userInterfaceLayoutDirectionProvider,
+            userInterfaceIdiomProvider: userInterfaceIdiomProvider,
+            makeElement: { element, traversalIndex, _ in .element(element, traversalIndex: traversalIndex) },
+            makeContainer: { container, children, _ in .container(container, children: children) }
+        )
+    }
+
+    /// Parses the accessibility hierarchy and folds it into a caller-defined node type.
+    ///
+    /// Walks the accessibility tree once in VoiceOver traversal order and builds a tree of `Node`
+    /// values bottom-up. `makeElement` constructs a leaf from its parsed `AccessibilityElement`, its
+    /// `traversalIndex`, and the live accessibility object that produced it. `makeContainer`
+    /// constructs an interior node from its `AccessibilityContainer`, its already-built child nodes
+    /// in traversal order, and the source object backing the container.
+    ///
+    /// The `source` parameters expose the originating accessibility object so callers can correlate
+    /// parsed markers back to their source views — useful for test harnesses, debugging overlays,
+    /// and custom renderers. `parseAccessibilityHierarchy(in:)` is the default instantiation,
+    /// producing `[AccessibilityHierarchy]` and ignoring the source.
+    ///
+    /// Both closures are invoked synchronously during the walk, on the caller's thread.
+    ///
+    /// - parameter makeElement: Builds a leaf node. Called once per element, in traversal order.
+    /// - parameter makeContainer: Builds an interior node from its children. Called once per container.
+    public func parseAccessibilityHierarchy<Node>(
+        in root: UIView,
+        rotorResultLimit: Int = AccessibilityElement.defaultRotorResultLimit,
+        userInterfaceLayoutDirectionProvider: UserInterfaceLayoutDirectionProviding = UIApplication.shared,
+        userInterfaceIdiomProvider: UserInterfaceIdiomProviding = UIDevice.current,
+        makeElement: (AccessibilityElement, _ traversalIndex: Int, _ source: NSObject) -> Node,
+        makeContainer: (AccessibilityContainer, _ children: [Node], _ source: NSObject) -> Node
+    ) -> [Node] {
         let userInterfaceLayoutDirection = userInterfaceLayoutDirectionProvider.userInterfaceLayoutDirection
         let userInterfaceIdiom = userInterfaceIdiomProvider.userInterfaceIdiom
 
@@ -194,7 +229,14 @@ public final class AccessibilityHierarchyParser {
             buildElement(from: element.object, context: element.context, in: root, rotorResultLimit: rotorResultLimit)
         }
 
-        return mapNodesToHierarchy(accessibilityNodes, sortedElements: uncontextualizedElements, elements: elements, in: root)
+        return foldNodes(
+            accessibilityNodes,
+            sortedElements: uncontextualizedElements,
+            elements: elements,
+            in: root,
+            makeElement: makeElement,
+            makeContainer: makeContainer
+        )
     }
 
     // MARK: - Private Types
@@ -531,23 +573,31 @@ public final class AccessibilityHierarchyParser {
 
     // MARK: - Private Hierarchy Methods
 
-    private func mapNodesToHierarchy(
+    /// Folds the structural accessibility tree into a caller-defined `Node` type, bottom-up.
+    ///
+    /// Each produced node is paired internally with a traversal-derived sort key so that a
+    /// container can order its children without inspecting the opaque `Node`. This mirrors
+    /// `AccessibilityHierarchy.sortIndex`: an element sorts by its `traversalIndex`, a container by
+    /// the minimum sort key among its children.
+    private func foldNodes<Node>(
         _ nodes: [AccessibilityNode],
         sortedElements: [(object: NSObject, contextProvider: ContextProvider?)],
         elements: [AccessibilityElement],
-        in root: UIView
-    ) -> [AccessibilityHierarchy] {
+        in root: UIView,
+        makeElement: (AccessibilityElement, _ traversalIndex: Int, _ source: NSObject) -> Node,
+        makeContainer: (AccessibilityContainer, _ children: [Node], _ source: NSObject) -> Node
+    ) -> [Node] {
         var indexLookup: [ObjectIdentifier: Int] = [:]
         for (index, element) in sortedElements.enumerated() {
             indexLookup[ObjectIdentifier(element.object)] = index
         }
 
-        func mapNode(_ node: AccessibilityNode) -> [AccessibilityHierarchy] {
+        func mapNode(_ node: AccessibilityNode) -> [(node: Node, sortIndex: Int)] {
             switch node {
             case let .element(object, _):
                 guard let index = indexLookup[ObjectIdentifier(object)],
                       index < elements.count else { return [] }
-                return [.element(elements[index], traversalIndex: index)]
+                return [(makeElement(elements[index], index, object), index)]
 
             case let .group(children, _, _, containerInfo):
                 let mappedChildren = children.flatMap { mapNode($0) }.sorted { lhs, rhs in
@@ -581,14 +631,15 @@ public final class AccessibilityHierarchyParser {
                         type: containerType,
                         frame: frame
                     )
-                    return [.container(container, children: mappedChildren)]
+                    let sortIndex = mappedChildren.map { $0.sortIndex }.min() ?? Int.max
+                    return [(makeContainer(container, mappedChildren.map { $0.node }, info.view), sortIndex)]
                 }
 
                 return mappedChildren
             }
         }
 
-        return nodes.flatMap { mapNode($0) }
+        return nodes.flatMap { mapNode($0) }.map { $0.node }
     }
 }