gdharness 1.1.11 → 1.1.13

package/build/cli.js

@@ -17091,7 +17091,7 @@ var init_tool_definitions = __esm(() => {
           requires: []
         },
         rect: {
-          summary: "one node's rectangle or position, in canvas and in window pixels. A 3D node answers with the point to aim at, which is the middle of what it draws rather than the origin it stands on, the rectangle it covers under covers, the camera that drew it, and behind_camera when it is not in front of one",
+          summary: "one node's rectangle or position, in canvas and in window pixels. Canvas is the node's own viewport; window is where it is drawn in the game's window, through any embedded dialog or SubViewport it sits in, which is what runtime_input mouse_click and mouse_motion take. A 3D node answers with the point to aim at, which is the middle of what it draws rather than the origin it stands on, the rectangle it covers under covers, the camera that drew it, and behind_camera when it is not in front of one",
           requires: ["nodePath"]
         },
         property: {
@@ -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." },
@@ -17290,7 +17290,7 @@ var init_tool_definitions = __esm(() => {
           requires: []
         },
         choose: {
-          summary: "take an item out of a menu, by what it says or by where it is in the list. A menu's items are drawn rather than built, so there is nothing to click: the item takes the focus and Enter presses it, which is the engine's own path and needs no window. Answers with what was chosen and what the button in front of it shows now",
+          summary: "take an item out of a menu, by what it says or by where it is in the list. A menu's items are drawn rather than built, so there is nothing to click: the item takes the focus and Enter presses it, which is the engine's own path and needs no window. Answers with what was chosen, read before the press, 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 it shows now when it is still there",
           requires: ["nodePath"]
         },
         action: { summary: "press an action, or hold it", requires: ["action"] },
@@ -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.