gdharness 1.2.26 → 1.2.27

package/build/cli.js

@@ -11898,7 +11898,7 @@ var init_tool_definitions = __esm(() => {
           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",
@@ -11915,7 +11915,7 @@ var init_tool_definitions = __esm(() => {
         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",
@@ -12596,7 +12596,7 @@ var init_tool_definitions = __esm(() => {
     {
       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_PATH,
         scriptPath: SCRIPT_PATH,
@@ -12611,23 +12611,33 @@ var init_tool_definitions = __esm(() => {
     {
       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",
@@ -35698,6 +35708,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);
@@ -36203,6 +36225,26 @@ var init_editor_log = __esm(() => {
   SLOTS = [/"[^"]*"/g, /'[^']*'/g, /\b(?:res|user):\/\/\S+/g, /(?<=\.gd|\.tscn|\.cs):\d+(?::\d+)?/g];
 });
 
+// src/godot-variant.ts
+var FLAG_64, MOST_MESSAGE_BYTES;
+var init_godot_variant = __esm(() => {
+  FLAG_64 = 1 << 16;
+  MOST_MESSAGE_BYTES = (8 << 20) + 4;
+});
+
+// src/game-debugger.ts
+var PAUSE_MS = 30000, STEP_MS = 1e4, READ_MS = 5000, REPLIES;
+var init_game_debugger = __esm(() => {
+  init_godot_variant();
+  REPLIES = new Set([
+    "debug_enter",
+    "debug_exit",
+    "stack_dump",
+    "stack_frame_vars",
+    "stack_frame_var"
+  ]);
+});
+
 // node_modules/ws/lib/constants.js
 var require_constants = __commonJS(function(exports, module) {
   var BINARY_TYPES = ["nodebuffer", "arraybuffer", "fragments"];
@@ -40167,7 +40209,30 @@ var init_junit = __esm(() => {
 
 // src/keeper-channel.ts
 import { connect as connect2, createServer as createServer2 } from "node:net";
-function askTheKeeperToStop(address, withinMs) {
+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;
@@ -40185,16 +40250,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) => {
@@ -40205,6 +40269,7 @@ function askTheKeeperToStop(address, withinMs) {
     });
   });
 }
+var DEBUG_PREFIX = "debug ";
 var init_keeper_channel = () => {};
 
 // src/lifecycle-log.ts
@@ -43183,13 +43248,6 @@ var init_script_origins = __esm(() => {
   RELOADED_AT = /GDScript::reload \((res:\/\/.+):(\d+)\)$/;
 });
 
-// src/godot-variant.ts
-var FLAG_64, MOST_MESSAGE_BYTES;
-var init_godot_variant = __esm(() => {
-  FLAG_64 = 1 << 16;
-  MOST_MESSAGE_BYTES = (8 << 20) + 4;
-});
-
 // src/script-profile.ts
 import { readFileSync as readFileSync22 } from "node:fs";
 function readProfileFile(path) {
@@ -43356,7 +43414,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(" ");
 }
@@ -43486,6 +43544,30 @@ 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" };
+  }
+}
 function projectSpelling(projectPath, absolutePath) {
   return `res://${relative5(realPathOr(projectPath), realPathOr(absolutePath)).replaceAll("\\", "/")}`;
 }
@@ -45392,28 +45474,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;
@@ -45557,8 +45681,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"
         ])
       };
@@ -46769,6 +46893,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: join27(projectPath, frame["script"].slice("res://".length)) } : {}
+        }))
+      } : {}
+    });
+  }
   breakpointsAsProjectSpells(projectPath, held) {
     return held.map((one) => ({
       scriptPath: projectSpelling(projectPath, one.scriptPath),
@@ -47430,9 +47586,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,
@@ -47442,6 +47599,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),
@@ -47450,7 +47608,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) {
@@ -47977,7 +48135,8 @@ class GodotServer {
         startedAt,
         projectPath,
         ...this.servedBy(),
-        ...profile === undefined ? {} : { profile }
+        ...profile === undefined ? {} : { profile },
+        breakpoints: this.breakpointsForAGame(projectPath)
       },
       ...desktop === undefined ? {} : { desktop }
     });
@@ -49830,7 +49989,7 @@ async function runGodotServer() {
   const server = new GodotServer;
   await server.run();
 }
-var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, run4, __dirname2, PARENT_ASKED_AFTER_MS = 5000, EDITOR_SERVERS_START_MS = 20000, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, PLAY_STARTS_WITHIN_MS = 30000, KEEPER_ANSWER_MS = 15000, EXIT_REPORTED_WITHIN_MS = 2000, CONSOLE_WRAPPER, LONGEST_BOOT_NOTED_MS, PROFILE_SEND_MS = 5000, MOST_GROUPS = 20, RUNTIME_LISTENING_LINE = "[gdharness] runtime listening on ", VALUE_NAMES, BRIDGE_RETRY_MS = 2000, SUCCESSOR_CHECK_MS = 1e4, CONSOLE_WATCH_MS = 250, BOUNDARY_WAIT_MS = 2000, HANDOVER_MS, HANDOVER_POLL_MS = 250, CACHE_WRITE_MS = 2000, STREAMS_GRACE_MS = 2000, PLAYING_STATUS_MS = 1000, SCAN_START_MS = 2000, SCAN_SETTLED_MS = 500, REIMPORT_TIMEOUT_MS = 300000, EDITOR_FREE_INSTEAD, OPS_ELSEWHERE, AUDIO_BUS_OPS, STALLED_AFTER_MS = 30000, TEST_HEARTBEAT_MS = 20000, DEPENDED_FAILED = "Failed to compile depended scripts", WAIT_FOR_RUN_MS = 600000, RUN_POLL_MS = 250, PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, PROJECT_INFO_SECTIONS2, RUNNER_DIRECTORY = "addons/gdUnit4/", PROFILE_FUNCTIONS = 30, PROFILER_ON_MS = 3000, PROPERTY_PLACES = "It is a property, so each place says whether it writes it (access write), which runs its set block, or reads it (access read), which runs its get block: withinCalls on a read says nothing of the set block, nor on a write of the get block unless the write is a compound one such as +=. Inside the property's own blocks its name is the value stored, which the engine reads and writes without running them, so those lines are not listed.", CALLERS_FOUND_BY_NAME = "Found by name in the project's scripts, since the engine's profiler counts calls and time per function and records nothing about who made them: a method of the same name on another class is listed too, unless one class was asked about and it is called through another class by name or through a variable declared as one. Each place carries the profile's numbers for the function it is written in.", MOST_ENGINE_ENTRIES = 200, ERROR_ASSERT = "GdUnitGodotErrorAssertImpl.gd", EXTERNAL_MEMBER = 'Could not resolve external class member "', STATIC_LIST_HINT;
+var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, run4, __dirname2, PARENT_ASKED_AFTER_MS = 5000, EDITOR_SERVERS_START_MS = 20000, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, 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.", PLAY_STARTS_WITHIN_MS = 30000, KEEPER_ANSWER_MS = 15000, KEEPER_DEBUG_MS, EXIT_REPORTED_WITHIN_MS = 2000, CONSOLE_WRAPPER, LONGEST_BOOT_NOTED_MS, PROFILE_SEND_MS = 5000, MOST_GROUPS = 20, RUNTIME_LISTENING_LINE = "[gdharness] runtime listening on ", VALUE_NAMES, BRIDGE_RETRY_MS = 2000, SUCCESSOR_CHECK_MS = 1e4, CONSOLE_WATCH_MS = 250, BOUNDARY_WAIT_MS = 2000, HANDOVER_MS, HANDOVER_POLL_MS = 250, CACHE_WRITE_MS = 2000, STREAMS_GRACE_MS = 2000, PLAYING_STATUS_MS = 1000, SCAN_START_MS = 2000, SCAN_SETTLED_MS = 500, REIMPORT_TIMEOUT_MS = 300000, EDITOR_FREE_INSTEAD, OPS_ELSEWHERE, AUDIO_BUS_OPS, STALLED_AFTER_MS = 30000, TEST_HEARTBEAT_MS = 20000, DEPENDED_FAILED = "Failed to compile depended scripts", WAIT_FOR_RUN_MS = 600000, RUN_POLL_MS = 250, PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, PROJECT_INFO_SECTIONS2, RUNNER_DIRECTORY = "addons/gdUnit4/", PROFILE_FUNCTIONS = 30, PROFILER_ON_MS = 3000, PROPERTY_PLACES = "It is a property, so each place says whether it writes it (access write), which runs its set block, or reads it (access read), which runs its get block: withinCalls on a read says nothing of the set block, nor on a write of the get block unless the write is a compound one such as +=. Inside the property's own blocks its name is the value stored, which the engine reads and writes without running them, so those lines are not listed.", CALLERS_FOUND_BY_NAME = "Found by name in the project's scripts, since the engine's profiler counts calls and time per function and records nothing about who made them: a method of the same name on another class is listed too, unless one class was asked about and it is called through another class by name or through a variable declared as one. Each place carries the profile's numbers for the function it is written in.", MOST_ENGINE_ENTRIES = 200, ERROR_ASSERT = "GdUnitGodotErrorAssertImpl.gd", EXTERNAL_MEMBER = 'Could not resolve external class member "', STATIC_LIST_HINT;
 var init_server = __esm(() => {
   init_dist();
   init_stdio();
@@ -49849,6 +50008,7 @@ var init_server = __esm(() => {
   init_editor_log();
   init_engine_run();
   init_errors();
+  init_game_debugger();
   init_game_log();
   init_gdscript_source();
   init_godot_bridge();
@@ -49886,6 +50046,7 @@ var init_server = __esm(() => {
   init_update_check();
   run4 = promisify5(execFile5);
   __dirname2 = dirname20(fileURLToPath5(import.meta.url));
+  KEEPER_DEBUG_MS = PAUSE_MS + STEP_MS + 2 * READ_MS;
   CONSOLE_WRAPPER = /_console(\.exe)?$/i;
   LONGEST_BOOT_NOTED_MS = 5 * 60000;
   VALUE_NAMES = {

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

@@ -100,15 +100,19 @@ try {
   $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)
+    # The window's corner is read on every walk: before the engine builds its tree the window is
+    # its frame, and after it the client area inside it, so a corner read once placed everything
+    # by the frame's.
+    $r = $root.Current.BoundingRectangle
     $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
+      $r = $root.Current.BoundingRectangle
       $tree = Describe $root $r.X $r.Y 0
       $count = Count $tree
       if ($count -gt 1 -and $count -eq $last) { break }