gdharness 1.2.1 → 1.2.3

package/build/cli.js

@@ -17977,7 +17977,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "project_test",
-      description: "Runs the project's gdUnit4 tests headless and answers with every case that did not pass: where it is, and what the assertion said. Suites where everything passed are counted rather than listed, and an engine message keeps the frames above gdUnit4 rather than the twenty inside it, so a clean tier answers in a few lines; identical engine messages come back once under engineEntries, with times saying how often they were printed, and engineErrors counts every one. The class list is rebuilt first, so a suite written a moment ago is found, and the rebuild's answer is under classes, with the classes each addon declares counted under addedInAddons and changedInAddons rather than named: a class it puts back that the cache had after the last rebuild is named under classes.lostSinceLastRebuild, which is the editor writing its shorter list over the file on every save until restarted. On Windows and Linux the run gets a user:// of its own, so a suite that saves a game writes nowhere near the saves of the copy somebody plays. On macOS the engine reads user:// off HOME and the run writes where the player keeps theirs, which the answer says under savesNote rather than leaving to be found in a save list. A run that found nothing to run is never called a pass: gdUnit4 exits cleanly for one, so the answer says so and names the path it looked in. A script that does not load stops gdUnit4 before any suite runs: its errors come back in full under scriptErrors, and the scripts that failed only because one they depend on did are listed by path under failedThroughDependency. When they failed on a class whose own script has a parser error, which gdUnit4 never names, that script is checked by the engine and its error comes first under scriptErrors, with the class it declares under declares, and the errors a script has only because that class did not resolve, which the engine reads as Variant, are kept apart under followFromUnresolved. A client that sends a progress token is told as each suite finishes, and at least every twenty seconds through a long one, so an idle limit does not end a long tier. A run that ends without a report, at its timeout or otherwise, names the suites it finished under suitesFinished, the failing ones with their failed cases under suitesFailing, and the one it was in under suiteRunning. When a client cuts a run off, that is kept in the project and the next project_test there carries it under previousRunCut. A run where nothing failed but nodes were left in the tree comes back under warnings, with the count per suite: gdUnit4 decides its verdict on those and keeps them out of its report, so they are read off what it printed. A run whose every case passed is still not called passed when it printed a script error that no case failed on: gdUnit4 fails a case on the script errors its logger sees, and it cannot see a stack overflow, so the cases pass on whatever the faulted calls returned. Those errors come back under uncaughtScriptErrors, and under engineEntries by index with detailUnder rather than with their backtrace a second time; a backtrace that repeats, as a recursion's does, has each repeated frame or cycle of frames written once with the frames it covers and how many times. One raised inside assert_error(...).is_runtime_error is the test's own and does not count, and none count when the project turns off gdUnit4's report/godot/script_error setting. Needs gdUnit4 under addons/gdUnit4.",
+      description: "Runs the project's gdUnit4 tests headless and answers with every case that did not pass: where it is, and what the assertion said. Each entry under failed carries its first report as message and detail, and, when it has more than one, every report under reports in the order the case met them: gdUnit4 goes on past a failed assertion, and a case can fail several and then stop on a runtime error, which makes its status error. failures counts the cases that failed an assertion and errors the cases that hit an error, so such a case counts in both. Suites where everything passed are counted rather than listed, and an engine message keeps the frames above gdUnit4 rather than the twenty inside it, so a clean tier answers in a few lines; identical engine messages come back once under engineEntries, with times saying how often they were printed, and engineErrors counts every one. The class list is rebuilt first, so a suite written a moment ago is found, and the rebuild's answer is under classes, with the classes each addon declares counted under addedInAddons and changedInAddons rather than named: a class it puts back that the cache had after the last rebuild is named under classes.lostSinceLastRebuild, which is the editor writing its shorter list over the file on every save until restarted. On Windows and Linux the run gets a user:// of its own, so a suite that saves a game writes nowhere near the saves of the copy somebody plays. On macOS the engine reads user:// off HOME and the run writes where the player keeps theirs, which the answer says under savesNote rather than leaving to be found in a save list. A run that found nothing to run is never called a pass: gdUnit4 exits cleanly for one, so the answer says so and names the path it looked in. A script that does not load stops gdUnit4 before any suite runs: its errors come back in full under scriptErrors, and the scripts that failed only because one they depend on did are listed by path under failedThroughDependency. When they failed on a class whose own script has a parser error, which gdUnit4 never names, that script is checked by the engine and its error comes first under scriptErrors, with the class it declares under declares, and the errors a script has only because that class did not resolve, which the engine reads as Variant, are kept apart under followFromUnresolved. A client that sends a progress token is told as each suite finishes, and at least every twenty seconds through a long one, so an idle limit does not end a long tier. A run that ends without a report, at its timeout or otherwise, names the suites it finished under suitesFinished, the failing ones with their failed cases under suitesFailing, and the one it was in under suiteRunning. When a client cuts a run off, that is kept in the project and the next project_test there carries it under previousRunCut. A run where nothing failed but nodes were left in the tree comes back under warnings, with the count per suite: gdUnit4 decides its verdict on those and keeps them out of its report, so they are read off what it printed. A run whose every case passed is still not called passed when it printed a script error that no case failed on: gdUnit4 fails a case on the script errors its logger sees, and it cannot see a stack overflow, so the cases pass on whatever the faulted calls returned. Those errors come back under uncaughtScriptErrors, and under engineEntries by index with detailUnder rather than with their backtrace a second time; a backtrace that repeats, as a recursion's does, has each repeated frame or cycle of frames written once with the frames it covers and how many times. One raised inside assert_error(...).is_runtime_error is the test's own and does not count, and none count when the project turns off gdUnit4's report/godot/script_error setting. Needs gdUnit4 under addons/gdUnit4.",
       parameters: {
         projectPath: PROJECT_PATH,
         path: {
@@ -39250,18 +39250,25 @@ function count(attributes, name) {
   return Number.isFinite(value) ? value : 0;
 }
 function caseOf(suite, element) {
-  const outcome = element.children.find((child) => ["failure", "error", "skipped"].includes(child.name));
-  const status = outcome === undefined ? "passed" : outcome.name === "failure" ? "failed" : outcome.name === "error" ? "error" : "skipped";
-  const detail = outcome?.text.trim() ?? "";
+  const of = (kind) => element.children.filter((child) => child.name === kind).map((child) => {
+    const detail = child.text.trim();
+    return { kind, message: child.attributes["message"] ?? null, detail: detail === "" ? null : detail };
+  });
+  const reports = [...of("failure"), ...of("error"), ...of("skipped")];
+  const status = reports.some((report) => report.kind === "error") ? "error" : reports.some((report) => report.kind === "failure") ? "failed" : reports.length > 0 ? "skipped" : "passed";
   return {
     suite: suite.attributes["name"] ?? "",
     name: element.attributes["name"] ?? "",
     status,
     time: count(element.attributes, "time"),
-    message: outcome?.attributes["message"] ?? null,
-    detail: detail === "" ? null : detail
+    message: reports[0]?.message ?? null,
+    detail: reports[0]?.detail ?? null,
+    reports
   };
 }
+function failedAnAssertion(entry) {
+  return entry.reports.some((report) => report.kind === "failure");
+}
 function pathOf(suite) {
   const directory = suite.attributes["package"];
   const name = suite.attributes["name"];
@@ -39276,7 +39283,7 @@ function parseJUnit(xml) {
   const suiteElements = top.name === "testsuite" ? [top] : top.children.filter((child) => child.name === "testsuite");
   const suites = suiteElements.map((suite) => {
     const cases = suite.children.filter((child) => child.name === "testcase").map((element) => caseOf(suite, element));
-    const failures = cases.filter((entry) => entry.status === "failed").length;
+    const failures = cases.filter(failedAnAssertion).length;
     const errors = cases.filter((entry) => entry.status === "error").length;
     const written = (kind) => suite.children.filter((child) => child.name === "testcase").reduce((sum, element) => sum + element.children.filter((child) => child.name === kind).length, 0);
     return {
@@ -39296,7 +39303,7 @@ function parseJUnit(xml) {
   const all = suites.flatMap((suite) => suite.cases);
   return {
     tests: all.length,
-    failures: all.filter((entry) => entry.status === "failed").length,
+    failures: all.filter(failedAnAssertion).length,
     errors: all.filter((entry) => entry.status === "error").length,
     hookFailures: suites.reduce((sum, suite) => sum + suite.hookFailures, 0),
     hookErrors: suites.reduce((sum, suite) => sum + suite.hookErrors, 0),
@@ -39418,6 +39425,25 @@ ${note}`;
     return detail === entry.detail ? entry : { ...entry, detail };
   });
 }
+function failedCases(report, printed) {
+  const cases = report.suites.flatMap((suite) => suite.cases.filter((entry) => entry.status === "failed" || entry.status === "error").map((entry) => ({ entry, path: suite.path })));
+  const read = withActualsPrinted(cases.flatMap(({ entry }) => entry.reports), printed);
+  let next = 0;
+  return cases.map(({ entry, path }) => {
+    const reports = read.slice(next, next + entry.reports.length);
+    next += entry.reports.length;
+    return {
+      suite: entry.suite,
+      name: entry.name,
+      status: entry.status,
+      time: entry.time,
+      path,
+      message: reports[0]?.message ?? null,
+      detail: reports[0]?.detail ?? null,
+      ...reports.length > 1 ? { reports } : {}
+    };
+  });
+}
 function masked(expected, actual) {
   const allSpelled = (value) => !PRINTED_DICTIONARY.test(value) && value.split("[").length === value.split(MASKED_BRACKET).length;
   return `${expected}${actual}`.includes(MASKED_BRACKET) && allSpelled(expected) && allSpelled(actual);
@@ -42840,6 +42866,9 @@ function runIsUp(run, editorSays, editorPlay = null, now = Date.now()) {
 function noCodeWillCome(run) {
   return !exited(run);
 }
+function transcriptNote(transcript, going) {
+  return going ? `Everything this run has printed is in ${transcript}, uncapped and still being written. Read it for output, not for whether the run is alive: a transcript that stops growing is a run between prints. running above is asked of the operating system while there is a process to ask about, and for an editor-played run that announced no runtime it is the editor's answer instead, which can lag after the game has gone.` : `Everything this run printed is in ${transcript}, uncapped and complete, since the run is over.`;
+}
 function stopWaitMs() {
   return waitFromEnv("GDHARNESS_STOP_WAIT_MS", 1e4);
 }
@@ -45432,7 +45461,7 @@ class GodotServer {
         isError: true
       };
     }
-    const failed = withActualsPrinted(report.suites.flatMap((suite) => suite.cases.filter((entry) => entry.status === "failed" || entry.status === "error").map((entry) => ({ ...entry, path: suite.path }))), Buffer.concat(console2).toString("utf8"));
+    const failed = failedCases(report, Buffer.concat(console2).toString("utf8"));
     const orphans = orphansPrinted(said);
     const leftBehind = new Map(orphans.suites.map((suite) => [suite.path, suite.orphans]));
     const orphansIn = (path) => path === null ? 0 : leftBehind.get(path) ?? 0;
@@ -47575,7 +47604,7 @@ class GodotServer {
       notes.push(`The debug adapter this run's console arrives over went away while the run was going, so what is below has a hole in it and the counts are of what was heard rather than of what was printed. ${back ? "It is connected again, and the line marking where is in the log." : "It is still gone, so nothing further will arrive here."} The project's own user://logs/godot.log has the rest, and "no entries" here means "not heard" rather than a quiet run.`);
     }
     if (run.transcript !== null && selected.omitted > 0) {
-      notes.push(`Everything this run has printed is in ${run.transcript}, uncapped and still being written. Read it for output, not for whether the run is alive: a transcript that stops growing is a run between prints. running above is asked of the operating system while there is a process to ask about, and for an editor-played run that announced no runtime it is the editor's answer instead, which can lag after the game has gone.`);
+      notes.push(transcriptNote(run.transcript, going));
     }
     return this.jsonTextResponse({
       running: going,

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

@@ -377,10 +377,15 @@ static func drawn_over(target: Control) -> Node:
 
 
 ## Why [param node], which is not visible in the tree, is not, as a parenthesis to follow its path:
-## which nodes hide it, nearest first, and what is shown beside the nearest. Reading visible off
-## the node itself says true when only an ancestor is hidden, so without this a caller had nothing
-## to unhide; every hidden one is named because unhiding only the nearest leaves the rest hiding it.
-## "" when nothing on the way up says so.
+## which nodes hide it, nearest first, and what has taken its place. Reading visible off the node
+## itself says true when only an ancestor is hidden, so without this a caller had nothing to unhide;
+## every hidden one is named because unhiding only the nearest leaves the rest hiding it.
+##
+## What has taken its place is what a click at its centre reaches now, which is the screen a game
+## shows instead. Without a control there, as for a 3D node, it is what is shown beside the
+## outermost hidden node: a game hides a screen by hiding the screen's root, and the nearest hidden
+## node can be a panel deep inside it whose siblings are hidden with it. "" when nothing on the way
+## up says the node is hidden.
 static func why_hidden(node: Node) -> String:
 	var hiding: Array[Node] = _hiding(node)
 	if hiding.is_empty():
@@ -391,27 +396,71 @@ static func why_hidden(node: Node) -> String:
 			named.append("its own visible is false")
 		else:
 			named.append("%s is hidden%s" % [one.get_path(), "" if named.is_empty() else " too"])
+	var control: Control = node as Control
+	var instead: Node = null if control == null else drawn_at(control)
+	if instead != null:
+		return " (%s; %s is drawn where it would be)" % [", and ".join(named), instead.get_path()]
+	var outermost: Node = hiding.back()
 	var beside: Array[String] = []
-	var parent: Node = hiding[0].get_parent()
+	var parent: Node = outermost.get_parent()
 	if parent != null:
 		for sibling: Node in parent.get_children():
-			if sibling != hiding[0] and _shown(sibling):
+			if sibling != outermost and _shown(sibling):
 				beside.append(str(sibling.get_path()))
-	return " (%s%s)" % [", and ".join(named), _shown_beside(beside)]
+	return " (%s%s)" % [", and ".join(named), _shown_beside(beside, outermost)]
+
+
+## What a click at the centre of [param target], which is hidden, would reach instead, or null.
+##
+## The topmost thing there that takes the pointer, whatever order it is drawn in relative to the
+## target, since the target is not drawn at all; and never a node holding the target, which covers
+## its place by containing it and is not what took it.
+static func drawn_at(target: Control) -> Node:
+	var drawn: Array[Node] = _pointer_takers(target.get_tree().root)
+	var point: Vector2 = _centre_of(target)
+	var none: Dictionary[ScrollContainer, Vector2] = {}
+	var viewport: Viewport = target.get_viewport()
+	var best: Control = null
+	for each: Node in drawn:
+		var window: Window = each as Window
+		if window != null:
+			if _window_over(target, point, window):
+				return window
+			continue
+		var control: Control = each
+		if control.is_ancestor_of(target) or target.is_ancestor_of(control):
+			continue
+		if control.get_viewport() != viewport or not _holds(control, point):
+			continue
+		if _clipped_away(control, point, none):
+			continue
+		if best == null or _drawn_above(control, best):
+			best = control
+	return best
+
+
+## Whether [param control] is drawn above [param other]: on a higher canvas layer, or later on the
+## same one.
+static func _drawn_above(control: Control, other: Control) -> bool:
+	var layer: int = _layer_of(control)
+	var other_layer: int = _layer_of(other)
+	return layer > other_layer or (layer == other_layer and control.is_greater_than(other))
 
 
-## "; A, B and C beside it are shown" for [param beside], naming three at most and counting the rest.
-static func _shown_beside(beside: Array[String]) -> String:
+## "; A, B and C are shown beside N" for [param beside] and the hidden node [param hidden], naming
+## three at most and counting the rest.
+static func _shown_beside(beside: Array[String], hidden: Node) -> String:
 	if beside.is_empty():
 		return ""
+	var at: String = str(hidden.get_path())
 	if beside.size() == 1:
-		return "; %s beside it is shown" % beside[0]
+		return "; %s is shown beside %s" % [beside[0], at]
 	var listed: Array[String] = beside.slice(0, 3)
 	var rest: int = beside.size() - listed.size()
 	if rest > 0:
-		return "; %s and %d more beside it are shown" % [", ".join(listed), rest]
+		return "; %s and %d more are shown beside %s" % [", ".join(listed), rest, at]
 	var last: String = listed.pop_back()
-	return "; %s and %s beside it are shown" % [", ".join(listed), last]
+	return "; %s and %s are shown beside %s" % [", ".join(listed), last, at]
 
 
 ## The nodes whose visible is false and keeps [param node] from being drawn, nearest first. Walked

package/build/index.js

@@ -29817,18 +29817,25 @@ function count(attributes, name) {
   return Number.isFinite(value) ? value : 0;
 }
 function caseOf(suite, element) {
-  const outcome = element.children.find((child) => ["failure", "error", "skipped"].includes(child.name));
-  const status = outcome === undefined ? "passed" : outcome.name === "failure" ? "failed" : outcome.name === "error" ? "error" : "skipped";
-  const detail = outcome?.text.trim() ?? "";
+  const of = (kind) => element.children.filter((child) => child.name === kind).map((child) => {
+    const detail = child.text.trim();
+    return { kind, message: child.attributes["message"] ?? null, detail: detail === "" ? null : detail };
+  });
+  const reports = [...of("failure"), ...of("error"), ...of("skipped")];
+  const status = reports.some((report) => report.kind === "error") ? "error" : reports.some((report) => report.kind === "failure") ? "failed" : reports.length > 0 ? "skipped" : "passed";
   return {
     suite: suite.attributes["name"] ?? "",
     name: element.attributes["name"] ?? "",
     status,
     time: count(element.attributes, "time"),
-    message: outcome?.attributes["message"] ?? null,
-    detail: detail === "" ? null : detail
+    message: reports[0]?.message ?? null,
+    detail: reports[0]?.detail ?? null,
+    reports
   };
 }
+function failedAnAssertion(entry) {
+  return entry.reports.some((report) => report.kind === "failure");
+}
 function pathOf(suite) {
   const directory = suite.attributes["package"];
   const name = suite.attributes["name"];
@@ -29843,7 +29850,7 @@ function parseJUnit(xml) {
   const suiteElements = top.name === "testsuite" ? [top] : top.children.filter((child) => child.name === "testsuite");
   const suites = suiteElements.map((suite) => {
     const cases = suite.children.filter((child) => child.name === "testcase").map((element) => caseOf(suite, element));
-    const failures = cases.filter((entry) => entry.status === "failed").length;
+    const failures = cases.filter(failedAnAssertion).length;
     const errors = cases.filter((entry) => entry.status === "error").length;
     const written = (kind) => suite.children.filter((child) => child.name === "testcase").reduce((sum, element) => sum + element.children.filter((child) => child.name === kind).length, 0);
     return {
@@ -29863,7 +29870,7 @@ function parseJUnit(xml) {
   const all = suites.flatMap((suite) => suite.cases);
   return {
     tests: all.length,
-    failures: all.filter((entry) => entry.status === "failed").length,
+    failures: all.filter(failedAnAssertion).length,
     errors: all.filter((entry) => entry.status === "error").length,
     hookFailures: suites.reduce((sum, suite) => sum + suite.hookFailures, 0),
     hookErrors: suites.reduce((sum, suite) => sum + suite.hookErrors, 0),
@@ -30010,6 +30017,25 @@ ${note}`;
     return detail === entry.detail ? entry : { ...entry, detail };
   });
 }
+function failedCases(report, printed) {
+  const cases = report.suites.flatMap((suite) => suite.cases.filter((entry) => entry.status === "failed" || entry.status === "error").map((entry) => ({ entry, path: suite.path })));
+  const read = withActualsPrinted(cases.flatMap(({ entry }) => entry.reports), printed);
+  let next = 0;
+  return cases.map(({ entry, path }) => {
+    const reports = read.slice(next, next + entry.reports.length);
+    next += entry.reports.length;
+    return {
+      suite: entry.suite,
+      name: entry.name,
+      status: entry.status,
+      time: entry.time,
+      path,
+      message: reports[0]?.message ?? null,
+      detail: reports[0]?.detail ?? null,
+      ...reports.length > 1 ? { reports } : {}
+    };
+  });
+}
 var MASKED_BRACKET = "[lb]";
 function masked(expected, actual) {
   const allSpelled = (value) => !PRINTED_DICTIONARY.test(value) && value.split("[").length === value.split(MASKED_BRACKET).length;
@@ -34054,7 +34080,7 @@ var TOOL_SPECS = [
   },
   {
     name: "project_test",
-    description: "Runs the project's gdUnit4 tests headless and answers with every case that did not pass: where it is, and what the assertion said. Suites where everything passed are counted rather than listed, and an engine message keeps the frames above gdUnit4 rather than the twenty inside it, so a clean tier answers in a few lines; identical engine messages come back once under engineEntries, with times saying how often they were printed, and engineErrors counts every one. The class list is rebuilt first, so a suite written a moment ago is found, and the rebuild's answer is under classes, with the classes each addon declares counted under addedInAddons and changedInAddons rather than named: a class it puts back that the cache had after the last rebuild is named under classes.lostSinceLastRebuild, which is the editor writing its shorter list over the file on every save until restarted. On Windows and Linux the run gets a user:// of its own, so a suite that saves a game writes nowhere near the saves of the copy somebody plays. On macOS the engine reads user:// off HOME and the run writes where the player keeps theirs, which the answer says under savesNote rather than leaving to be found in a save list. A run that found nothing to run is never called a pass: gdUnit4 exits cleanly for one, so the answer says so and names the path it looked in. A script that does not load stops gdUnit4 before any suite runs: its errors come back in full under scriptErrors, and the scripts that failed only because one they depend on did are listed by path under failedThroughDependency. When they failed on a class whose own script has a parser error, which gdUnit4 never names, that script is checked by the engine and its error comes first under scriptErrors, with the class it declares under declares, and the errors a script has only because that class did not resolve, which the engine reads as Variant, are kept apart under followFromUnresolved. A client that sends a progress token is told as each suite finishes, and at least every twenty seconds through a long one, so an idle limit does not end a long tier. A run that ends without a report, at its timeout or otherwise, names the suites it finished under suitesFinished, the failing ones with their failed cases under suitesFailing, and the one it was in under suiteRunning. When a client cuts a run off, that is kept in the project and the next project_test there carries it under previousRunCut. A run where nothing failed but nodes were left in the tree comes back under warnings, with the count per suite: gdUnit4 decides its verdict on those and keeps them out of its report, so they are read off what it printed. A run whose every case passed is still not called passed when it printed a script error that no case failed on: gdUnit4 fails a case on the script errors its logger sees, and it cannot see a stack overflow, so the cases pass on whatever the faulted calls returned. Those errors come back under uncaughtScriptErrors, and under engineEntries by index with detailUnder rather than with their backtrace a second time; a backtrace that repeats, as a recursion's does, has each repeated frame or cycle of frames written once with the frames it covers and how many times. One raised inside assert_error(...).is_runtime_error is the test's own and does not count, and none count when the project turns off gdUnit4's report/godot/script_error setting. Needs gdUnit4 under addons/gdUnit4.",
+    description: "Runs the project's gdUnit4 tests headless and answers with every case that did not pass: where it is, and what the assertion said. Each entry under failed carries its first report as message and detail, and, when it has more than one, every report under reports in the order the case met them: gdUnit4 goes on past a failed assertion, and a case can fail several and then stop on a runtime error, which makes its status error. failures counts the cases that failed an assertion and errors the cases that hit an error, so such a case counts in both. Suites where everything passed are counted rather than listed, and an engine message keeps the frames above gdUnit4 rather than the twenty inside it, so a clean tier answers in a few lines; identical engine messages come back once under engineEntries, with times saying how often they were printed, and engineErrors counts every one. The class list is rebuilt first, so a suite written a moment ago is found, and the rebuild's answer is under classes, with the classes each addon declares counted under addedInAddons and changedInAddons rather than named: a class it puts back that the cache had after the last rebuild is named under classes.lostSinceLastRebuild, which is the editor writing its shorter list over the file on every save until restarted. On Windows and Linux the run gets a user:// of its own, so a suite that saves a game writes nowhere near the saves of the copy somebody plays. On macOS the engine reads user:// off HOME and the run writes where the player keeps theirs, which the answer says under savesNote rather than leaving to be found in a save list. A run that found nothing to run is never called a pass: gdUnit4 exits cleanly for one, so the answer says so and names the path it looked in. A script that does not load stops gdUnit4 before any suite runs: its errors come back in full under scriptErrors, and the scripts that failed only because one they depend on did are listed by path under failedThroughDependency. When they failed on a class whose own script has a parser error, which gdUnit4 never names, that script is checked by the engine and its error comes first under scriptErrors, with the class it declares under declares, and the errors a script has only because that class did not resolve, which the engine reads as Variant, are kept apart under followFromUnresolved. A client that sends a progress token is told as each suite finishes, and at least every twenty seconds through a long one, so an idle limit does not end a long tier. A run that ends without a report, at its timeout or otherwise, names the suites it finished under suitesFinished, the failing ones with their failed cases under suitesFailing, and the one it was in under suiteRunning. When a client cuts a run off, that is kept in the project and the next project_test there carries it under previousRunCut. A run where nothing failed but nodes were left in the tree comes back under warnings, with the count per suite: gdUnit4 decides its verdict on those and keeps them out of its report, so they are read off what it printed. A run whose every case passed is still not called passed when it printed a script error that no case failed on: gdUnit4 fails a case on the script errors its logger sees, and it cannot see a stack overflow, so the cases pass on whatever the faulted calls returned. Those errors come back under uncaughtScriptErrors, and under engineEntries by index with detailUnder rather than with their backtrace a second time; a backtrace that repeats, as a recursion's does, has each repeated frame or cycle of frames written once with the frames it covers and how many times. One raised inside assert_error(...).is_runtime_error is the test's own and does not count, and none count when the project turns off gdUnit4's report/godot/script_error setting. Needs gdUnit4 under addons/gdUnit4.",
     parameters: {
       projectPath: PROJECT_PATH,
       path: {
@@ -35268,6 +35294,9 @@ function runIsUp(run, editorSays, editorPlay = null, now = Date.now()) {
 function noCodeWillCome(run) {
   return !exited(run);
 }
+function transcriptNote(transcript, going) {
+  return going ? `Everything this run has printed is in ${transcript}, uncapped and still being written. Read it for output, not for whether the run is alive: a transcript that stops growing is a run between prints. running above is asked of the operating system while there is a process to ask about, and for an editor-played run that announced no runtime it is the editor's answer instead, which can lag after the game has gone.` : `Everything this run printed is in ${transcript}, uncapped and complete, since the run is over.`;
+}
 function stopWaitMs() {
   return waitFromEnv("GDHARNESS_STOP_WAIT_MS", 1e4);
 }
@@ -37929,7 +37958,7 @@ class GodotServer {
         isError: true
       };
     }
-    const failed = withActualsPrinted(report.suites.flatMap((suite) => suite.cases.filter((entry) => entry.status === "failed" || entry.status === "error").map((entry) => ({ ...entry, path: suite.path }))), Buffer.concat(console2).toString("utf8"));
+    const failed = failedCases(report, Buffer.concat(console2).toString("utf8"));
     const orphans = orphansPrinted(said);
     const leftBehind = new Map(orphans.suites.map((suite) => [suite.path, suite.orphans]));
     const orphansIn = (path) => path === null ? 0 : leftBehind.get(path) ?? 0;
@@ -40072,7 +40101,7 @@ class GodotServer {
       notes.push(`The debug adapter this run's console arrives over went away while the run was going, so what is below has a hole in it and the counts are of what was heard rather than of what was printed. ${back ? "It is connected again, and the line marking where is in the log." : "It is still gone, so nothing further will arrive here."} The project's own user://logs/godot.log has the rest, and "no entries" here means "not heard" rather than a quiet run.`);
     }
     if (run.transcript !== null && selected.omitted > 0) {
-      notes.push(`Everything this run has printed is in ${run.transcript}, uncapped and still being written. Read it for output, not for whether the run is alive: a transcript that stops growing is a run between prints. running above is asked of the operating system while there is a process to ask about, and for an editor-played run that announced no runtime it is the editor's answer instead, which can lag after the game has gone.`);
+      notes.push(transcriptNote(run.transcript, going));
     }
     return this.jsonTextResponse({
       running: going,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdharness",
-  "version": "1.2.1",
+  "version": "1.2.3",
   "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",