Build `Get Aria Snapshot return_type=parsed` on Playwright's `ariaSnapshotJSON`

Read Browser/keywords/getters.py and node/playwright-wrapper/getters.ts first, then review the AriaSnapShot RPC in protobuf/playwright.proto and its registration in grpc-service.ts. Implement the JSON RPC and map its nodes into the documented DotDict shape; update the parser unit tests and add a backslash case to the acceptance tests. Done means the parsed shape and options remain compatible, with the documented text value difference covered in release notes.

Use case

Get Aria Snapshot return_type=parsed (added in #5101, released in v20.4.0) returns the snapshot as a tree of nodes with role, name, text, props and children, so tests can assert on single nodes:

${nodes} =    Get Aria Snapshot    h1    parsed
Should Be Equal    ${nodes}[0][props][level]    ${1}

The library builds that tree itself: it loads Playwright's YAML and splits each line label with regular expressions (Browser/utils/aria_snapshot.py). The YAML is made for humans and for toMatchAriaSnapshot, not for parsing, and the parser has to guess at Playwright's quoting rules. One case it gets wrong today, checked with Playwright 1.65.0 and Chromium:

• An accessible name with a backslash. Playwright writes heading "A\\B" and the parser unescapes only \", so name comes back as A\\B instead of A\B.

Playwright 1.63 added locator.ariaSnapshotJSON(), which returns the same tree as a JSON value. Using it removes the parsing, and with it this class of bug.

Proposed keyword / arguments

No new keyword and no new argument. return_type=parsed keeps its documented shape (role, name, text, props, children on every node, DotDict access), but gets the tree from ariaSnapshotJSON instead of parsing YAML. yaml and dict stay on ariaSnapshot() as today. mode, depth and boxes apply to parsed as they do now; ariaSnapshotJSON takes the same three options.

*** Test Cases ***
Check Login Form Through Aria Tree
    ${nodes} =    Get Aria Snapshot    id=login    parsed
    Should Be Equal    ${nodes}[0][role]    textbox
    Should Be Equal    ${nodes}[0][props][placeholder]    User name
    Get Aria Snapshot    css=select    parsed    validate    value[0].children[0].props.selected == True

The mapping from a JSON node to a parsed node:

JSON node	parsed node
role	role
name	name, None when absent
text	text, None when absent
children	children, each mapped the same way, [] when absent
every other key (level, checked, selected, url, placeholder, ref, cursor, box, ...)	a key in props

Keeping the fixed keys, instead of returning the JSON as is, matters for assertions: ${node.name} and ${node}[children] work on every node without a missing-key error, and existing tests keep passing.

A separate return_type=json with Playwright's raw shape was considered. It would give users two tree formats with almost the same content and different keys, so it is not proposed.

Playwright API

locator.ariaSnapshotJSON({ mode, depth, boxes, timeout }), since 1.63 (absent from types.d.ts of 1.62.0, present in 1.63.0). page.ariaSnapshotJSON() exists too, but the keyword always works on a locator. The docs list the node properties: role ("text" for a text fragment), name, text ("Text content of the element when it is the only child, or the content of a static text fragment"), children, state flags checked, disabled, expanded, active, invalid, level, pressed, selected, other properties such as url and placeholder, and ref, cursor (AI mode) and box (boxes: true, with x, y, width, height).

Observed with Playwright 1.65.0 and Chromium:

• {"role":"heading","name":"Login Page","level":1}; keys that have no value are left out, not null.
• {"role":"link","name":"Text bold","url":"/a"}; the link target is a property, where the YAML has a /url child that our parser hoists into props.
• boxes: true gives "box":{"x":8,"y":8,"width":1264,"height":37}, integers, the same keys and values as the YAML [box=...].
• mode: "ai" adds "ref":"e1".

Implementation notes

All references are to upstream main (5e350998).

• Proto: ariaSnapshot() and ariaSnapshotJSON() are two Playwright calls, so add a second rpc next to rpc AriaSnapShot(Request.AriaSnapShot) returns (Response.String) (protobuf/playwright.proto:561): rpc AriaSnapshotJson(Request.AriaSnapShot) returns (Response.Json). Request.AriaSnapShot (:20-26) already carries locator, strict, mode, depth and boxes.
• Node: node/playwright-wrapper/getters.ts:41-52 getAriaSnapshot resolves the locator with findLocator and builds options with ariaSnapshotOptions (:27-39). The new handler does the same and calls locator.ariaSnapshotJSON(options), returning the value with jsonResponse. Register it in grpc-service.ts next to ariaSnapShot = this.wrappingStatePage(getters.getAriaSnapshot) (:294).
• Python: Browser/keywords/getters.py:67-153 get_aria_snapshot calls the new rpc when return_type is AriaSnapshotReturnType.parsed (:143-144 today calls parse_aria_snapshot), and maps the result to DotDict nodes as in the table above. Browser/utils/aria_snapshot.py (the YAML label parser) is then no longer needed and can be replaced by the JSON-to-node mapping.
• AriaSnapshotReturnType docs (Browser/utils/data_types.py:185-405): the parsed section explains that /url "is an annotation in Playwright ... and therefore becomes the url property". That stays true; the wording about splitting YAML annotations changes.
• Tests: the parsed acceptance tests in atest/test/02_Content_Keywords/aria_snapshot.robot:101-162 describe the shape and should pass unchanged; add a name with a backslash. utest/test_aria_snapshot_parser.py tests the YAML parser; it becomes a test of the JSON-to-node mapping.
• To check during implementation: the docstring says mode=ai "does not wait for a matching element, but fails immediately" (getters.py:103-106). Confirm ariaSnapshotJSON behaves the same, or document the difference.

Backwards compatibility

yaml and dict do not change. parsed keeps its keys and access style, with these differences in values:

• Names and texts with backslashes are correct, where today they keep the YAML escaping.
• An element with both a name and its own text content: the YAML parser turns a - text: line under a node into a child node, while the JSON may put it in the node's text. With Playwright 1.65.0, <input aria-label="N" placeholder="ph" value="v"> gives {"role":"textbox","name":"N","placeholder":"ph","text":"v"} in JSON, and today's parsed gives a textbox with a text child node v. Tests that read such a value through children need to read text instead. This should be called out in the release notes.