gdharness 1.2.25 → 1.2.26

package/build/cli.js

@@ -652,7 +652,7 @@ function engineFlags(given) {
       const setBy = Object.hasOwn(SET_BY_ARGUMENT, flag) ? SET_BY_ARGUMENT[flag] : undefined;
       return {
         ok: false,
-        reason: setBy !== undefined ? `${flag} is set by this tool's own argument, ${setBy}, rather than through engineArgs.` : `${flag} is not one of the engine flags engineArgs takes, which are those that change what the engine logs, draws for debugging, checks on the GPU or how it times frames, and Movie Maker's --write-movie: ${offered}. A value goes as the next entry, as in ["--fixed-fps", "60"].`
+        reason: setBy !== undefined ? `${flag} is set by this tool's own argument, ${setBy}, rather than through engineArgs.` : `${flag} is not one of the engine flags engineArgs takes, which are those that change what the engine logs, draws for debugging, checks on the GPU, which renderer draws, how it times frames or whether it builds the tree a screen reader reads, and Movie Maker's --write-movie: ${offered}. A value goes as the next entry, as in ["--fixed-fps", "60"].`
       };
     }
     if (takes === "none") {
@@ -748,12 +748,27 @@ var init_launch = __esm(() => {
     "--fixed-fps": "number",
     "--max-fps": "number",
     "--resolution": "size",
-    "--write-movie": "file"
+    "--write-movie": "file",
+    "--rendering-driver": "driver",
+    "--rendering-method": "method",
+    "--accessibility": "accessibility"
   });
   VALUE_KIND = {
     number: { pattern: /^\d+(?:\.\d+)?$/, named: "a number" },
     size: { pattern: /^\d+x\d+$/, named: "a size such as 1280x720" },
-    file: { pattern: /^[^-]/, named: "a file path" }
+    file: { pattern: /^[^-]/, named: "a file path" },
+    driver: {
+      pattern: /^(?:vulkan|d3d12|metal|opengl3|opengl3_es|opengl3_angle|dummy)$/,
+      named: "a rendering driver: vulkan, d3d12, metal, opengl3, opengl3_es, opengl3_angle or dummy"
+    },
+    method: {
+      pattern: /^(?:forward_plus|mobile|gl_compatibility)$/,
+      named: "a rendering method: forward_plus, mobile or gl_compatibility"
+    },
+    accessibility: {
+      pattern: /^(?:auto|always|disabled)$/,
+      named: "an accessibility mode: auto, always or disabled"
+    }
   };
   SET_BY_ARGUMENT = Object.freeze({
     "--headless": "headless",
@@ -8365,7 +8380,7 @@ function reported2(problems) {
   return omitted === 0 ? { messages: problems } : { messages: problems.slice(omitted), messagesOmitted: omitted };
 }
 function reason(log, problems) {
-  const own = log.everything().filter((entry) => entry.source === "stderr" && entry.severity === "info" && entry.text.startsWith(OWN_ERROR));
+  const own = refusalsIn(log);
   if (own.length > 0) {
     return own.map((entry) => entry.text.slice(OWN_ERROR.length)).join("; ");
   }
@@ -8377,6 +8392,9 @@ function reason(log, problems) {
   const printed = log.everything().filter((entry) => entry.source === "stdout");
   return printed.at(-1)?.text ?? "no output at all";
 }
+function refusalsIn(log) {
+  return log.everything().filter((entry) => entry.source === "stderr" && entry.severity === "info" && entry.text.startsWith(OWN_ERROR));
+}
 function scriptFault(problems, script) {
   const spelled = (path) => `(${path.replaceAll("\\", "/").toLowerCase()}/`;
   const directories = [...new Set([spelled(dirname4(script)), spelled(resolvedOr(dirname4(script)))])];
@@ -8496,6 +8514,15 @@ async function runOperation(engine, operation, params, projectPath) {
     };
   }
   if (answer.kind === "none") {
+    const refusals = refusalsIn(ran.log);
+    if (refusals.length > 0) {
+      const said = new Set(refusals.map((entry) => entry.index));
+      return {
+        ok: false,
+        message: refusals.map((entry) => entry.text.slice(OWN_ERROR.length)).join("; "),
+        ...reported2(problems.filter((entry) => !said.has(entry.index)))
+      };
+    }
     const ending = ran.exitCode === 0 && ran.failure === null ? "produced no result" : `failed (${howItEnded(ran)})`;
     return {
       ok: false,
@@ -11127,7 +11154,7 @@ var init_tool_definitions = __esm(() => {
     {
       name: "project_settings",
       title: "Project settings",
-      description: "Reads or writes project.godot: settings, autoloads, the main scene, input actions, plugins and audio buses. A write with an editor open on the project is handed to the editor, which takes the settings the write changed or names from the file (named under editorAdopted), including a setting the file already held, since the editor can hold another value after the file was put back, or reloads the bus layout, so it answers the new values and does not save the old ones back over them. editorNote is an editor that could not take the write, one on an addon from before this, which still holds the old values until editor_launch restart. An enabled plugin's code still loads on the editor's next start. set answers old_value and new_value, with was_new true when project.godot did not set the setting before, and was_default true when what it held was the engine's own default, which old_value then is. get answers exists, true for any setting the engine knows, and at_default, true when the value is the engine's own default and so has no line in project.godot. Each setting under prefix carries at_default too, so a family read separates what the project sets from the engine's defaults; it is absent for a setting the engine registers no default for, such as an input action the project added, which only the project can have set.",
+      description: "Reads or writes project.godot: settings, autoloads, the main scene, input actions, plugins and audio buses. A write with an editor open on the project is handed to the editor, which takes the settings the write changed or names from the file (named under editorAdopted), including a setting the file already held, since the editor can hold another value after the file was put back, or reloads the bus layout, so it answers the new values and does not save the old ones back over them. editorNote is an editor that could not take the write, one on an addon from before this, which still holds the old values until editor_launch restart. An enabled plugin's code still loads on the editor's next start. set answers old_value and new_value, with was_new true when project.godot did not set the setting before, and was_default true when what it held was the engine's own default, which old_value then is. A set of the value the setting already holds, in the same type, writes nothing and answers unchanged true and saved false. Every write keeps the sections and keys of project.godot in the order the file had them, so a change touches only its own lines. get answers exists, true for any setting the engine knows, and at_default, true when the value is the engine's own default and so has no line in project.godot. Each setting under prefix carries at_default too, so a family read separates what the project sets from the engine's defaults; it is absent for a setting the engine registers no default for, such as an input action the project added, which only the project can have set.",
       parameters: {
         projectPath: PROJECT_PATH,
         setting: {
@@ -11312,7 +11339,7 @@ var init_tool_definitions = __esm(() => {
         },
         options: {
           type: "object",
-          description: 'set_options: import options keyed as the .import file spells them, {"compress/mode": 1}.',
+          description: `set_options: import options keyed as the .import file spells them, {"compress/mode": 1}. A dictionary option whose keys are numbers, a font's opentype_features or any option already holding number keys, takes them written as strings of digits, and opentype_features also takes an OpenType tag by its four-letter name: {"opentype_features": {"liga": 0}} turns ligatures off. Both are written as the numbers the engine reads.`,
           additionalProperties: true
         },
         reimport: {
@@ -11400,7 +11427,7 @@ var init_tool_definitions = __esm(() => {
         engineArgs: {
           type: "array",
           items: { type: "string" },
-          description: `The engine's own flags for the run, such as ["--verbose"], a value going as the next entry. Only those that change what the engine logs, draws for debugging, checks on the GPU or how it times frames: ${Object.keys(ENGINE_FLAGS).join(", ")}. Any other is refused. With --verbose, engineEntries holds the ordinary lines the run printed as well, which is where the engine names the instances leaked and the resources still in use at exit.`
+          description: `The engine's own flags for the run, such as ["--verbose"], a value going as the next entry. Only those that change what the engine logs, draws for debugging, checks on the GPU, which renderer draws, how it times frames or whether it builds the tree a screen reader reads: ${Object.keys(ENGINE_FLAGS).join(", ")}. Any other is refused. With --verbose, engineEntries holds the ordinary lines the run printed as well, which is where the engine names the instances leaked and the resources still in use at exit.`
         },
         failFast: {
           type: "boolean",
@@ -11877,7 +11904,7 @@ var init_tool_definitions = __esm(() => {
           type: "array",
           items: { type: "string" },
           ops: ["start", "check"],
-          description: `The engine's own flags, before the separator, such as ["--verbose"] or ["--fixed-fps", "60"], a value going as the next entry. Only those that change what the engine logs, draws for debugging, checks on the GPU or how it times frames, and Movie Maker's --write-movie: ${Object.keys(ENGINE_FLAGS).join(", ")}. Any other is refused, since the engine's command line can also run scripts, open other projects and write files. --write-movie takes an absolute path outside the project, in a directory that exists, ending in .avi (one file, video and sound) or .png (one numbered PNG per frame and a .wav beside them), where nothing it would write is there already; it needs a start with headless: false, since the engine crashes writing a movie headless, and it records at the project's editor/movie_writer/fps unless --fixed-fps says otherwise. A run with any is started by this server, as one with args is. A check given --verbose answers with everything printed rather than only errors and warnings, since what verbose adds, the instances leaked at exit among it, is printed as ordinary lines.`
+          description: `The engine's own flags, before the separator, such as ["--verbose"] or ["--fixed-fps", "60"], a value going as the next entry. Only those that change what the engine logs, draws for debugging, checks on the GPU, which renderer draws, how it times frames or whether it builds the tree a screen reader reads, and Movie Maker's --write-movie: ${Object.keys(ENGINE_FLAGS).join(", ")}. Any other is refused, since the engine's command line can also run scripts, open other projects and write files. --rendering-driver takes vulkan, d3d12, metal, opengl3, opengl3_es, opengl3_angle or dummy, and --rendering-method forward_plus, mobile or gl_compatibility, so the same scene can be measured on another driver and a project's OpenGL fallback exercised on a machine that has Vulkan; they choose what draws a run with a window. --accessibility always has the game build the tree a screen reader reads, as the project's accessibility/general/accessibility_support at Always Active does, so runtime_inspect accessibility can read it; otherwise the engine builds it only when a screen reader is running. --write-movie takes an absolute path outside the project, in a directory that exists, ending in .avi (one file, video and sound) or .png (one numbered PNG per frame and a .wav beside them), where nothing it would write is there already; it needs a start with headless: false, since the engine crashes writing a movie headless, and it records at the project's editor/movie_writer/fps unless --fixed-fps says otherwise. A run with any is started by this server, as one with args is. A check given --verbose answers with everything printed rather than only errors and warnings, since what verbose adds, the instances leaked at exit among it, is printed as ordinary lines.`
         },
         headless: { type: "boolean", ops: ["start"], description: "start: force a window or no window." },
         visible: {
@@ -12117,7 +12144,7 @@ var init_tool_definitions = __esm(() => {
     {
       name: "runtime_inspect",
       title: "Inspect the running game",
-      description: "Questions about the running game: what is written on the screen, the scene tree, the nodes matching a query, where one node is on screen, what one property reads, or the performance metrics. Needs the game running with the runtime addon.",
+      description: "Questions about the running game: what is written on the screen, the scene tree, the nodes matching a query, where one node is on screen, what one property reads, the performance metrics, or what it tells a screen reader. Needs the game running with the runtime addon.",
       parameters: {
         projectPath: RUNNING_PROJECT_PATH,
         pid: RUNNING_PID,
@@ -12186,7 +12213,7 @@ var init_tool_definitions = __esm(() => {
         timeoutMs: {
           type: "integer",
           minimum: 1,
-          description: "How long to wait for the answer before answering pending with a requestId, which runtime_invoke op result collects the reply by. Default 10000, or GDHARNESS_RUNTIME_TIMEOUT_MS."
+          description: "How long to wait for the answer before answering pending with a requestId, which runtime_invoke op result collects the reply by. Default 10000, or GDHARNESS_RUNTIME_TIMEOUT_MS; accessibility defaults to 30000 or that, whichever is longer."
         }
       },
       requires: [],
@@ -12214,7 +12241,12 @@ var init_tool_definitions = __esm(() => {
         },
         metrics: {
           effect: "read",
-          summary: "frame time, memory, draw calls and the rest. frame_time is the mean wall time of a frame over the last frames_timed frames (up to 120, timed by the game itself, physics and the wait for the display included), frame_time_max the slowest of them, both in seconds and null before a frame has passed; vsync says whether a frame waits for the display, and max_fps is the game's frame-rate cap, 0 for none. fps, process_time_max and physics_time are the engine's monitors, which it sets once a second: the frames counted in the last second, and the slowest process and physics step in it, so they trail a change by up to a second and the last two are a worst case rather than the frame. The memory, object and render counts are read as asked",
+          summary: "frame time, memory, draw calls and the rest. frame_time is the mean wall time of a frame over the last frames_timed frames (up to 120, timed by the game itself, physics and the wait for the display included), frame_time_max the slowest of them, both in seconds and null before a frame has passed; vsync says whether a frame waits for the display, and max_fps is the game's frame-rate cap, 0 for none. fps, process_time_max and physics_time are the engine's monitors, which it sets once a second: the frames counted in the last second, and the slowest process and physics step in it, so they trail a change by up to a second and the last two are a worst case rather than the frame. The memory, object and render counts are read as asked. memory_static is what the engine allocated on the CPU side, in bytes; render_video_mem_used, render_texture_mem_used and render_buffer_mem_used are what the renderer has on the GPU, in bytes, which memory_static does not count",
+          requires: []
+        },
+        accessibility: {
+          effect: "read",
+          summary: `what the game tells a screen reader, read through UI Automation as a Windows screen reader reads it, under windows: one tree per window, each element with its role as UI Automation names it (text for static text, button, check_box, group for a control holding others), its name, its value where it has one, its bounds in the window's pixels, the actions a screen reader is offered (click, focus, toggle, set_value, select, expand_collapse, scroll_into_view), and focused on the one holding the focus. The name is what is read aloud, so an empty one is read as nothing; static text takes it from DisplayServer.accessibility_update_set_value, not from a name set on it, and the answer says under _note how many text elements on screen have none. With no control focused, the engine reports the first node under the root as focused, which in a run with the runtime is GdharnessRuntime. Needs a windowed run on Windows started with engineArgs ["--accessibility", "always"] or with the project's accessibility/general/accessibility_support at Always Active, since the engine builds the tree only when asked; reading it takes a second or two, starting PowerShell inside the game so it reaches the game's own desktop`,
           requires: []
         }
       },
@@ -12344,7 +12376,7 @@ var init_tool_definitions = __esm(() => {
       name: "runtime_input",
       title: "Send input to the game",
       description: "Input to the running game: a whole click on a Control or a 3D node named by path or on a control named by the words on it, an item chosen out of a menu, typing into whatever has the focus, or a raw action, key, mouse button or mouse motion. All of it works headless, where the window is 64 by 64 and the GUI only takes what is inside it. On gdharness's own desktop, where a windowed run goes, Windows refuses to say where the pointer is: every pointer answer there carries pointer_on_hidden_desktop, and the first of the run pointer_note saying why it matters: get_mouse_position() on the root window, and the mouse positions derived from it, read a meaningless position, while what reads the event itself (the control under it, hover, tooltips, input handlers) gets the injected position.",
-      answer: 'click: what was under the pointer, and what became of the control: in_tree, removed or freed. Named by says, found says which match it was, and found.pressedOn says "the words" for words in a RichTextLabel pressed where they are drawn, or "the middle of the label" with a note saying why they could not be placed; on a rich label link_pressed says whether the press reached a link, with link_meta giving the meta the label reports clicked, an empty one included. A control scrolled into view first is scrolled each container out from it a frame after the one inside, and scrolled_into_view says whether a scroll value changed. A button in toggle mode, a CheckBox or CheckButton included, answers pressed with before and after, its button_pressed either side of the click: the same value twice is a click the game undid, and after is null when the click freed it. A refusal for a pointer turned off names where mouse_behavior_recursive was set. On a 3D node landed says the interface did not swallow the press: no control under the pointer stopped it, a control letting the pointer pass included, and every viewport on the way out from the room had the pointer over what shows the room. choose: what was chosen, read before the press, which is heard rather than assumed; what became of the control named (in_tree, removed or freed, since a game can rebuild its screen on the pick); and what the button in front of the menu shows now when it is still there. A menu is opened rather than clicked because its items are drawn rather than built, and the item is looked for as the menu stands once open, since a game can fill a menu as it opens. action, key and mouse_click: the event as it was sent, with whole saying whether the press was let go of again, and for a key the keycode, physical_keycode and unicode it carried. mouse_motion: the position and the relative movement sent. None of these is aimed at anything, so none says what the event reached: click on a nodePath or says answers what was under the pointer.',
+      answer: 'click: what was under the pointer, and what became of the control: in_tree, removed or freed. Named by says, found says which match it was, and found.pressedOn says "the words" for words in a RichTextLabel pressed where they are drawn, or "the middle of the label" with a note saying why they could not be placed; on a rich label link_pressed says whether the press reached a link, with link_meta giving the meta the label reports clicked, an empty one included. A control scrolled into view first is scrolled each container out from it a frame after the one inside, and scrolled_into_view says whether a scroll value changed. A button in toggle mode, a CheckBox or CheckButton included, answers pressed with before and after, its button_pressed either side of the click: the same value twice is a click the game undid, and after is null when the click freed it. A refusal for a pointer turned off names where mouse_behavior_recursive was set. On a 3D node landed says the interface did not swallow the press: no control under the pointer stopped it, a control letting the pointer pass included, and every viewport on the way out from the room had the pointer over what shows the room. choose: what was chosen, read before the press, which is heard rather than assumed; what became of the control named (in_tree, removed or freed, since a game can rebuild its screen on the pick); and what the button in front of the menu shows now when it is still there. A menu is opened rather than clicked because its items are drawn rather than built, and the item is looked for as the menu stands once open, since a game can fill a menu as it opens. action, key, mouse_click and joypad_button: the event as it was sent, with whole saying whether the press was let go of again, for a key the keycode, physical_keycode and unicode it carried, and for a controller button its number, its name and the device. mouse_motion: the position and the relative movement sent. joypad_motion: the axis by number and name, the value and the device. None of these is aimed at anything, so none says what the event reached: click on a nodePath or says answers what was under the pointer.',
       parameters: {
         projectPath: RUNNING_PROJECT_PATH,
         pid: RUNNING_PID,
@@ -12365,8 +12397,8 @@ var init_tool_definitions = __esm(() => {
         },
         pressed: {
           type: "boolean",
-          ops: ["action", "key", "mouse_click"],
-          description: "action, key, mouse_click: leave it out and the press is a whole one, down and up a frame apart. true holds it down, false lets go of one being held. A wheel button held down is still a whole step, since a wheel is never held."
+          ops: ["action", "key", "mouse_click", "joypad_button"],
+          description: "action, key, mouse_click, joypad_button: leave it out and the press is a whole one, down and up a frame apart. true holds it down, false lets go of one being held. A wheel button held down is still a whole step, since a wheel is never held."
         },
         strength: {
           type: "number",
@@ -12411,8 +12443,26 @@ var init_tool_definitions = __esm(() => {
         },
         button: {
           type: ["string", "number"],
-          ops: ["click", "mouse_click"],
-          description: "click, mouse_click: left, right, middle, wheel_up or wheel_down, or a button number. Default left."
+          ops: ["click", "mouse_click", "joypad_button"],
+          description: "click, mouse_click: left, right, middle, wheel_up or wheel_down, or a button number. Default left. joypad_button: the controller button, by name (a, b, x, y, back, guide, start, left_stick, right_stick, left_shoulder, right_shoulder, dpad_up, dpad_down, dpad_left, dpad_right, misc1, paddle1 to paddle4, touchpad) or by its JoyButton number; a, b, x and y are the bottom, right, left and top face buttons, as Godot names them, whatever the controller prints on them."
+        },
+        axis: {
+          type: ["string", "number"],
+          ops: ["joypad_motion"],
+          description: "joypad_motion: the stick or trigger axis, by name (left_x, left_y, right_x, right_y, trigger_left, trigger_right) or by its JoyAxis number."
+        },
+        value: {
+          type: "number",
+          minimum: -1,
+          maximum: 1,
+          ops: ["joypad_motion"],
+          description: "joypad_motion: where the axis is, -1 to 1: down and right are positive on a stick, and a trigger runs 0 to 1. The axis stays there until another motion moves it, as a stick held over does; send 0 to let it go back."
+        },
+        device: {
+          type: "number",
+          minimum: 0,
+          ops: ["joypad_button", "joypad_motion"],
+          description: "joypad_button, joypad_motion: which controller, counting from 0. Default 0."
         },
         doubleClick: {
           type: "boolean",
@@ -12462,6 +12512,16 @@ var init_tool_definitions = __esm(() => {
           effect: "additive",
           summary: "move the mouse to a position, carrying the distance from where the last injected event put it unless relativeX and relativeY say otherwise, and the buttons held, so a control that drags moves under a run of these between a held mouse_click and its release",
           requires: ["x", "y"]
+        },
+        joypad_button: {
+          effect: "additive",
+          summary: "press a controller button, or hold it, as an InputEventJoypadButton, so a game reading the pad in _input or _unhandled_input gets what a controller sends; an action bound to the button fires with it, as it would for a real one. Pressed and released a frame apart unless pressed says otherwise",
+          requires: ["button"]
+        },
+        joypad_motion: {
+          effect: "additive",
+          summary: "move a stick or trigger axis to a value, as an InputEventJoypadMotion, which is what a game reading the sticks gets; the axis stays there until another motion moves it",
+          requires: ["axis", "value"]
         }
       }
     },
@@ -45267,6 +45327,12 @@ class GodotServer {
               path: readNonEmptyString(args, "nodePath") ?? "",
               property: readNonEmptyString(args, "property") ?? ""
             }, { tool: "runtime_inspect", op, patience });
+          case "accessibility":
+            return await this.handleRuntimeCommand("get_accessibility", whichGame(args), {
+              tool: "runtime_inspect",
+              op,
+              patience: readPositiveNumber(args, "timeoutMs") ?? Math.max(30000, this.runtimeTimeoutMs())
+            });
           default:
             return await this.handleRuntimeCommand("get_metrics", { ...whichGame(args), metrics: readArray(args, "metrics") ?? [] }, { tool: "runtime_inspect", op, patience });
         }

package/build/godot/addons/gdharness_runtime/runtime_accessibility.gd

@@ -0,0 +1,290 @@
+extends RefCounted
+
+## What the running game tells a screen reader: its accessibility tree, as UI Automation reads it.
+##
+## The engine builds the tree only when something asks for it, and nothing on gdharness's desktop
+## does, so a game's NOTIFICATION_ACCESSIBILITY_UPDATE never came and what its controls expose could
+## not be checked. The engine offers no way to read the tree back, so the question is put the way a
+## screen reader puts it: a UI Automation client started by the game lands on the game's own desktop,
+## its first question makes the engine build the tree, and what it reads is what a screen reader is
+## told, names left empty included.
+
+const Read = preload("reading.gd")
+
+## How long the client keeps walking the tree for it to settle: the engine answers the first question
+## with its windows alone and fills them in over the next frames.
+const SETTLE_MS: int = 8000
+## How long a window with nothing in it is walked before the client stops: a game building its tree
+## fills the window within a few frames of being asked, and one building none never does.
+const EMPTY_MS: int = 4000
+## How long the client may take beyond that, starting PowerShell and loading UI Automation included,
+## before it is stopped and the call answers that it did not finish.
+const START_MS: int = 15000
+## Deep enough for any interface a game builds, and inside the hundred levels ConvertTo-Json stops
+## at, which are two to a level of the tree.
+const MOST_LEVELS: int = 40
+
+## The client, as PowerShell, with $Handles, $Out, $SettleMs, $EmptyMs and $MostLevels set before it. Each
+## element answers what UI Automation names its role, its name, its value where it has one, its
+## bounds in the window's pixels, and the actions a screen reader is offered on it.
+const WALK: String = r"""
+$ErrorActionPreference = 'Stop'
+function Answer($value) {
+  [System.IO.File]::WriteAllText($Out, (ConvertTo-Json -InputObject $value -Depth 100 -Compress))
+}
+try {
+  Add-Type -AssemblyName UIAutomationClient, UIAutomationTypes
+  $walker = [System.Windows.Automation.TreeWalker]::RawViewWalker
+  function Patterned($element, $name) {
+    $pattern = ("System.Windows.Automation.$($name)Pattern" -as [type])::Pattern
+    $found = $null
+    if ($element.TryGetCurrentPattern($pattern, [ref]$found)) { return $found }
+    return $null
+  }
+  function Describe($element, $ox, $oy, $depth) {
+    $c = $element.Current
+    $role = $c.ControlType.ProgrammaticName -replace '^ControlType[.]', ''
+    $role = ($role -creplace '(?<=[a-z])(?=[A-Z])', '_').ToLowerInvariant()
+    $node = [ordered]@{ role = $role; name = $c.Name }
+    if ($c.HelpText) { $node.description = $c.HelpText }
+    $r = $c.BoundingRectangle
+    if (-not $r.IsEmpty) {
+      $node.bounds = [ordered]@{ x = [int]($r.X - $ox); y = [int]($r.Y - $oy) }
+      $node.bounds.width = [int]$r.Width
+      $node.bounds.height = [int]$r.Height
+    }
+    $actions = @()
+    if (Patterned $element 'Invoke') { $actions += 'click' }
+    $p = Patterned $element 'Toggle'
+    if ($p) { $actions += 'toggle'; $node.toggled = "$($p.Current.ToggleState)".ToLowerInvariant() }
+    $p = Patterned $element 'ExpandCollapse'
+    if ($p) {
+      $actions += 'expand_collapse'
+      $node.expanded = "$($p.Current.ExpandCollapseState)".ToLowerInvariant()
+    }
+    $p = Patterned $element 'SelectionItem'
+    if ($p) { $actions += 'select'; $node.selected = $p.Current.IsSelected }
+    $p = Patterned $element 'Value'
+    if ($p) {
+      $node.value = $p.Current.Value
+      if (-not $p.Current.IsReadOnly) { $actions += 'set_value' }
+    }
+    $p = Patterned $element 'RangeValue'
+    if ($p) {
+      $node.value = $p.Current.Value
+      $node.range = @($p.Current.Minimum, $p.Current.Maximum)
+      if (-not $p.Current.IsReadOnly) { $actions += 'set_value' }
+    }
+    if (Patterned $element 'ScrollItem') { $actions += 'scroll_into_view' }
+    if ($c.IsKeyboardFocusable) { $actions += 'focus' }
+    $node.actions = $actions
+    if ($c.HasKeyboardFocus) { $node.focused = $true }
+    if (-not $c.IsEnabled) { $node.disabled = $true }
+    if ($c.IsOffscreen) { $node.offscreen = $true }
+    $children = @()
+    if ($depth -lt $MostLevels) {
+      $child = $walker.GetFirstChild($element)
+      while ($null -ne $child) {
+        $children += , (Describe $child $ox $oy ($depth + 1))
+        $child = $walker.GetNextSibling($child)
+      }
+    }
+    $node.children = $children
+    return $node
+  }
+  function Count($node) {
+    $n = 1
+    foreach ($child in $node.children) { $n += Count $child }
+    return $n
+  }
+  $windows = @()
+  foreach ($handle in $Handles) {
+    $root = [System.Windows.Automation.AutomationElement]::FromHandle([IntPtr][long]$handle)
+    $r = $root.Current.BoundingRectangle
+    $deadline = [DateTime]::UtcNow.AddMilliseconds($SettleMs)
+    $empty = [DateTime]::UtcNow.AddMilliseconds($EmptyMs)
+    $tree = Describe $root $r.X $r.Y 0
+    $last = Count $tree
+    # Walked again until two walks in a row agree, since the first question is what makes the
+    # engine build the tree, which arrives over the frames after it.
+    while ([DateTime]::UtcNow -lt $deadline) {
+      Start-Sleep -Milliseconds 150
+      $tree = Describe $root $r.X $r.Y 0
+      $count = Count $tree
+      if ($count -gt 1 -and $count -eq $last) { break }
+      if ($count -eq 1 -and [DateTime]::UtcNow -gt $empty) { break }
+      $last = $count
+    }
+    $windows += , $tree
+  }
+  Answer @{ windows = $windows }
+} catch {
+  Answer @{ error = "$_" }
+}
+"""
+
+var _host: Node
+
+
+func _init(host: Node) -> void:
+	_host = host
+
+
+## The game's windows as a screen reader is told them, each a tree of elements.
+func get_accessibility(_params: Dictionary) -> Dictionary:
+	if DisplayServer.get_name() == "headless":
+		return _refused(
+			(
+				"A headless run has no window, so a screen reader is told nothing: start the run with"
+				+ " headless: false."
+			)
+		)
+	if OS.get_name() != "Windows":
+		return _refused(
+			(
+				(
+					"The tree is read through UI Automation, the interface a Windows screen reader uses, and this"
+					+ " game runs on %s, whose screen readers ask it through another"
+				)
+				% OS.get_name()
+			)
+		)
+	var handles: Array[String] = []
+	var ids: Array[int] = []
+	for id: int in DisplayServer.get_window_list():
+		var handle: int = DisplayServer.window_get_native_handle(DisplayServer.WINDOW_HANDLE, id)
+		if handle != 0:
+			handles.append(str(handle))
+			ids.append(id)
+
+	var out: String = OS.get_temp_dir().path_join(
+		"gdharness-accessibility-%d-%d.json" % [OS.get_process_id(), Time.get_ticks_usec()]
+	)
+	var script: String = (
+		(
+			"$Handles = @(%s)\n$Out = '%s'\n$SettleMs = %d\n$EmptyMs = %d\n$MostLevels = %d\n"
+			% [", ".join(handles), out.replace("'", "''"), SETTLE_MS, EMPTY_MS, MOST_LEVELS]
+		)
+		+ WALK
+	)
+	# The system's own PowerShell by its path, so a powershell.exe earlier on PATH is not what runs.
+	var shell: String = OS.get_environment("SystemRoot").path_join(
+		"System32/WindowsPowerShell/v1.0/powershell.exe"
+	)
+	var pid: int = (
+		OS
+		. create_process(
+			shell,
+			[
+				"-NoProfile",
+				"-NonInteractive",
+				"-EncodedCommand",
+				Marshalls.raw_to_base64(script.to_utf16_buffer()),
+			]
+		)
+	)
+	if pid <= 0:
+		return _refused("PowerShell could not be started from %s to read the tree" % shell)
+	# Waited out a frame at a time rather than blocking: the client's questions are answered on the
+	# game's main thread, which a blocking wait would hold, and neither side would move.
+	var deadline: int = Time.get_ticks_msec() + SETTLE_MS + START_MS
+	while OS.is_process_running(pid):
+		if Time.get_ticks_msec() > deadline:
+			var _killed: Error = OS.kill(pid)
+			return _refused(
+				"UI Automation had not read the tree after %d ms, so it was stopped" % (SETTLE_MS + START_MS)
+			)
+		await _host.get_tree().process_frame
+
+	var text: String = FileAccess.get_file_as_string(out)
+	# Not checked: a file that is not there was never written, which the answer below says.
+	var _removed: Error = DirAccess.remove_absolute(out)
+	var read: Variant = Read.json_or_null(text)
+	if not read is Dictionary:
+		return _refused("UI Automation answered nothing readable: %s" % text.left(500))
+	var answer: Dictionary = read
+	if answer.has("error"):
+		return _refused("UI Automation could not read the game's windows: %s" % str(answer["error"]))
+
+	var windows: Array = answer.get("windows", [])
+	var elements: int = 0
+	var unnamed: int = 0
+	for at: int in windows.size():
+		var window: Dictionary = windows[at]
+		window["window_id"] = ids[at] if at < ids.size() else -1
+		elements += _count(window)
+		unnamed += _unnamed_text(window)
+	var result: Dictionary = {"windows": windows, "elements": elements}
+	if elements <= windows.size():
+		var setting: String = _setting()
+		# The command line's --accessibility is consumed by the engine and not handed on, so only
+		# the setting and a screen reader can say the tree is built; otherwise an empty window is
+		# most likely a game that builds none.
+		# 1 is a screen reader running, 0 none and -1 a platform that cannot say.
+		var read_aloud: bool = setting == "auto" and DisplayServer.accessibility_screen_reader_active() == 1
+		if setting != "always" and not read_aloud:
+			return _refused(
+				(
+					(
+						"UI Automation found nothing in the game's windows: the engine builds the tree a screen"
+						+ " reader reads only with accessibility/general/accessibility_support at Always Active,"
+						+ " or at Auto with a screen reader running when it starts, and this project's is %s."
+						+ ' Start the run with engineArgs ["--accessibility", "always"].'
+					)
+					% setting
+				)
+			)
+		result["_note"] = (
+			"The windows hold nothing a screen reader is told: Controls are in the tree, and Node2D and"
+			+ " Node3D are not unless the game creates elements for them."
+		)
+	elif unnamed > 0:
+		# Seen on a game naming its lines with accessibility_update_set_name: the text was there in
+		# the game and empty to the screen reader.
+		result["_note"] = (
+			(
+				"%d text element(s) on screen have no name, so a screen reader reads them as nothing. Static"
+				+ " text is read from its value, DisplayServer.accessibility_update_set_value, and a name"
+				+ " set on it is not read."
+			)
+			% unnamed
+		)
+	return result
+
+
+## The project's accessibility mode, as the command line's --accessibility names them.
+static func _setting() -> String:
+	match Read.as_int(ProjectSettings.get_setting("accessibility/general/accessibility_support", 0), 0):
+		1:
+			return "always"
+		2:
+			return "disabled"
+	return "auto"
+
+
+static func _count(element: Dictionary) -> int:
+	var total: int = 1
+	var children: Array = element.get("children", [])
+	for child: Variant in children:
+		if child is Dictionary:
+			var inner: Dictionary = child
+			total += _count(inner)
+	return total
+
+
+## Text elements with bounds and no name. A window also holds a nameless text element with no bounds
+## that no node of the game made, in every scene tried, which is left out.
+static func _unnamed_text(element: Dictionary) -> int:
+	var total: int = 0
+	if element.get("role") == "text" and str(element.get("name", "")).is_empty() and element.has("bounds"):
+		total += 1
+	var children: Array = element.get("children", [])
+	for child: Variant in children:
+		if child is Dictionary:
+			var inner: Dictionary = child
+			total += _unnamed_text(inner)
+	return total
+
+
+static func _refused(message: String) -> Dictionary:
+	return {"type": "error", "message": message}

package/build/godot/addons/gdharness_runtime/runtime_accessibility.gd.uid

@@ -0,0 +1 @@
+uid://c8abcitp7crgk

package/build/godot/addons/gdharness_runtime/runtime_autoload.gd

@@ -10,10 +10,12 @@ extends Node
 ## wanted. Both directions of the socket carry one JSON object per line. Every request names an
 ## id and the reply carries it back.
 
+const Accessibility = preload("runtime_accessibility.gd")
 const Capture = preload("runtime_capture.gd")
 const Changes = preload("runtime_changes.gd")
 const ErrorReport = preload("error_report.gd")
 const InputCommands = preload("runtime_input.gd")
+const Pad = preload("runtime_pad.gd")
 const Queries = preload("runtime_queries.gd")
 const Read = preload("reading.gd")
 const Typing = preload("runtime_typing.gd")
@@ -85,8 +87,10 @@ var _queries: Queries = Queries.new(self, values)
 var _changes: Changes = Changes.new(self, values)
 var _input: InputCommands = InputCommands.new(self, values)
 var _typing: Typing = Typing.new(self)
+var _pad: Pad = Pad.new(self)
 var _capture: Capture = Capture.new(self, values)
 var _waits: Waits = Waits.new(self, values)
+var _accessibility: Accessibility = Accessibility.new(self)
 
 var _server: TCPServer
 var _clients: Array[StreamPeerTCP] = []
@@ -128,6 +132,7 @@ func _init() -> void:
 		"set_property": _changes.set_property,
 		"call_method": _changes.call_method,
 		"get_metrics": _queries.get_metrics,
+		"get_accessibility": _accessibility.get_accessibility,
 		"capture_screenshot": _capture.capture_screenshot,
 		"capture_viewport": _capture.capture_viewport,
 		"inject_action": _input.inject_action,
@@ -135,6 +140,8 @@ func _init() -> void:
 		"inject_text": _typing.inject_text,
 		"inject_mouse_click": _input.inject_mouse_click,
 		"inject_mouse_motion": _input.inject_mouse_motion,
+		"inject_joypad_button": _pad.inject_joypad_button,
+		"inject_joypad_motion": _pad.inject_joypad_motion,
 		"click": _input.click,
 		"choose": _typing.choose,
 		"wait_frames": _waits.wait_frames,