gdharness 1.1.11 → 1.1.13

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,69 @@ 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 areas: Array[Rect2] = _areas_of(drawn)
+	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, areas)
+		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 +120,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 +181,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 +202,117 @@ 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
+
+
+## The box each of [param drawn] takes up in its viewport: a window's rectangle, and the box around
+## a control's however it is turned or scaled.
+##
+## Worked out once for a click rather than once for each match. A plain word on a screen of prose
+## matches a hundred labels, and asking all four thousand controls of a hall for their transform
+## for each of them took a click by words 80 ms, where the matching alone takes half that.
+static func _areas_of(drawn: Array[Node]) -> Array[Rect2]:
+	var areas: Array[Rect2] = []
+	for each: Node in drawn:
+		var window: Window = each as Window
+		if window != null:
+			areas.append(Rect2(window.position, window.size))
+		else:
+			var control: Control = each
+			areas.append(control.get_global_transform_with_canvas() * Rect2(Vector2.ZERO, control.size))
+	return areas
+
+
+## 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.
+##
+## [param areas] holds the box around each of [param drawn], so everything whose box misses the
+## point is passed over before anything costlier is asked of it.
+static func _cover_of(target: Control, drawn: Array[Node], areas: Array[Rect2]) -> 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 at: int in drawn.size():
+		if not areas[at].has_point(point):
+			continue
+		var other: Node = drawn[at]
+		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)
+			):
+				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 {
@@ -30731,7 +30754,7 @@ var TOOL_SPECS = [
         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: {
@@ -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." },
@@ -30930,7 +30953,7 @@ var TOOL_SPECS = [
         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"] },
@@ -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.13",
   "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",