gdharness 1.2.25 → 1.2.27

package/build/index.js

@@ -24933,12 +24933,27 @@ var ENGINE_FLAGS = Object.freeze({
   "--fixed-fps": "number",
   "--max-fps": "number",
   "--resolution": "size",
-  "--write-movie": "file"
+  "--write-movie": "file",
+  "--rendering-driver": "driver",
+  "--rendering-method": "method",
+  "--accessibility": "accessibility"
 });
 var 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"
+  }
 };
 var SET_BY_ARGUMENT = Object.freeze({
   "--headless": "headless",
@@ -24954,7 +24969,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") {
@@ -27914,6 +27929,18 @@ class GodotDAPClient {
       lines: Array.from(lines).sort((a, b) => a - b)
     }));
   }
+  forgetBreakpoint(scriptPath, line) {
+    const key = fileKey(scriptPath);
+    const lines = this.breakpoints.get(key);
+    if (lines === undefined) {
+      return;
+    }
+    lines.delete(line);
+    if (lines.size === 0) {
+      this.breakpoints.delete(key);
+      this.spelled.delete(key);
+    }
+  }
   holdBreakpoints(held) {
     for (const { scriptPath, lines } of held) {
       const key = fileKey(scriptPath);
@@ -28692,6 +28719,22 @@ function howItEnded(run) {
   return run.exitSignal === null ? `exit code ${run.exitCode ?? "unknown"}` : `ended by ${run.exitSignal}`;
 }
 
+// src/godot-variant.ts
+var FLAG_64 = 1 << 16;
+var MOST_MESSAGE_BYTES = (8 << 20) + 4;
+
+// src/game-debugger.ts
+var PAUSE_MS = 30000;
+var STEP_MS = 1e4;
+var READ_MS = 5000;
+var REPLIES = new Set([
+  "debug_enter",
+  "debug_exit",
+  "stack_dump",
+  "stack_frame_vars",
+  "stack_frame_var"
+]);
+
 // src/godot-bridge.ts
 import { randomUUID } from "node:crypto";
 import { EventEmitter } from "node:events";
@@ -29643,7 +29686,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("; ");
   }
@@ -29655,6 +29698,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(dirname8(script)), spelled(resolvedOr(dirname8(script)))])];
@@ -29774,6 +29820,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,
@@ -30313,7 +30368,31 @@ function testProgressMessage(printed, elapsedMs) {
 
 // src/keeper-channel.ts
 import { connect, createServer as createServer2 } from "node:net";
-function askTheKeeperToStop(address, withinMs) {
+var DEBUG_PREFIX = "debug ";
+async function askTheKeeperToStop(address, withinMs) {
+  const answered = await askTheKeeper(address, "stop", withinMs);
+  if (typeof answered !== "string") {
+    return answered;
+  }
+  return answered === "signalled" || answered === "gone" ? answered : { unreached: `it answered ${JSON.stringify(answered)}` };
+}
+async function askTheKeepersDebugger(address, request, withinMs) {
+  const answered = await askTheKeeper(address, `${DEBUG_PREFIX}${JSON.stringify(request)}`, withinMs);
+  if (typeof answered !== "string") {
+    return answered;
+  }
+  if (answered === "unknown") {
+    return { unreached: "its keeper was started by a gdharness from before game debuggers, and has none" };
+  }
+  try {
+    const parsed = JSON.parse(answered);
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      return parsed;
+    }
+  } catch {}
+  return { unreached: `it answered ${JSON.stringify(answered.slice(0, 200))}` };
+}
+function askTheKeeper(address, line, withinMs) {
   return new Promise((resolve) => {
     let said = "";
     let settled = false;
@@ -30331,16 +30410,15 @@ function askTheKeeperToStop(address, withinMs) {
     }, withinMs);
     socket.setEncoding("utf8");
     socket.on("connect", () => {
-      socket.write(`stop
+      socket.write(`${line}
 `);
     });
     socket.on("data", (chunk) => {
       said += chunk;
-      const line = said.split(`
-`)[0] ?? "";
       if (said.includes(`
 `)) {
-        settle(line === "signalled" || line === "gone" ? line : { unreached: `it answered ${JSON.stringify(line)}` });
+        settle(said.split(`
+`)[0] ?? "");
       }
     });
     socket.on("error", (error) => {
@@ -33841,12 +33919,6 @@ function withoutListed(entries, errors) {
 
 // src/script-profile.ts
 import { readFileSync as readFileSync19 } from "node:fs";
-
-// src/godot-variant.ts
-var FLAG_64 = 1 << 16;
-var MOST_MESSAGE_BYTES = (8 << 20) + 4;
-
-// src/script-profile.ts
 function readProfileFile(path) {
   try {
     const parsed = JSON.parse(readFileSync19(path, "utf8"));
@@ -34221,7 +34293,7 @@ var TOOL_SPECS = [
   {
     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_PATH2,
       setting: {
@@ -34406,7 +34478,7 @@ var TOOL_SPECS = [
       },
       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: {
@@ -34494,7 +34566,7 @@ var TOOL_SPECS = [
       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",
@@ -34965,13 +35037,13 @@ var TOOL_SPECS = [
         type: "array",
         items: { type: "string" },
         ops: ["start", "check"],
-        description: `The game's own arguments, what OS.get_cmdline_user_args() answers, such as ["--level=2"]. The separator is added here, so a flag the engine reads goes to the game instead, and the answer says so under argsNote. A run with any is started by this server rather than by the editor, which fixes the game's command line when it opens the project, so the debug_* tools do not answer for it.`
+        description: `The game's own arguments, what OS.get_cmdline_user_args() answers, such as ["--level=2"]. The separator is added here, so a flag the engine reads goes to the game instead, and the answer says so under argsNote. A run with any is started by this server rather than by the editor, which fixes the game's command line when it opens the project, so its debugger is the keeper holding it rather than the editor; the debug_* tools answer for it all the same.`
       },
       engineArgs: {
         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: {
@@ -34982,7 +35054,7 @@ var TOOL_SPECS = [
       silent: {
         type: "boolean",
         ops: ["start"],
-        description: "start: run the game with no sound out of the machine, by starting the engine with --audio-driver Dummy: every stream still plays and every playback position still advances, so what is playing can still be asked. The editor takes no engine flags for a game it plays, so a silent windowed run is started by this server, and the debug_* tools do not answer for it. A headless run, check's included, is silent already. Default false, or true when GDHARNESS_SILENT is set in the server's environment to anything but 0 or false; silent: false then plays through the editor as before."
+        description: "start: run the game with no sound out of the machine, by starting the engine with --audio-driver Dummy: every stream still plays and every playback position still advances, so what is playing can still be asked. The editor takes no engine flags for a game it plays, so a silent windowed run is started by this server, whose keeper is its debugger rather than the editor. A headless run, check's included, is silent already. Default false, or true when GDHARNESS_SILENT is set in the server's environment to anything but 0 or false; silent: false then plays through the editor as before."
       },
       savesIn: {
         type: "string",
@@ -35211,7 +35283,7 @@ var TOOL_SPECS = [
   {
     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,
@@ -35280,7 +35352,7 @@ var TOOL_SPECS = [
       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: [],
@@ -35308,7 +35380,12 @@ var TOOL_SPECS = [
       },
       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: []
       }
     },
@@ -35438,7 +35515,7 @@ var TOOL_SPECS = [
     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,
@@ -35459,8 +35536,8 @@ var TOOL_SPECS = [
       },
       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",
@@ -35505,8 +35582,26 @@ var TOOL_SPECS = [
       },
       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",
@@ -35556,6 +35651,16 @@ var TOOL_SPECS = [
         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"]
       }
     }
   },
@@ -35630,7 +35735,7 @@ var TOOL_SPECS = [
   {
     name: "debug_breakpoint",
     title: "Breakpoints",
-    description: "Sets or removes a breakpoint through the editor's debug adapter. Needs the editor, not a running game: set them first, then editor_run, and the game stops where you asked. The editor keeps a breakpoint set this way for one play, so every breakpoint this server holds is sent again before each play editor_run starts, and the start answer lists them under breakpoints. The set is also kept in the project, for the server that comes after a reconnect: a breakpoint stays until it is removed here, whichever server set it. Every answer lists the whole set under held, and the breakpoints the user set in the editor's own gutter under setInEditor; setting one here never takes those away, and removing a line here clears it whoever set it. Godot clears every breakpoint in the editor when a debug session opens unless network/debug_adapter/sync_breakpoints is on, which the addon turns on as it loads; an editor running an older addon is said so under breakpointsAtRisk, here and in editor_status.",
+    description: "Sets or removes a breakpoint. Set them first, then editor_run, and the game stops where you asked. With the editor connected it goes through the editor's debug adapter; with none, it is held here. A game this server starts itself, which editor_run start does for a run given args, savesIn, env or silent, or with no editor, is handed every breakpoint held here as it starts, and one set while that game runs reaches it at once (runningGame says so). The editor keeps a breakpoint set this way for one play, so every breakpoint this server holds is sent again before each play editor_run starts, and the start answer lists them under breakpoints. The set is also kept in the project, for the server that comes after a reconnect: a breakpoint stays until it is removed here, whichever server set it. Every answer lists the whole set under held, and the breakpoints the user set in the editor's own gutter under setInEditor; setting one here never takes those away, and removing a line here clears it whoever set it. Godot clears every breakpoint in the editor when a debug session opens unless network/debug_adapter/sync_breakpoints is on, which the addon turns on as it loads; an editor running an older addon is said so under breakpointsAtRisk, here and in editor_status.",
     parameters: {
       projectPath: PROJECT_PATH2,
       scriptPath: SCRIPT_PATH,
@@ -35645,23 +35750,33 @@ var TOOL_SPECS = [
   {
     name: "debug_control",
     title: "Step the debugger",
-    description: "Continues or steps the debugged game through the editor's debug adapter. A step waits for the game to stop again and answers with the stack where it ended up; one that has not stopped the game again within ten seconds answers heldAgain false and no stack. There is no pause and no step_out: Godot's adapter answers a pause by reporting the game stopped and leaving it running, and implements no stepOut at all, so hold the game where you want it with a breakpoint and step over or into from there.",
+    description: "Pauses, continues or steps the debugged game. A step waits for the game to stop again and answers with the stack where it ended up; one that has not stopped the game again within ten seconds answers heldAgain false and no stack. A game the editor plays is moved through the editor's debug adapter, which cannot pause or step out: it answers a pause by reporting the game stopped and leaving it running, and implements no stepOut, so hold such a game with a breakpoint and step over or into from there. A game this server started itself has its keeper as its debugger, which does both: pause breaks into the game wherever it is, a script spinning in a loop included, which is how a game hung on its first frame is asked where it is.",
     parameters: {},
     requires: [],
     operations: {
+      pause: {
+        effect: "additive",
+        summary: "stop a game this server started where it is, answering with the stack. The game takes it between frames, and in a script every 2048 lines it runs, so a loop that sleeps between few lines can take seconds; the call waits thirty, and past that answers paused false with the request still standing. Stopped between frames, where no script runs, the game is stepped on to the next line of script it runs",
+        requires: []
+      },
       continue: { effect: "additive", summary: "resume after a breakpoint", requires: [] },
       step_over: { effect: "additive", summary: "run the current line", requires: [] },
       step_into: {
         effect: "additive",
         summary: "run the current line, stopping inside whatever it calls",
         requires: []
+      },
+      step_out: {
+        effect: "additive",
+        summary: "run to the end of the current function and stop in its caller; a game this server started only",
+        requires: []
       }
     }
   },
   {
     name: "debug_state",
     title: "Debugger state",
-    description: "Where the debugged game is stopped: the stack trace, what is in scope at a frame with the values, or the debug adapter's console output so far, its last thousand lines, with any earlier ones counted under notShown. A stop is reported by the editor's adapter only to the sessions connected when it happened, so a server that connected afterwards, which is every server after a reconnect, is shown a thread and no frames about a game still sitting at its breakpoint. That server asks the runtime instead: a held game accepts a connection and never answers, and the refusal then says held rather than running, and that the stack cannot be read from here. debug_control continue lets it go, and the next stop is one this session is told about, with its stack.",
+    description: "Where the debugged game is stopped: the stack trace, what is in scope at a frame with the values, or the debugger's console output so far, its last thousand lines, with any earlier ones counted under notShown. For a game this server started, its keeper's debugger answers: each frame names its script as the project spells it under script and on this machine under path, and held says which thread stopped and why. For a game the editor plays, the editor's debug adapter answers. A stop is reported by the editor's adapter only to the sessions connected when it happened, so a server that connected afterwards, which is every server after a reconnect, is shown a thread and no frames about a game still sitting at its breakpoint. That server asks the runtime instead: a held game accepts a connection and never answers, and the refusal then says held rather than running, and that the stack cannot be read from here. debug_control continue lets it go, and the next stop is one this session is told about, with its stack.",
     parameters: {
       frameId: {
         type: "number",
@@ -35751,7 +35866,7 @@ function serverInstructions() {
     "Call editor_status first: it says whether an editor is connected and whether its addon matches this server.",
     "Start the game with editor_run start, never by spawning an engine, and read editor_output after every run:",
     "its clean verdict and its error entries are how a run is judged, and editor_run wait is how to wait for one.",
-    "The runtime_* tools work on the running game and the debug_* tools on the editor's debugger.",
+    "The runtime_* tools work on the running game and the debug_* tools on its debugger.",
     "A refusal names what would have worked, so read it before calling again."
   ].join(" ");
 }
@@ -36092,6 +36207,31 @@ function longerWaitNote(tool, op, waitedMs) {
   const how = tool === "runtime_wait" && op === "frames" ? `the wait is counted from the number of frames, at ${SLOWEST_FRAME_RATE} a second on top of GDHARNESS_RUNTIME_TIMEOUT_MS: a game drawing frames more slowly than that is waited on in fewer frames at a time, and a game inside one long frame, such as a long _ready, answers no call however few frames are asked for` : "the wait is GDHARNESS_RUNTIME_TIMEOUT_MS, which is set in the environment the server is started with";
   return `${tool} ${op} takes no timeoutMs: it was given ${waitedMs}ms, and ${how}.`;
 }
+function keptGameRequest(tool, op, args) {
+  if (tool === "debug_state") {
+    if (op === "output") {
+      return { op: "output" };
+    }
+    if (op === "variables") {
+      const frame = args["frameId"];
+      return { op: "variables", frame: typeof frame === "number" ? frame : 0 };
+    }
+    return { op: "stack" };
+  }
+  switch (op) {
+    case "pause":
+      return { op: "pause" };
+    case "step_over":
+      return { op: "resume", how: "next" };
+    case "step_into":
+      return { op: "resume", how: "step" };
+    case "step_out":
+      return { op: "resume", how: "out" };
+    default:
+      return { op: "resume", how: "continue" };
+  }
+}
+var OWN_DEBUGGER = " Its debugger is the keeper holding it rather than the editor, so the debug_* tools answer for it all the same: breakpoints stop it, and debug_control pause breaks into it wherever it is, which the editor offers no way to do.";
 function projectSpelling(projectPath, absolutePath) {
   return `res://${relative4(realPathOr(projectPath), realPathOr(absolutePath)).replaceAll("\\", "/")}`;
 }
@@ -36179,6 +36319,7 @@ function stopWaitMs() {
   return waitFromEnv("GDHARNESS_STOP_WAIT_MS", 1e4);
 }
 var KEEPER_ANSWER_MS = 15000;
+var KEEPER_DEBUG_MS = PAUSE_MS + STEP_MS + 2 * READ_MS;
 var EXIT_REPORTED_WITHIN_MS = 2000;
 async function untilGone(pids, withinMs = stopWaitMs()) {
   const gone = () => pids.every((pid) => !alive(pid));
@@ -38014,6 +38155,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 });
         }
@@ -38073,28 +38220,70 @@ class GodotServer {
           return this.createErrorResponse(located.reason, PATH_SOLUTIONS);
         }
         const session = this.dapHoldingBreakpointsOf(project.value.path);
-        const answered = await this.handleDAP(op === "set" ? "dap_set_breakpoint" : "dap_remove_breakpoint", {
-          ...args,
-          scriptPath: realPathOr(located.absolutePath)
-        });
-        if (answered.isError === true) {
-          return answered;
+        const scriptPath = realPathOr(located.absolutePath);
+        const line = readPositiveNumber(args, "line");
+        if (line === undefined) {
+          return this.createErrorResponse("line is required: the one-based line to stop on.");
+        }
+        const editor = this.godotBridge.isConnected();
+        let answer;
+        if (editor) {
+          const answered = await this.handleDAP(op === "set" ? "dap_set_breakpoint" : "dap_remove_breakpoint", {
+            ...args,
+            scriptPath
+          });
+          if (answered.isError === true) {
+            return answered;
+          }
+          answer = asParams(JSON.parse(answered.content[0]?.text ?? "{}"));
+        } else {
+          if (op === "set") {
+            session.holdBreakpoints([{ scriptPath, lines: [line] }]);
+          } else {
+            session.forgetBreakpoint(scriptPath, line);
+          }
+          answer = { [op === "set" ? "set" : "removed"]: true };
         }
         const held = session.breakpointsHeld();
         writeBreakpointNote(project.value.path, held);
+        const kept = this.keptRun();
+        const told = kept === null ? null : await askTheKeepersDebugger(kept.keeper, {
+          op: "breakpoint",
+          script: projectSpelling(project.value.path, scriptPath),
+          line,
+          set: op === "set"
+        }, KEEPER_DEBUG_MS);
         return this.jsonTextResponse({
-          ...asParams(JSON.parse(answered.content[0]?.text ?? "{}")),
+          ...answer,
           held: this.breakpointsAsProjectSpells(project.value.path, held),
-          setInEditor: this.breakpointsAsProjectSpells(project.value.path, session.breakpointsInEditor()),
-          note: "The editor keeps a breakpoint set this way for one play. Every breakpoint held here is sent again before each play editor_run starts, and kept in the project for the server after a reconnect.",
-          ...this.breakpointsAtRisk()
+          ...editor ? {
+            setInEditor: this.breakpointsAsProjectSpells(project.value.path, session.breakpointsInEditor())
+          } : {},
+          ...told === null ? {} : ("unreached" in told) || typeof told["refused"] === "string" ? {
+            runningGame: `The game this server started is running, and its debugger was not told: ${String("unreached" in told ? told.unreached : told["refused"])}. It takes the line when it is started again.`
+          } : {
+            runningGame: `Told to the running game (pid ${kept?.pid ?? "?"}), which this server started.`
+          },
+          note: editor ? "The editor keeps a breakpoint set this way for one play. Every breakpoint held here is sent again before each play editor_run starts, handed to every game this server starts itself, and kept in the project for the server after a reconnect." : "No editor is connected, so the set under held is kept here: every game this server starts is handed it as it starts, an editor that connects is sent it before its first play, and it is kept in the project for the server after a reconnect.",
+          ...editor ? this.breakpointsAtRisk() : {}
         });
       }
       case "debug_control":
       case "debug_state": {
+        const kept = this.keptRun();
+        if (kept !== null) {
+          return await this.askTheKeptGame(kept.keeper, keptGameRequest(tool, op, args), kept.projectPath ?? "");
+        }
         if (tool === "debug_state" && op === "output") {
           return await this.handleDAP("dap_get_output", args);
         }
+        const played = this.activeProcess;
+        if ((op === "pause" || op === "step_out") && played?.throughEditor === true && !exited(played)) {
+          return this.createErrorResponse(op === "pause" ? "A game the editor plays cannot be paused from here: Godot's debug adapter answers a pause by reporting the game stopped and leaving it running." : "A game the editor plays cannot be stepped out of a function from here: Godot's debug adapter implements no stepOut.", [
+            "Set a breakpoint where it should stop, then step over or into from there",
+            "A game this server starts, as editor_run start does with args, savesIn or env, has a debugger here that pauses and steps out"
+          ]);
+        }
         const held = await this.debuggedGame(tool === "debug_control" ? "move" : "read");
         if (!held.ok) {
           return held.response;
@@ -38238,8 +38427,8 @@ class GodotServer {
     if (!game.throughEditor) {
       return {
         ok: false,
-        response: this.createErrorResponse("The running game is its own process, so no debugger is holding it: breakpoints never hit and there is no stack to read.", [
-          "editor_run start plays it through the open editor, whose debugger the debug_* tools speak to",
+        response: this.createErrorResponse("The running game has no debugger: it was started with none, or by a keeper that could not take questions, so breakpoints never hit and there is no stack to read.", [
+          "editor_run start starts it again, and the keeper holding a game this server starts is its debugger",
           "editor_status says whether an editor has reached this server"
         ])
       };
@@ -39450,6 +39639,38 @@ class GodotServer {
       breakpointsAtRisk: status.syncsBreakpoints === false ? "This editor clears every breakpoint in its script editor whenever a debug session opens on its adapter, which this server does for its first breakpoint or stack read: network/debug_adapter/sync_breakpoints is off. The installed addon turns it on as it loads, so the editor is running an older one; editor_launch restart puts the installed addon in, or turn the setting on in Editor Settings > Network > Debug Adapter." : "Whether this editor keeps its breakpoints when a debug session opens cannot be told: the addon it is running predates the report. Godot clears them unless network/debug_adapter/sync_breakpoints is on, which the installed addon turns on as it loads; editor_launch restart puts the installed addon in."
     };
   }
+  breakpointsForAGame(projectPath) {
+    return this.dapHoldingBreakpointsOf(projectPath).breakpointsHeld().flatMap((one) => one.lines.map((line) => `${projectSpelling(projectPath, one.scriptPath)}:${line}`));
+  }
+  keptRun() {
+    const game = this.activeProcess;
+    if (game === null || game.throughEditor || exited(game) || game.keeper === undefined) {
+      return null;
+    }
+    return { ...game, keeper: game.keeper };
+  }
+  async askTheKeptGame(keeper, request, projectPath) {
+    const answered = await askTheKeepersDebugger(keeper, request, KEEPER_DEBUG_MS);
+    if ("unreached" in answered) {
+      return this.createErrorResponse(`The debugger of the running game did not answer: ${String(answered.unreached)}.`, [
+        "editor_run start starts the game again, with a debugger",
+        "editor_status says whether it is still running"
+      ]);
+    }
+    if (typeof answered["refused"] === "string") {
+      return this.createErrorResponse(answered["refused"]);
+    }
+    const stack = answered["stack"];
+    return this.jsonTextResponse({
+      ...answered,
+      ...Array.isArray(stack) ? {
+        stack: stack.map((frame) => ({
+          ...frame,
+          ...projectPath !== "" && typeof frame["script"] === "string" && frame["script"].startsWith("res://") ? { path: join23(projectPath, frame["script"].slice("res://".length)) } : {}
+        }))
+      } : {}
+    });
+  }
   breakpointsAsProjectSpells(projectPath, held) {
     return held.map((one) => ({
       scriptPath: projectSpelling(projectPath, one.scriptPath),
@@ -40111,9 +40332,10 @@ class GodotServer {
     started.announcedBefore = alreadyPlaying;
     started.bootScene = runtimeWaitMs.scene;
     this.activeProcess = started;
-    const spawnedInstead = this.godotBridge.isConnected() && editorWouldPlay && (given.value.length > 0 || flags.value.length > 0) ? " The editor cannot be handed arguments for a game it plays, so this one was started " + "here: the debug_* tools answer only for a game the editor is playing." : this.godotBridge.isConnected() && editorWouldPlay && needsItsOwnProcess(asked.value) ? " The editor plays a game with its own environment, so a run given one was started " + "here: the debug_* tools answer only for a game the editor is playing." : this.godotBridge.isConnected() && editorWouldPlay && silent ? " The editor cannot play a game silent, which takes an engine flag, so this one was " + `started here${args["silent"] === true ? "" : ", silent because GDHARNESS_SILENT says so"}: the debug_* tools answer only for a game the editor is playing, and silent: false plays it through the editor.` : "";
+    const spawnedInstead = this.godotBridge.isConnected() && editorWouldPlay && (given.value.length > 0 || flags.value.length > 0) ? ` The editor cannot be handed arguments for a game it plays, so this one was started here.${OWN_DEBUGGER}` : this.godotBridge.isConnected() && editorWouldPlay && needsItsOwnProcess(asked.value) ? ` The editor plays a game with its own environment, so a run given one was started here.${OWN_DEBUGGER}` : this.godotBridge.isConnected() && editorWouldPlay && silent ? " The editor cannot play a game silent, which takes an engine flag, so this one was " + `started here${args["silent"] === true ? "" : ", silent because GDHARNESS_SILENT says so"}, and silent: false plays it through the editor.${OWN_DEBUGGER}` : "";
     const endedForThis = endedToStartThis(ended);
     const stranded = wereHereFirst.filter((one) => one.pid !== ended?.pid && alive(one.pid));
+    const handed = this.dapHoldingBreakpointsOf(project.value.path).breakpointsHeld();
     const alsoRunning = leftRunningNote(stranded);
     return this.jsonTextResponse({
       started: true,
@@ -40123,6 +40345,7 @@ class GodotServer {
       arguments: cmdArgs,
       argsNote: engineFlagsNote(given.value),
       transcript: started.transcript,
+      breakpoints: started.keeper === undefined || handed.length === 0 ? undefined : this.breakpointsAsProjectSpells(project.value.path, handed),
       profile: profileOnStart(profiled, "gdharness", runtimeAddonRegistered(project.value.path)),
       refreshedClasses: refreshed.value,
       ...scanWaitAnswer(scanned),
@@ -40131,7 +40354,7 @@ class GodotServer {
       previousRunLeft: previousRunLeft(ended),
       ...previousRunHow(ended),
       runtime: await this.runtimeUp(project.value.path, alreadyPlaying, runtimeWaitMs, given.value.length > 0),
-      message: `Use editor_output for what it prints and editor_run stop to end it.${spawnedInstead}${endedForThis}${alsoRunning}`
+      message: `Use editor_output for what it prints and editor_run stop to end it.${started.keeper !== undefined && handed.length > 0 ? " It stops at the lines under breakpoints, and debug_state stack reads where it is held." : ""}${spawnedInstead}${endedForThis}${alsoRunning}`
     });
   }
   async runtimeUp(projectPath, before, budget, withArgs) {
@@ -40658,7 +40881,8 @@ class GodotServer {
         startedAt,
         projectPath,
         ...this.servedBy(),
-        ...profile === undefined ? {} : { profile }
+        ...profile === undefined ? {} : { profile },
+        breakpoints: this.breakpointsForAGame(projectPath)
       },
       ...desktop === undefined ? {} : { desktop }
     });