fix(folio): stop abusing contentDescription as data carrier (#45)

* feat(hierarchy): full-attribute selector system

- Add Attributes map to Element (raw platform attrs + serialized booleans)
- Add Selector / AttrFilter types for multi-filter AND matching
- Add matchAttr with alias expansion and substring/boolean semantics
- Add matchSelector (AND of all filters)
- id: and desc: keep exact/suffix/prefix semantics for backward compat
- text: widens to substring via matchAttr
- default: case routes unknown kinds to matchAttr (NEW)
- Add Tree.FindNode / Tree.FindAllNodes returning *Node
- Add Node.Find / Node.FindAll for scoped subtree string search
- Add Node.FindBySelector / Node.FindAllBySelector for object AND search
- Add attributeAliases for cross-platform name expansion

* test(hierarchy): full-attribute selector coverage

- raw resource-id: substring match
- label:/content-desc: alias expansion to accessibilityText on iOS
- scrollable:true/false boolean exact match
- title: iOS-only attribute, graceful nil on Android
- text: substring widening
- Selector AND: both filters must match; single miss returns nil
- Node.Find scoped search: descendants only, not siblings

* feat(verifier): object-form selectors + attrs + element-level find

- ax.find/findAll accept string or {attr:value} JS objects
- Object form builds Selector with AND semantics
- Returned element objects expose attrs sub-object (raw platform attrs)
- Returned element objects expose .find() and .findAll() scoped to subtree
- Element-level .find/.findAll accept string or object selectors

* feat(spec): extend AccessibilityElement and AccessibilityTree types

- AccessibilityElement gains attrs, find(), findAll()
- find/findAll on both Tree and Element accept string | AttrSelector
- AttrSelector = Record<string, string> for object-form AND matching

* feat(folio): migrate to chained object-form selectors

- Replace path queries (desc:X > desc:Y) with chained API
- Screen root lookups use { accessibilityText: "ScreenName" }
- Element-scoped searches use find/findAll with string or object
- Keep string selectors for descPrefix: and desc:Back (shows both forms)

* fix(folio): use account_card:id desc, expose balance via text semantics

* fix(folio): embed accountId in LedgerScreen desc, expose values via text semantics

* fix(spec): replace desc-parsing with text-based parseDollarCents extraction

internal/verifier/marshal.go

@@ -61,33 +61,34 @@ func stateObject(runtime *goja.Runtime, input stateInput) (*goja.Object, error)
 
 func accessibilityObject(runtime *goja.Runtime, tree *hierarchy.Tree) *goja.Object {
 	accessibility := runtime.NewObject()
-	find := func(selector string) goja.Value {
+	find := func(call goja.FunctionCall) goja.Value {
 		if tree == nil {
 			return goja.Undefined()
 		}
-		element := tree.Find(selector)
-		if element == nil {
+		node := findNodeFromJS(runtime, tree, call.Argument(0))
+		if node == nil {
 			return goja.Undefined()
 		}
-		return elementObject(runtime, element, selector)
+		return nodeObject(runtime, node, selectorStringFromJS(call.Argument(0)))
 	}
-	findAll := func(selector string) []goja.Value {
+	findAll := func(call goja.FunctionCall) goja.Value {
 		if tree == nil {
-			return nil
+			return goja.Undefined()
 		}
-		elements := tree.FindAll(selector)
-		result := make([]goja.Value, len(elements))
-		for index, element := range elements {
-			result[index] = elementObject(runtime, element, selector)
+		nodes := findAllNodesFromJS(runtime, tree, call.Argument(0))
+		array := runtime.NewArray()
+		for i, n := range nodes {
+			_ = array.Set(fmt.Sprintf("%d", i), nodeObject(runtime, n, selectorStringFromJS(call.Argument(0))))
 		}
-		return result
+		return array
 	}
 	_ = accessibility.Set("find", runtime.ToValue(find))
 	_ = accessibility.Set("findAll", runtime.ToValue(findAll))
 	return accessibility
 }
 
-func elementObject(runtime *goja.Runtime, element *hierarchy.Element, selector string) goja.Value {
+func nodeObject(runtime *goja.Runtime, node *hierarchy.Node, selector string) goja.Value {
+	element := &node.Element
 	object := runtime.NewObject()
 	centerX, centerY := element.Bounds.Center()
 	_ = object.Set("id", element.ResourceID)
@@ -108,9 +109,129 @@ func elementObject(runtime *goja.Runtime, element *hierarchy.Element, selector s
 	_ = bounds.Set("right", element.Bounds.Right)
 	_ = bounds.Set("bottom", element.Bounds.Bottom)
 	_ = object.Set("bounds", bounds)
+	attrs := runtime.NewObject()
+	for k, v := range element.Attributes {
+		_ = attrs.Set(k, v)
+	}
+	_ = object.Set("attrs", attrs)
+	childFind := func(call goja.FunctionCall) goja.Value {
+		arg := call.Argument(0)
+		childNode := findNodeInSubtreeFromJS(runtime, node, arg)
+		if childNode == nil {
+			return goja.Undefined()
+		}
+		return nodeObject(runtime, childNode, selectorStringFromJS(arg))
+	}
+	childFindAll := func(call goja.FunctionCall) goja.Value {
+		arg := call.Argument(0)
+		childNodes := findAllNodesInSubtreeFromJS(runtime, node, arg)
+		array := runtime.NewArray()
+		for i, n := range childNodes {
+			_ = array.Set(fmt.Sprintf("%d", i), nodeObject(runtime, n, selectorStringFromJS(arg)))
+		}
+		return array
+	}
+	_ = object.Set("find", runtime.ToValue(childFind))
+	_ = object.Set("findAll", runtime.ToValue(childFindAll))
 	return object
 }
 
+// findNodeFromJS dispatches a JS value (string or object) to Tree-level node lookup.
+func findNodeFromJS(runtime *goja.Runtime, tree *hierarchy.Tree, arg goja.Value) *hierarchy.Node {
+	if goja.IsUndefined(arg) || goja.IsNull(arg) {
+		return nil
+	}
+	if tree == nil {
+		return nil
+	}
+	if s, ok := arg.Export().(string); ok {
+		return tree.FindNode(s)
+	}
+	sel := selectorFromJSObject(runtime, arg)
+	if len(sel.Filters) == 0 {
+		return nil
+	}
+	return tree.Root.FindBySelector(sel)
+}
+
+// findAllNodesFromJS dispatches a JS value to Tree-level multi-node lookup.
+func findAllNodesFromJS(runtime *goja.Runtime, tree *hierarchy.Tree, arg goja.Value) []*hierarchy.Node {
+	if goja.IsUndefined(arg) || goja.IsNull(arg) || tree == nil {
+		return nil
+	}
+	if s, ok := arg.Export().(string); ok {
+		return tree.FindAllNodes(s)
+	}
+	sel := selectorFromJSObject(runtime, arg)
+	if len(sel.Filters) == 0 {
+		return nil
+	}
+	return tree.Root.FindAllBySelector(sel)
+}
+
+// findNodeInSubtreeFromJS dispatches a JS value to Node-level scoped lookup.
+func findNodeInSubtreeFromJS(runtime *goja.Runtime, node *hierarchy.Node, arg goja.Value) *hierarchy.Node {
+	if goja.IsUndefined(arg) || goja.IsNull(arg) {
+		return nil
+	}
+	if s, ok := arg.Export().(string); ok {
+		return node.Find(s)
+	}
+	sel := selectorFromJSObject(runtime, arg)
+	if len(sel.Filters) == 0 {
+		return nil
+	}
+	return node.FindBySelector(sel)
+}
+
+// findAllNodesInSubtreeFromJS dispatches a JS value to Node-level scoped multi-lookup.
+func findAllNodesInSubtreeFromJS(runtime *goja.Runtime, node *hierarchy.Node, arg goja.Value) []*hierarchy.Node {
+	if goja.IsUndefined(arg) || goja.IsNull(arg) {
+		return nil
+	}
+	if s, ok := arg.Export().(string); ok {
+		return node.FindAll(s)
+	}
+	sel := selectorFromJSObject(runtime, arg)
+	if len(sel.Filters) == 0 {
+		return nil
+	}
+	return node.FindAllBySelector(sel)
+}
+
+// selectorFromJSObject converts a JS object {attr: value, ...} into a Selector.
+func selectorFromJSObject(runtime *goja.Runtime, arg goja.Value) hierarchy.Selector {
+	obj := arg.ToObject(runtime)
+	if obj == nil {
+		return hierarchy.Selector{}
+	}
+	var sel hierarchy.Selector
+	for _, key := range obj.Keys() {
+		if key == tagSelector {
+			continue
+		}
+		val := obj.Get(key)
+		if val == nil || goja.IsUndefined(val) {
+			continue
+		}
+		sel.Filters = append(sel.Filters, hierarchy.AttrFilter{Attr: key, Value: val.String()})
+	}
+	return sel
+}
+
+// selectorStringFromJS returns a string representation of the selector argument
+// for tagging returned element objects (used by selectorOf to reconstruct the
+// selector when the element is passed back as an action target).
+func selectorStringFromJS(arg goja.Value) string {
+	if goja.IsUndefined(arg) || goja.IsNull(arg) {
+		return ""
+	}
+	if s, ok := arg.Export().(string); ok {
+		return s
+	}
+	return arg.String()
+}
+
 func lastActionObject(runtime *goja.Runtime, action *Action) goja.Value {
 	if action == nil {
 		return goja.Null()