gdharness 1.1.11 → 1.1.12

package/build/cli.js

@@ -17209,7 +17209,7 @@ var init_tool_definitions = __esm(() => {
         says: {
           type: "string",
           ops: ["click"],
-          description: "click: the words on the control to click, matched the way runtime_inspect find matches says (a plain word is contained in the text, a pattern with * or ? is a glob over it), among the controls on screen, and pressed in the same frame it was found in, so a panel rebuilding between a find and a click cannot free it first. Words on a label inside a button press the button. Several matches are refused with each one listed, and index picks one."
+          description: "click: the words on the control to click, matched the way runtime_inspect find matches says (a plain word is contained in the text, a pattern with * or ? is a glob over it), among the controls on screen, and pressed in the same frame it was found in, so a panel rebuilding between a find and a click cannot free it first. Words on a label inside a button press the button. A control with something drawn over its centre that would take the pointer, such as a screen shown over it, is not on screen. The matches are ranked the way a person picks what to press: a button before text that cannot be pressed, then a control whose whole text is the words before one saying them as part of more, and the best one is pressed; found.picked says why. Several matches at the best rank are refused with each one listed, and index picks one."
         },
         action: {
           type: "string",
@@ -17247,7 +17247,7 @@ var init_tool_definitions = __esm(() => {
         index: {
           type: "number",
           ops: ["click", "choose"],
-          description: "click: which of several controls saying the words, counting from 0 in the order a refusal lists them. choose: the item to take, by where it is in the list, when text will not do."
+          description: "click: which of several controls saying the words, counting from 0 in the order a refusal lists them, best matches first. choose: the item to take, by where it is in the list, when text will not do."
         },
         shift: { type: "boolean", ops: ["key"], description: "key: hold Shift with it. Default false." },
         ctrl: { type: "boolean", ops: ["key"], description: "key: hold Ctrl with it. Default false." },
@@ -17340,7 +17340,7 @@ var init_tool_definitions = __esm(() => {
         says: {
           type: "string",
           ops: ["until"],
-          description: "until: wait for these words to appear anywhere under nodePath, or anywhere in the game when no nodePath is given, instead of for a property, which is how a panel that rebuilds its labels is waited on at all: the labels are named afresh each redraw and the panel is what stays put. Case-insensitive, part of a line, on a node the player can see unless includeHidden says otherwise; a label with a line break is matched with the break in the words, and a backslash followed by n counts as one. Instead of, not as well as: a call carrying this and a property is refused, because they ask about different things and answering one of them silently is how a caller watches a screen believing they are watching a property. It looks every frame while a look is cheap and less often on a screen large enough for a look to cost a real share of a frame, so the game keeps its speed; the answer counts the frames the wait spanned and the looks it took."
+          description: "until: wait for these words to appear anywhere under nodePath, or anywhere in the game when no nodePath is given, instead of for a property, which is how a panel that rebuilds its labels is waited on at all: the labels are named afresh each redraw and the panel is what stays put. Matched the way runtime_inspect find matches says: case-insensitive, a plain word anywhere in the text, a pattern with * or ? a glob over the whole of it; on a node the player can see unless includeHidden says otherwise; a label with a line break is matched with the break in the words, and a backslash followed by n counts as one. Instead of, not as well as: a call carrying this and a property is refused, because they ask about different things and answering one of them silently is how a caller watches a screen believing they are watching a property. It looks every frame while a look is cheap and less often on a screen large enough for a look to cost a real share of a frame, so the game keeps its speed; the answer counts the frames the wait spanned and the looks it took."
         },
         includeHidden: {
           type: "boolean",
@@ -32197,6 +32197,28 @@ function errorReportOf(pid, directories = runtimeDirectories()) {
   }
   return null;
 }
+function consoleBoundaryAt(bytes) {
+  const wanted = Buffer.from(CONSOLE_BOUNDARY);
+  for (let at = bytes.indexOf(wanted);at !== -1; at = bytes.indexOf(wanted, at + 1)) {
+    if (at === 0 || bytes[at - 1] === 10) {
+      return at;
+    }
+  }
+  return -1;
+}
+function reportAlreadyInTranscript(transcript, report) {
+  const boundary = consoleBoundaryAt(report);
+  if (boundary === -1) {
+    return 0;
+  }
+  const inTranscript = consoleBoundaryAt(transcript);
+  if (inTranscript === -1) {
+    return boundary;
+  }
+  const copied = transcript.subarray(inTranscript);
+  const end = boundary + copied.length;
+  return end <= report.length && report.subarray(boundary, end).equals(copied) ? end : report.length;
+}
 function processAlive(pid) {
   try {
     process.kill(pid, 0);
@@ -32641,7 +32663,7 @@ function runtimeRequest(endpoint, command, params, timeoutMs, keepListening = fa
     });
   });
 }
-var RUNTIME_PROTOCOL = 2, ANNOUNCEMENT_PATTERN, ERROR_REPORT_PATTERN, ERROR_REPORT_KEEP_MS, GONE_WINDOW_MS = 120000, GONE_KEPT = 32, gone, STARTED_AFTER_ANNOUNCING_MS = 2000, CONFIRMED_FOR_MS = 60000, JUDGED_AFTER_MS = 60000, verdicts, ENDED_WITHIN_MS = 3000, LOOK_EVERY_MS = 50, ANNOUNCE_BUDGET_MS = 5000, nextRequestId = 1, LATE_ANSWER_MS, LATE_KEPT = 50, lateAnswers;
+var RUNTIME_PROTOCOL = 2, ANNOUNCEMENT_PATTERN, ERROR_REPORT_PATTERN, CONSOLE_BOUNDARY = "[gdharness] runtime listening on ", ERROR_REPORT_KEEP_MS, GONE_WINDOW_MS = 120000, GONE_KEPT = 32, gone, STARTED_AFTER_ANNOUNCING_MS = 2000, CONFIRMED_FOR_MS = 60000, JUDGED_AFTER_MS = 60000, verdicts, ENDED_WITHIN_MS = 3000, LOOK_EVERY_MS = 50, ANNOUNCE_BUDGET_MS = 5000, nextRequestId = 1, LATE_ANSWER_MS, LATE_KEPT = 50, lateAnswers;
 var init_runtime_client = __esm(() => {
   init_paths();
   init_process_children();
@@ -39230,6 +39252,7 @@ class GodotServer {
   bridgeStartupError = null;
   bridgeRetry = null;
   successorWatch = null;
+  consoleWatch = null;
   lastProjectPath = null;
   shutdownInitiated = false;
   launchedEditor = null;
@@ -39402,10 +39425,30 @@ class GodotServer {
       this.successorWatch = null;
     }
   }
+  watchThePlayedConsole() {
+    if (this.consoleWatch !== null) {
+      return;
+    }
+    const watch = setInterval(() => {
+      const run = this.activeProcess;
+      if (run?.throughEditor !== true || run.transcript === null) {
+        clearInterval(watch);
+        this.consoleWatch = null;
+        return;
+      }
+      this.drainErrorReport(run);
+    }, CONSOLE_WATCH_MS);
+    watch.unref();
+    this.consoleWatch = watch;
+  }
   async cleanup() {
     this.logDebug("Cleaning up resources");
     this.stopTryingTheBridge();
     this.stopWatchingForASuccessor();
+    if (this.consoleWatch !== null) {
+      clearInterval(this.consoleWatch);
+      this.consoleWatch = null;
+    }
     withdrawBridge(this.announcedAt);
     this.announcedAt = null;
     this.activeProcess = null;
@@ -40973,7 +41016,16 @@ class GodotServer {
   }
   writeToTranscript(line) {
     const run = this.activeProcess;
-    if (run?.throughEditor !== true || run.transcript === null) {
+    if (run?.throughEditor !== true) {
+      return;
+    }
+    if (run.consoleFromReport === true || line.startsWith(CONSOLE_BOUNDARY)) {
+      this.drainErrorReport(run, line);
+      if (run.consoleFromReport === true) {
+        return;
+      }
+    }
+    if (run.transcript === null) {
       return;
     }
     try {
@@ -41526,6 +41578,7 @@ class GodotServer {
       seenPlaying: readBoolean(playAnswer, "playing") === true
     };
     this.activeProcess = played;
+    this.watchThePlayedConsole();
     writeEditorRunNote({ projectPath, transcript: transcript.path, startedAt });
     sweepTranscripts();
     return this.jsonTextResponse({
@@ -41543,7 +41596,7 @@ class GodotServer {
         reason: one.reason
       })),
       runtime: await this.runtimeUp(projectPath, alreadyPlaying, runtimeWaitMs, false),
-      message: "The editor is playing it, so its debugger holds it: the debug_* tools can reach it, " + "editor_output reads its console through the debug adapter, and editor_run stop ends it." + endedToStartThis(ended)
+      message: "The editor is playing it, so its debugger holds it: the debug_* tools can reach it, " + "editor_output reads its console through the debug adapter and the runtime's report of it, and editor_run stop ends it." + endedToStartThis(ended)
     });
   }
   drainEditorOutput(game) {
@@ -41555,26 +41608,35 @@ class GodotServer {
       return;
     }
     if (game.transcript === null) {
-      for (const line of this.dapClient.getOutput(true)) {
-        game.log.append("stdout", line.endsWith(`
+      const heard = this.dapClient.getOutput(true);
+      if (game.consoleFromReport !== true) {
+        for (const line of heard) {
+          game.log.append("stdout", line.endsWith(`
 `) ? line : `${line}
 `);
+        }
       }
     }
-    if (!this.dapClient.isConnected()) {
+    if (!this.dapClient.isConnected() && game.consoleFromReport !== true) {
       game.consoleLost = true;
     }
     this.recordWhatItBrokeOn(game);
   }
-  drainErrorReport(game) {
+  drainErrorReport(game, heard) {
+    if (game.errorReport === null) {
+      return;
+    }
     if (game.errorReport === undefined) {
-      const its = this.announcedPidOf(game);
+      const its = this.announcedPidOf(game) ?? (heard?.startsWith(CONSOLE_BOUNDARY) === true ? this.announcedPidNamedBy(game, heard) : undefined);
       const found = its === undefined ? null : errorReportOf(its);
       if (found === null) {
+        if (heard?.startsWith(CONSOLE_BOUNDARY) === true) {
+          game.errorReport = null;
+        }
         return;
       }
       game.errorReport = found;
-      game.errorReportOffset = 0;
+      game.errorReportOffset = this.reportTakenBefore(game, found);
     }
     let handle;
     try {
@@ -41590,8 +41652,22 @@ class GodotServer {
       }
       const buffer = Buffer.alloc(size - from);
       const read = readSync2(handle, buffer, 0, buffer.length, from);
-      game.errorReportOffset = from + read;
-      const reported = buffer.subarray(0, read);
+      let reported = buffer.subarray(0, read);
+      if (game.consoleFromReport !== true) {
+        const boundary = consoleBoundaryAt(reported);
+        if (boundary !== -1) {
+          game.boundaryInReportSince ??= Date.now();
+          if (heard?.startsWith(CONSOLE_BOUNDARY) === true || game.pickedUpPlaying === true || this.dapClient?.isConnected() !== true || Date.now() - game.boundaryInReportSince >= BOUNDARY_WAIT_MS) {
+            game.consoleFromReport = true;
+          } else {
+            reported = reported.subarray(0, boundary);
+          }
+        }
+      }
+      game.errorReportOffset = from + reported.length;
+      if (reported.length === 0) {
+        return;
+      }
       if (game.transcript !== null) {
         appendFileSync(game.transcript, reported);
       } else {
@@ -41601,9 +41677,32 @@ class GodotServer {
       closeSync2(handle);
     }
   }
+  announcedPidNamedBy(run, line) {
+    const named = /runtime-(\d+)\.json$/.exec(line.trim())?.[1];
+    if (named === undefined) {
+      return;
+    }
+    const before = run.announcedBefore ?? new Set;
+    const theOne = this.announcedOfTheRunsProject(run, runtimesAnnounced().running).find((one) => one.pid === Number(named) && !before.has(one.pid) && this.isTheGameOf(run, one, run.projectPath));
+    if (theOne !== undefined) {
+      this.tie(run, theOne);
+    }
+    return run.announcedPid;
+  }
+  reportTakenBefore(game, report) {
+    if (game.pickedUpPlaying !== true || game.transcript === null) {
+      return 0;
+    }
+    try {
+      return reportAlreadyInTranscript(readFileSync19(game.transcript), readFileSync19(report));
+    } catch (error) {
+      this.logDebug(`Could not compare a picked-up run's report with its transcript: ${errorMessage(error)}`);
+      return 0;
+    }
+  }
   recordWhatItBrokeOn(game) {
     const halt = this.dapClient?.whereItStopped() ?? null;
-    if (halt?.reason !== "exception" || halt.text === "" || game.brokeOn === halt.text || game.errorReport !== undefined) {
+    if (halt?.reason !== "exception" || halt.text === "" || game.brokeOn === halt.text || typeof game.errorReport === "string") {
       return;
     }
     game.brokeOn = halt.text;
@@ -41815,6 +41914,7 @@ class GodotServer {
       pickedUpPlaying: true
     };
     this.activeProcess = picked;
+    this.watchThePlayedConsole();
   }
   announcedPidOf(run, announced) {
     if (run.announcedPid !== undefined) {
@@ -42233,7 +42333,7 @@ class GodotServer {
       }));
     }
     if (run.pickedUpPlaying === true) {
-      notes.push(run.transcript === null ? "The editor was already playing this when this server reached it, and the server that started it left no transcript, so this is not the run from its start: what it printed before that is only in the editor. It is the run the editor is holding now, which is the one the debug_* tools answer for." : "The editor was already playing this when this server reached it, and what it printed before that has been read back from its transcript. It is the run the editor is holding now, which is the one the debug_* tools answer for.");
+      notes.push(run.transcript !== null ? "The editor was already playing this when this server reached it, and what it printed before that has been read back from its transcript. It is the run the editor is holding now, which is the one the debug_* tools answer for." : run.consoleFromReport === true ? "The editor was already playing this when this server reached it, and the server that started it left no transcript, so what is below was read back from the file the game's runtime writes its console to, which begins where the runtime started: the engine's own start-up before that is only in the editor. It is the run the editor is holding now, which is the one the debug_* tools answer for." : "The editor was already playing this when this server reached it, and the server that started it left no transcript, so this is not the run from its start: what it printed before that is only in the editor. It is the run the editor is holding now, which is the one the debug_* tools answer for.");
     }
     if (run.consoleLost === true) {
       const back = this.dapClient?.isConnected() === true;
@@ -42961,7 +43061,7 @@ async function runGodotServer() {
   const server = new GodotServer;
   await server.run();
 }
-var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, run5, __dirname2, EDITOR_RESTART_TIMEOUT_MS = 90000, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, PLAY_STARTS_WITHIN_MS = 30000, STOP_WAIT_MS = 1e4, EXIT_REPORTED_WITHIN_MS = 2000, CONSOLE_WRAPPER, LONGEST_BOOT_NOTED_MS, MOST_GROUPS = 20, VALUE_NAMES, BRIDGE_RETRY_MS = 2000, SUCCESSOR_CHECK_MS = 1e4, HANDOVER_MS, HANDOVER_POLL_MS = 250, CACHE_WRITE_MS = 2000, SCAN_WAIT_MS = 30000, PLAYING_STATUS_MS = 1000, SCAN_START_MS = 2000, SCAN_SETTLED_MS = 500, REIMPORT_TIMEOUT_MS = 300000, AUDIO_BUS_OPS, STALLED_AFTER_MS = 30000, 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/";
+var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, run5, __dirname2, EDITOR_RESTART_TIMEOUT_MS = 90000, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, PLAY_STARTS_WITHIN_MS = 30000, STOP_WAIT_MS = 1e4, EXIT_REPORTED_WITHIN_MS = 2000, CONSOLE_WRAPPER, LONGEST_BOOT_NOTED_MS, MOST_GROUPS = 20, 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, SCAN_WAIT_MS = 30000, PLAYING_STATUS_MS = 1000, SCAN_START_MS = 2000, SCAN_SETTLED_MS = 500, REIMPORT_TIMEOUT_MS = 300000, AUDIO_BUS_OPS, STALLED_AFTER_MS = 30000, 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/";
 var init_server3 = __esm(() => {
   init_mcp();
   init_stdio2();

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

@@ -1,7 +1,7 @@
 extends Logger
 
-## Every error the engine reports inside this game, written to a file beside the announcement,
-## in the lines the engine itself prints to stderr.
+## The console of a game the editor plays, errors and prints in the order the engine made them,
+## written to a file beside the announcement in the lines the engine itself prints.
 ##
 ## A game the editor plays prints to the editor's own stderr, which nobody reads: a `push_error`
 ## raised in one reached neither `editor_output` nor the run's transcript, and the run was
@@ -9,14 +9,49 @@ extends Logger
 ## what the game prints and not what it reports, so the report is taken where it is made, in
 ## the game, and left where the server already looks. The lines are the engine's own so the
 ## server reads them the way it reads a run it started itself.
+##
+## Prints as well, once [method take_the_console] is called: the adapter's prints and this file's
+## errors are two streams, and read side by side a warning raised before a print was put after
+## it. One file written from inside the game has one order, the engine's.
 
 var _path: String
+var _file: FileAccess = null
+var _console: bool = false
+## Held across a write, because the engine logs from whichever thread printed.
+var _mutex: Mutex = Mutex.new()
+## Set while writing, so a failure the write itself logs does not come straight back in here.
+var _writing: bool = false
 
 
 func _init(path: String) -> void:
 	_path = path
 
 
+## Writes every print from here on as well as the errors, and prints [param boundary], which is
+## therefore the first print in the file and the last one the server takes from the adapter.
+func take_the_console(boundary: String) -> void:
+	_mutex.lock()
+	_console = true
+	_mutex.unlock()
+	print(boundary)
+
+
+## Lets go of the file, once the Logger has been removed and nothing more will be written.
+func close() -> void:
+	_mutex.lock()
+	if _file != null:
+		_file.close()
+		_file = null
+	_mutex.unlock()
+
+
+func _log_message(message: String, _error: bool) -> void:
+	_mutex.lock()
+	if _console:
+		_write(message if message.ends_with("\n") else message + "\n")
+	_mutex.unlock()
+
+
 # The engine's own signature for a Logger, eight parameters and not this project's to shape.
 # gdlint:ignore = function-arguments-number
 func _log_error(
@@ -45,18 +80,29 @@ func _log_error(
 	]
 	for backtrace: ScriptBacktrace in script_backtraces:
 		lines.append(backtrace.format(3))
-	# Opened for each report rather than held, so the file is whole on disk after every one:
-	# the last error a game reports is the one a caller most needs, and the game may be gone the
-	# moment after. Nothing here may report an error of its own, which would come straight back.
-	var report: FileAccess = (
-		FileAccess.open(_path, FileAccess.READ_WRITE)
-		if FileAccess.file_exists(_path)
-		else FileAccess.open(_path, FileAccess.WRITE)
-	)
-	if report == null:
+	_mutex.lock()
+	_write("\n".join(lines) + "\n")
+	_mutex.unlock()
+
+
+## Appends [param text] and flushes it, so the file is whole on disk after every entry: the last
+## thing a game reports is the one a caller most needs, and the game may be gone the moment after.
+## Held open rather than opened for each entry, because a game printing every frame would open the
+## file sixty times a second. Called with the mutex held.
+func _write(text: String) -> void:
+	if _writing:
 		return
-	report.seek_end()
-	for each: String in lines:
+	_writing = true
+	if _file == null:
+		_file = (
+			FileAccess.open(_path, FileAccess.READ_WRITE)
+			if FileAccess.file_exists(_path)
+			else FileAccess.open(_path, FileAccess.WRITE)
+		)
+		if _file != null:
+			_file.seek_end()
+	if _file != null:
 		# A line the disk would not take is a report lost, and nothing here may report that.
-		var _stored: bool = report.store_line(each)
-	report.close()
+		var _stored: bool = _file.store_string(text)
+		_file.flush()
+	_writing = false

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

@@ -114,11 +114,13 @@ func _ready() -> void:
 func _exit_tree() -> void:
 	if _errors != null:
 		OS.remove_logger(_errors)
+		_errors.close()
 		_errors = null
 	_cleanup()
 
 
-## The engine's error reports, written to a file for the server, for a game the editor plays.
+## The engine's error reports, written to a file for the server, for a game the editor plays, and
+## its prints as well from the line announcing the runtime on.
 ##
 ## Only for one the editor plays: a game the server starts itself has its stderr in the run's
 ## transcript already, and a game somebody runs from a terminal has it on the terminal. The
@@ -235,7 +237,16 @@ func _start_server() -> void:
 
 	_port = _server.get_local_port()
 	_announce(bind_address)
-	print("[gdharness] runtime listening on %s:%d, announced at %s" % [bind_address, _port, _announcement])
+	var listening: String = (
+		"[gdharness] runtime listening on %s:%d, announced at %s" % [bind_address, _port, _announcement]
+	)
+	# The line the server tells the two streams apart by: it takes the prints before it from the
+	# debug adapter and everything from it on from the file, which has it first. After the
+	# announcement, so a server reading the line finds the file beside it.
+	if _errors != null:
+		_errors.take_the_console(listening)
+	else:
+		print(listening)
 
 
 ## Whether the engine was told to run a script rather than the game.

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

@@ -18,15 +18,27 @@ const LISTED_CANDIDATES: int = 10
 ## Matched the way a find matches `says`, against a control's own words, and only among controls
 ## the player can see. A match inside a button presses the button, because the label is what says
 ## the words and the button is what takes the click: aimed at the label, the pointer lands on the
-## button and the answer would call the click a miss. Several matches are refused rather than
-## guessed, each named with the [param which] that picks it, counting from 0.
+## button and the answer would call the click a miss.
+##
+## The matches are ranked the way a person reads a screen for the thing to press: a button before
+## text that cannot be pressed, and a control whose words are exactly these before one saying them
+## as part of a sentence. A plain word is matched anywhere in a text, so on a screen full of prose
+## "Back" was said by ten labels as well as the one button reading "Back", and the refusal listing
+## eleven sent the caller to an index that moved every time the prose did. Several matches at the
+## best rank are refused rather than guessed, each named with the [param which] that picks it,
+## counting from 0 in rank order.
+##
+## A control with something drawn over its centre that a pointer there would reach instead is not
+## on screen for a player, and a click at it lands on the thing on top. The screen a game shows
+## over its hall covers the hall's drawers without hiding them, so their words matched as well.
 static func control_saying(root: Node, root_path: String, wanted: String, which: Variant) -> Dictionary:
 	var reached: Dictionary = Values.node_at(root, root_path)
 	if reached.has("message"):
 		return reached
-	var targets: Array[Control] = []
+	var matched: Array[Control] = []
 	# The words of the control that matched, which a button pressed on a label's behalf has none of.
 	var said: Array[String] = []
+	var exact: Array[bool] = []
 	var hidden: int = 0
 	var pending: Array[Node] = [reached["node"]]
 	while not pending.is_empty():
@@ -35,32 +47,68 @@ static func control_saying(root: Node, root_path: String, wanted: String, which:
 			if not Queries.shown(node):
 				hidden += 1
 			else:
-				var matched: Control = node
-				var target: Control = _pressed_through(matched)
-				if not targets.has(target):
-					targets.append(target)
-					said.append(Words.said_by(node))
+				var control: Control = node
+				var target: Control = _pressed_through(control)
+				var words: String = Words.said_by(node)
+				var whole: bool = _says_exactly(words, wanted)
+				var at: int = matched.find(target)
+				if at == -1:
+					matched.append(target)
+					said.append(words)
+					exact.append(whole)
+				elif whole and not exact[at]:
+					said[at] = words
+					exact[at] = true
 		var children: Array[Node] = node.get_children(true)
 		for index: int in range(children.size() - 1, -1, -1):
 			pending.push_front(children[index])
 
+	var drawn: Array[Node] = _pointer_takers(root)
+	var covered: int = 0
+	var cover: Node = null
+	var open: Array[int] = []
+	for index: int in matched.size():
+		var over: Node = _cover_of(matched[index], drawn)
+		if over == null:
+			open.append(index)
+		else:
+			covered += 1
+			if cover == null:
+				cover = over
+	# Stable, so matches of one rank keep the order they are drawn in.
+	open.sort_custom(
+		func(a: int, b: int) -> bool:
+			var first: int = _rank(matched[a], exact[a])
+			var second: int = _rank(matched[b], exact[b])
+			return first > second or (first == second and a < b)
+	)
+	var targets: Array[Control] = []
+	var ranks: Array[int] = []
+	var lines: Array[String] = []
+	for index: int in open:
+		targets.append(matched[index])
+		ranks.append(_rank(matched[index], exact[index]))
+		lines.append(said[index])
+
 	var under: String = "" if root_path == "/root" else " under %s" % root_path
 	if targets.is_empty():
 		return {
 			"type": "error",
 			"message":
 			(
-				'no control on screen%s says "%s", so nothing was clicked%s'
-				% [under, wanted, _hidden_note(hidden)]
+				'no control on screen%s says "%s", so nothing was clicked%s%s'
+				% [under, wanted, _hidden_note(hidden), _covered_note(covered, cover)]
 			)
 		}
-	if which == null and targets.size() > 1:
+	var best: int = ranks.count(ranks[0])
+	if which == null and best > 1:
+		var order: String = "" if best == targets.size() else ", best matches first"
 		return {
 			"type": "error",
 			"message":
 			(
-				'%d controls on screen%s say "%s", so which to click is not clear; pass index, counting from 0: %s'
-				% [targets.size(), under, wanted, _candidates(targets, said)]
+				"%s, so which to click is not clear; pass index, counting from 0%s: %s"
+				% [_described(best, ranks[0], wanted, under), order, _candidates(targets, lines)]
 			)
 		}
 	var index: int = 0 if which == null else Read.as_int(which, -1)
@@ -71,13 +119,58 @@ static func control_saying(root: Node, root_path: String, wanted: String, which:
 			"message":
 			(
 				'index %s is not one of the %d control%s on screen%s saying "%s": %s'
-				% [str(which), targets.size(), plural, under, wanted, _candidates(targets, said)]
+				% [str(which), targets.size(), plural, under, wanted, _candidates(targets, lines)]
 			)
 		}
-	return {
-		"path": str(targets[index].get_path()),
-		"found": {"says": wanted, "index": index, "of": targets.size()},
-	}
+	var found: Dictionary = {"says": wanted, "index": index, "of": targets.size()}
+	if which == null and targets.size() > 1:
+		var others: String = (
+			"the other one on screen %s" % _passed_over(ranks[0], true)
+			if targets.size() == 2
+			else "the other %d on screen %s" % [targets.size() - 1, _passed_over(ranks[0], false)]
+		)
+		found["picked"] = "%s; %s" % [_described(1, ranks[0], wanted, under), others]
+	if covered > 0:
+		found["covered"] = covered
+	return {"path": str(targets[index].get_path()), "found": found}
+
+
+## How good a match [param target] is for a click: a button over what cannot be pressed, and then
+## the whole of its words over a part of them.
+static func _rank(target: Control, whole: bool) -> int:
+	return (2 if target is BaseButton else 0) + (1 if whole else 0)
+
+
+## Whether [param said] is the whole of what [param wanted] asks for. A glob is matched against the
+## whole text already, so every match of one is whole.
+static func _says_exactly(said: String, wanted: String) -> bool:
+	var words: String = Queries.as_said(wanted)
+	if words.contains("*") or words.contains("?"):
+		return true
+	return said.strip_edges().nocasecmp_to(words.strip_edges()) == 0
+
+
+## [param count] matches of [param rank], as the start of a sentence.
+static func _described(count: int, rank: int, wanted: String, under: String) -> String:
+	var what: String = "button" if rank >= 2 else "control"
+	var how: String = '"%s"' % wanted
+	if not Queries.as_said(wanted).contains("*") and not Queries.as_said(wanted).contains("?"):
+		how = ('exactly "%s"' if rank % 2 == 1 else '"%s" as part of more') % wanted
+	if count == 1:
+		return "the one %s on screen%s saying %s" % [what, under, how]
+	return "%d %ss on screen%s say %s" % [count, what, under, how]
+
+
+## Why the matches below [param rank] were passed over, said of one of them when [param one].
+static func _passed_over(rank: int, one: bool) -> String:
+	var says: String = "says" if one else "say"
+	match rank:
+		3:
+			return "cannot be pressed or %s it as part of more" % says
+		2:
+			return "cannot be pressed"
+		_:
+			return "%s it as part of more" % says
 
 
 ## What to add to a refusal that found nothing on screen, when words matched controls out of sight.
@@ -87,6 +180,15 @@ static func _hidden_note(hidden: int) -> String:
 	return "; %d hidden control%s" % [hidden, " says it" if hidden == 1 else "s say it"]
 
 
+## What to add to a refusal that found nothing on screen, when the controls saying it are covered.
+static func _covered_note(covered: int, cover: Node) -> String:
+	if covered == 0:
+		return ""
+	if covered == 1:
+		return "; 1 control says it under %s, which is drawn over it" % cover.get_path()
+	return "; %d controls say it under what is drawn over them, such as %s" % [covered, cover.get_path()]
+
+
 ## [param control], or the button holding it when it is not one itself, which is what a click on
 ## its words means.
 static func _pressed_through(control: Control) -> Control:
@@ -99,6 +201,94 @@ static func _pressed_through(control: Control) -> Control:
 	return control
 
 
+## Everything in the tree [param root] heads that a pointer can land on: each control on screen
+## that does not let the pointer through, and each window embedded in another.
+static func _pointer_takers(root: Node) -> Array[Node]:
+	var found: Array[Node] = []
+	var pending: Array[Node] = [root]
+	while not pending.is_empty():
+		var node: Node = pending.pop_back()
+		var control: Control = node as Control
+		var window: Window = node as Window
+		if control != null:
+			if not control.is_visible_in_tree():
+				continue
+			if control.get_mouse_filter_with_override() != Control.MOUSE_FILTER_IGNORE:
+				found.append(control)
+		elif window != null and window != root:
+			if not window.visible:
+				continue
+			if window.is_embedded():
+				found.append(window)
+		pending.append_array(node.get_children(true))
+	return found
+
+
+## What a pointer at [param target]'s centre reaches instead of it, or null when nothing does.
+##
+## The engine's own order for which control takes the pointer: an embedded window over everything
+## in the viewport that holds it, then the higher canvas layer, then the later in the tree. A
+## control holding the target or held by it is part of the same click. A target whose centre its
+## own container clips away is judged not covered, since the click scrolls it into view first and
+## what is drawn there now is not what it will land on.
+static func _cover_of(target: Control, drawn: Array[Node]) -> Node:
+	var viewport: Viewport = target.get_viewport()
+	var point: Vector2 = target.get_global_transform_with_canvas() * (target.size * 0.5)
+	if _clipped_away(target, point):
+		return null
+	var layer: int = _layer_of(target)
+	for other: Node in drawn:
+		var window: Window = other as Window
+		if window != null:
+			if (
+				window.get_parent() != null
+				and window.get_parent().get_viewport() == viewport
+				and not window.is_ancestor_of(target)
+				and Rect2(window.position, window.size).has_point(point)
+			):
+				return window
+			continue
+		var control: Control = other
+		if control == target or control.is_ancestor_of(target) or target.is_ancestor_of(control):
+			continue
+		if control.get_viewport() != viewport:
+			continue
+		var its_layer: int = _layer_of(control)
+		if its_layer < layer or (its_layer == layer and not control.is_greater_than(target)):
+			continue
+		if _holds(control, point) and not _clipped_away(control, point):
+			return control
+	return null
+
+
+## Whether [param control] holds [param point], given in its viewport's coordinates.
+static func _holds(control: Control, point: Vector2) -> bool:
+	var placed: Transform2D = control.get_global_transform_with_canvas()
+	# A control scaled to nothing holds no point, and inverting its transform is an engine error.
+	if is_zero_approx(placed.determinant()):
+		return false
+	# The rectangle, which is the engine's own answer unless a script overrides `_has_point`; the
+	# engine does not offer the overridden answer to scripts.
+	return Rect2(Vector2.ZERO, control.size).has_point(placed.affine_inverse() * point)
+
+
+## Whether a container clipping what it holds cuts [param point] off from [param control].
+static func _clipped_away(control: Control, point: Vector2) -> bool:
+	var walk: Node = control.get_parent()
+	while walk != null:
+		var holder: Control = walk as Control
+		if holder != null and holder.clip_contents and not _holds(holder, point):
+			return true
+		walk = walk.get_parent()
+	return false
+
+
+## The canvas layer [param control] is drawn on, 0 for the viewport's own canvas.
+static func _layer_of(control: Control) -> int:
+	var layer: CanvasLayer = control.get_canvas_layer_node()
+	return 0 if layer == null else layer.layer
+
+
 ## The controls a click by words could mean, each with its index, its path and the words that
 ## matched, [param said] holding those in the same order.
 static func _candidates(targets: Array[Control], said: Array[String]) -> String:

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

@@ -7,7 +7,6 @@ const Paths = preload("runtime_paths.gd")
 const Queries = preload("runtime_queries.gd")
 const Read = preload("reading.gd")
 const Values = preload("runtime_values.gd")
-const Words = preload("runtime_words.gd")
 
 ## The longest one wait may last, whatever the request says: past this the server has long
 ## since given up on the reply.
@@ -284,7 +283,9 @@ func _wait_until_said(node_path: String, said: String, timeout_ms: int, include_
 
 
 ## Whether anything under [param node_path] says [param said], the node itself included, and shown
-## unless hidden ones are wanted too.
+## unless hidden ones are wanted too. Matched as a find and a click match `says`, a glob over the
+## whole text when it has `*` or `?`: read as literal words, a glob a click had just pressed by was
+## waited on for the whole timeout with its label on screen, and answered as words never arriving.
 func _anything_says(node_path: String, said: String, include_hidden: bool) -> bool:
 	var root: Node = _host.get_tree().root.get_node_or_null(node_path)
 	if root == null:
@@ -292,7 +293,7 @@ func _anything_says(node_path: String, said: String, include_hidden: bool) -> bo
 	var pending: Array[Node] = [root]
 	while not pending.is_empty():
 		var node: Node = pending.pop_back()
-		if Words.said_by(node).containsn(said) and (include_hidden or Queries.shown(node)):
+		if Queries.says(node, said) and (include_hidden or Queries.shown(node)):
 			return true
 		pending.append_array(node.get_children(true))
 	return false

package/build/index.js

@@ -25210,6 +25210,29 @@ function errorReportOf(pid, directories = runtimeDirectories()) {
   }
   return null;
 }
+var CONSOLE_BOUNDARY = "[gdharness] runtime listening on ";
+function consoleBoundaryAt(bytes) {
+  const wanted = Buffer.from(CONSOLE_BOUNDARY);
+  for (let at = bytes.indexOf(wanted);at !== -1; at = bytes.indexOf(wanted, at + 1)) {
+    if (at === 0 || bytes[at - 1] === 10) {
+      return at;
+    }
+  }
+  return -1;
+}
+function reportAlreadyInTranscript(transcript, report) {
+  const boundary = consoleBoundaryAt(report);
+  if (boundary === -1) {
+    return 0;
+  }
+  const inTranscript = consoleBoundaryAt(transcript);
+  if (inTranscript === -1) {
+    return boundary;
+  }
+  const copied = transcript.subarray(inTranscript);
+  const end = boundary + copied.length;
+  return end <= report.length && report.subarray(boundary, end).equals(copied) ? end : report.length;
+}
 var ERROR_REPORT_KEEP_MS = 60 * 60 * 1000;
 function processAlive(pid) {
   try {
@@ -30849,7 +30872,7 @@ var TOOL_SPECS = [
       says: {
         type: "string",
         ops: ["click"],
-        description: "click: the words on the control to click, matched the way runtime_inspect find matches says (a plain word is contained in the text, a pattern with * or ? is a glob over it), among the controls on screen, and pressed in the same frame it was found in, so a panel rebuilding between a find and a click cannot free it first. Words on a label inside a button press the button. Several matches are refused with each one listed, and index picks one."
+        description: "click: the words on the control to click, matched the way runtime_inspect find matches says (a plain word is contained in the text, a pattern with * or ? is a glob over it), among the controls on screen, and pressed in the same frame it was found in, so a panel rebuilding between a find and a click cannot free it first. Words on a label inside a button press the button. A control with something drawn over its centre that would take the pointer, such as a screen shown over it, is not on screen. The matches are ranked the way a person picks what to press: a button before text that cannot be pressed, then a control whose whole text is the words before one saying them as part of more, and the best one is pressed; found.picked says why. Several matches at the best rank are refused with each one listed, and index picks one."
       },
       action: {
         type: "string",
@@ -30887,7 +30910,7 @@ var TOOL_SPECS = [
       index: {
         type: "number",
         ops: ["click", "choose"],
-        description: "click: which of several controls saying the words, counting from 0 in the order a refusal lists them. choose: the item to take, by where it is in the list, when text will not do."
+        description: "click: which of several controls saying the words, counting from 0 in the order a refusal lists them, best matches first. choose: the item to take, by where it is in the list, when text will not do."
       },
       shift: { type: "boolean", ops: ["key"], description: "key: hold Shift with it. Default false." },
       ctrl: { type: "boolean", ops: ["key"], description: "key: hold Ctrl with it. Default false." },
@@ -30980,7 +31003,7 @@ var TOOL_SPECS = [
       says: {
         type: "string",
         ops: ["until"],
-        description: "until: wait for these words to appear anywhere under nodePath, or anywhere in the game when no nodePath is given, instead of for a property, which is how a panel that rebuilds its labels is waited on at all: the labels are named afresh each redraw and the panel is what stays put. Case-insensitive, part of a line, on a node the player can see unless includeHidden says otherwise; a label with a line break is matched with the break in the words, and a backslash followed by n counts as one. Instead of, not as well as: a call carrying this and a property is refused, because they ask about different things and answering one of them silently is how a caller watches a screen believing they are watching a property. It looks every frame while a look is cheap and less often on a screen large enough for a look to cost a real share of a frame, so the game keeps its speed; the answer counts the frames the wait spanned and the looks it took."
+        description: "until: wait for these words to appear anywhere under nodePath, or anywhere in the game when no nodePath is given, instead of for a property, which is how a panel that rebuilds its labels is waited on at all: the labels are named afresh each redraw and the panel is what stays put. Matched the way runtime_inspect find matches says: case-insensitive, a plain word anywhere in the text, a pattern with * or ? a glob over the whole of it; on a node the player can see unless includeHidden says otherwise; a label with a line break is matched with the break in the words, and a backslash followed by n counts as one. Instead of, not as well as: a call carrying this and a property is refused, because they ask about different things and answering one of them silently is how a caller watches a screen believing they are watching a property. It looks every frame while a look is cheap and less often on a screen large enough for a look to cost a real share of a frame, so the game keeps its speed; the answer counts the frames the wait spanned and the looks it took."
       },
       includeHidden: {
         type: "boolean",
@@ -31469,6 +31492,8 @@ function outsideTheirRanges(spec, args) {
 }
 var BRIDGE_RETRY_MS = 2000;
 var SUCCESSOR_CHECK_MS = 1e4;
+var CONSOLE_WATCH_MS = 250;
+var BOUNDARY_WAIT_MS = 2000;
 var HANDOVER_MS = SUCCESSOR_CHECK_MS + 5000;
 var HANDOVER_POLL_MS = 250;
 var CACHE_WRITE_MS = 2000;
@@ -31687,6 +31712,7 @@ class GodotServer {
   bridgeStartupError = null;
   bridgeRetry = null;
   successorWatch = null;
+  consoleWatch = null;
   lastProjectPath = null;
   shutdownInitiated = false;
   launchedEditor = null;
@@ -31859,10 +31885,30 @@ class GodotServer {
       this.successorWatch = null;
     }
   }
+  watchThePlayedConsole() {
+    if (this.consoleWatch !== null) {
+      return;
+    }
+    const watch = setInterval(() => {
+      const run = this.activeProcess;
+      if (run?.throughEditor !== true || run.transcript === null) {
+        clearInterval(watch);
+        this.consoleWatch = null;
+        return;
+      }
+      this.drainErrorReport(run);
+    }, CONSOLE_WATCH_MS);
+    watch.unref();
+    this.consoleWatch = watch;
+  }
   async cleanup() {
     this.logDebug("Cleaning up resources");
     this.stopTryingTheBridge();
     this.stopWatchingForASuccessor();
+    if (this.consoleWatch !== null) {
+      clearInterval(this.consoleWatch);
+      this.consoleWatch = null;
+    }
     withdrawBridge(this.announcedAt);
     this.announcedAt = null;
     this.activeProcess = null;
@@ -33430,7 +33476,16 @@ class GodotServer {
   }
   writeToTranscript(line) {
     const run = this.activeProcess;
-    if (run?.throughEditor !== true || run.transcript === null) {
+    if (run?.throughEditor !== true) {
+      return;
+    }
+    if (run.consoleFromReport === true || line.startsWith(CONSOLE_BOUNDARY)) {
+      this.drainErrorReport(run, line);
+      if (run.consoleFromReport === true) {
+        return;
+      }
+    }
+    if (run.transcript === null) {
       return;
     }
     try {
@@ -33983,6 +34038,7 @@ class GodotServer {
       seenPlaying: readBoolean(playAnswer, "playing") === true
     };
     this.activeProcess = played;
+    this.watchThePlayedConsole();
     writeEditorRunNote({ projectPath, transcript: transcript.path, startedAt });
     sweepTranscripts();
     return this.jsonTextResponse({
@@ -34000,7 +34056,7 @@ class GodotServer {
         reason: one.reason
       })),
       runtime: await this.runtimeUp(projectPath, alreadyPlaying, runtimeWaitMs, false),
-      message: "The editor is playing it, so its debugger holds it: the debug_* tools can reach it, " + "editor_output reads its console through the debug adapter, and editor_run stop ends it." + endedToStartThis(ended)
+      message: "The editor is playing it, so its debugger holds it: the debug_* tools can reach it, " + "editor_output reads its console through the debug adapter and the runtime's report of it, and editor_run stop ends it." + endedToStartThis(ended)
     });
   }
   drainEditorOutput(game) {
@@ -34012,26 +34068,35 @@ class GodotServer {
       return;
     }
     if (game.transcript === null) {
-      for (const line of this.dapClient.getOutput(true)) {
-        game.log.append("stdout", line.endsWith(`
+      const heard = this.dapClient.getOutput(true);
+      if (game.consoleFromReport !== true) {
+        for (const line of heard) {
+          game.log.append("stdout", line.endsWith(`
 `) ? line : `${line}
 `);
+        }
       }
     }
-    if (!this.dapClient.isConnected()) {
+    if (!this.dapClient.isConnected() && game.consoleFromReport !== true) {
       game.consoleLost = true;
     }
     this.recordWhatItBrokeOn(game);
   }
-  drainErrorReport(game) {
+  drainErrorReport(game, heard) {
+    if (game.errorReport === null) {
+      return;
+    }
     if (game.errorReport === undefined) {
-      const its = this.announcedPidOf(game);
+      const its = this.announcedPidOf(game) ?? (heard?.startsWith(CONSOLE_BOUNDARY) === true ? this.announcedPidNamedBy(game, heard) : undefined);
       const found = its === undefined ? null : errorReportOf(its);
       if (found === null) {
+        if (heard?.startsWith(CONSOLE_BOUNDARY) === true) {
+          game.errorReport = null;
+        }
         return;
       }
       game.errorReport = found;
-      game.errorReportOffset = 0;
+      game.errorReportOffset = this.reportTakenBefore(game, found);
     }
     let handle;
     try {
@@ -34047,8 +34112,22 @@ class GodotServer {
       }
       const buffer = Buffer.alloc(size - from);
       const read = readSync2(handle, buffer, 0, buffer.length, from);
-      game.errorReportOffset = from + read;
-      const reported = buffer.subarray(0, read);
+      let reported = buffer.subarray(0, read);
+      if (game.consoleFromReport !== true) {
+        const boundary = consoleBoundaryAt(reported);
+        if (boundary !== -1) {
+          game.boundaryInReportSince ??= Date.now();
+          if (heard?.startsWith(CONSOLE_BOUNDARY) === true || game.pickedUpPlaying === true || this.dapClient?.isConnected() !== true || Date.now() - game.boundaryInReportSince >= BOUNDARY_WAIT_MS) {
+            game.consoleFromReport = true;
+          } else {
+            reported = reported.subarray(0, boundary);
+          }
+        }
+      }
+      game.errorReportOffset = from + reported.length;
+      if (reported.length === 0) {
+        return;
+      }
       if (game.transcript !== null) {
         appendFileSync(game.transcript, reported);
       } else {
@@ -34058,9 +34137,32 @@ class GodotServer {
       closeSync2(handle);
     }
   }
+  announcedPidNamedBy(run, line) {
+    const named = /runtime-(\d+)\.json$/.exec(line.trim())?.[1];
+    if (named === undefined) {
+      return;
+    }
+    const before = run.announcedBefore ?? new Set;
+    const theOne = this.announcedOfTheRunsProject(run, runtimesAnnounced().running).find((one) => one.pid === Number(named) && !before.has(one.pid) && this.isTheGameOf(run, one, run.projectPath));
+    if (theOne !== undefined) {
+      this.tie(run, theOne);
+    }
+    return run.announcedPid;
+  }
+  reportTakenBefore(game, report) {
+    if (game.pickedUpPlaying !== true || game.transcript === null) {
+      return 0;
+    }
+    try {
+      return reportAlreadyInTranscript(readFileSync17(game.transcript), readFileSync17(report));
+    } catch (error) {
+      this.logDebug(`Could not compare a picked-up run's report with its transcript: ${errorMessage(error)}`);
+      return 0;
+    }
+  }
   recordWhatItBrokeOn(game) {
     const halt = this.dapClient?.whereItStopped() ?? null;
-    if (halt?.reason !== "exception" || halt.text === "" || game.brokeOn === halt.text || game.errorReport !== undefined) {
+    if (halt?.reason !== "exception" || halt.text === "" || game.brokeOn === halt.text || typeof game.errorReport === "string") {
       return;
     }
     game.brokeOn = halt.text;
@@ -34272,6 +34374,7 @@ class GodotServer {
       pickedUpPlaying: true
     };
     this.activeProcess = picked;
+    this.watchThePlayedConsole();
   }
   announcedPidOf(run, announced) {
     if (run.announcedPid !== undefined) {
@@ -34690,7 +34793,7 @@ class GodotServer {
       }));
     }
     if (run.pickedUpPlaying === true) {
-      notes.push(run.transcript === null ? "The editor was already playing this when this server reached it, and the server that started it left no transcript, so this is not the run from its start: what it printed before that is only in the editor. It is the run the editor is holding now, which is the one the debug_* tools answer for." : "The editor was already playing this when this server reached it, and what it printed before that has been read back from its transcript. It is the run the editor is holding now, which is the one the debug_* tools answer for.");
+      notes.push(run.transcript !== null ? "The editor was already playing this when this server reached it, and what it printed before that has been read back from its transcript. It is the run the editor is holding now, which is the one the debug_* tools answer for." : run.consoleFromReport === true ? "The editor was already playing this when this server reached it, and the server that started it left no transcript, so what is below was read back from the file the game's runtime writes its console to, which begins where the runtime started: the engine's own start-up before that is only in the editor. It is the run the editor is holding now, which is the one the debug_* tools answer for." : "The editor was already playing this when this server reached it, and the server that started it left no transcript, so this is not the run from its start: what it printed before that is only in the editor. It is the run the editor is holding now, which is the one the debug_* tools answer for.");
     }
     if (run.consoleLost === true) {
       const back = this.dapClient?.isConnected() === true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdharness",
-  "version": "1.1.11",
+  "version": "1.1.12",
   "mcpName": "io.github.Aureliolo/gdharness",
   "description": "A harness for driving a Godot 4 project from an agent: editor addons, a runtime bridge into the running game, an MCP server in front of them, and a CLI that installs and diagnoses the Godot side.",
   "type": "module",