gdharness 1.3.46 → 1.3.47

package/build/cli.js

@@ -11027,9 +11027,10 @@ function rowOf(name) {
 function rowRuns(share, row) {
   return "only" in share ? row !== null && share.only.includes(row) : row === null || !share.besides.includes(row);
 }
-function mismatchedRowsIn(printed) {
+function skippedAsDeclaredIn(printed) {
   const lines = printed.flatMap((text) => stripVTControlCharacters(text).split(/\r?\n/));
   const found = [];
+  const unrunnable = [];
   let suite = null;
   let lastCase = null;
   for (let at = 0;at < lines.length; at += 1) {
@@ -11045,7 +11046,15 @@ function mismatchedRowsIn(printed) {
       lastCase = caseLine[3] === "STARTED" ? lastCase : caseLine[2] ?? null;
       continue;
     }
-    if (suite === null || lastCase === null || !MISMATCHED_ROW.test(line)) {
+    if (suite === null || lastCase === null) {
+      continue;
+    }
+    const declared = UNRUNNABLE_CASE.exec(line)?.[1];
+    if (declared !== undefined) {
+      unrunnable.push({ suite, name: lastCase, reason: declared });
+      continue;
+    }
+    if (!MISMATCHED_ROW.test(line)) {
       continue;
     }
     const parts = [line.trim()];
@@ -11055,7 +11064,7 @@ function mismatchedRowsIn(printed) {
     }
     found.push({ suite, name: lastCase, reason: parts.join(" ").replaceAll(/\[\/?color[^\]]*\]/g, "") });
   }
-  return found;
+  return { mismatched: found, unrunnable };
 }
 function readRun(printed) {
   const lines = stripVTControlCharacters(printed).replaceAll(`\r
@@ -11189,7 +11198,7 @@ function readRun(printed) {
     leftOut,
     engineVersion,
     orphansLeft,
-    mismatched: mismatchedRowsIn(lines)
+    ...skippedAsDeclaredIn(lines)
   };
 }
 function withNestedErrors(printed, piped) {
@@ -11314,7 +11323,7 @@ function judgeEngine(printed, handed, end) {
   if (printed.executed === null || printed.executed === 0) {
     faults.push(printed.executed === null ? "the run never printed its summary" : "the run executed no test case at all, whatever it exited with");
   }
-  for (const row of printed.mismatched) {
+  for (const row of [...printed.mismatched, ...printed.unrunnable]) {
     faults.push(`${row.suite} > ${row.name} never ran: gdUnit4 skipped it, saying "${row.reason}"`);
     failing.add(row.suite);
   }
@@ -11481,7 +11490,7 @@ ${String(error.warning)}`);
   const neverPrinted = [...owed.values()].flatMap((debt) => debt.texts.map((text) => ({ suite: debt.suite, during: debt.during, text, warning: debt.warning })));
   return { printed: unexpected, neverPrinted };
 }
-var SUITE_OPENED, TIME, CASE_LINE, STATISTICS, ERROR_LINE, WARNING_LINE, EXECUTED, MISMATCHED_ROW, BANNER, LEFT_OUT, DRIVER_FALLBACK, MACHINE_WARNED, ORPHANS_REPORTED, STARVED, NESTED_ERROR = "While attempting to print an error, another error was printed:", WINDOWS_EXITS, MEMORY_EXITS, GDUNIT_FAILED = 100, GDUNIT_ORPHANS = 101, GDUNIT_EXITS, GODOT_EXITS, TAIL = 60, MOST_NAMED = 8;
+var SUITE_OPENED, TIME, CASE_LINE, STATISTICS, ERROR_LINE, WARNING_LINE, EXECUTED, MISMATCHED_ROW, UNRUNNABLE_CASE, BANNER, LEFT_OUT, DRIVER_FALLBACK, MACHINE_WARNED, ORPHANS_REPORTED, STARVED, NESTED_ERROR = "While attempting to print an error, another error was printed:", WINDOWS_EXITS, MEMORY_EXITS, GDUNIT_FAILED = 100, GDUNIT_ORPHANS = 101, GDUNIT_EXITS, GODOT_EXITS, TAIL = 60, MOST_NAMED = 8;
 var init_suite_judge = __esm(() => {
   init_engine_leaks();
   init_junit();
@@ -11493,6 +11502,7 @@ var init_suite_judge = __esm(() => {
   WARNING_LINE = /^\s*(?:SCRIPT |USER )?WARNING: (.*?)\s*$/;
   EXECUTED = /^Executed test cases\s*:\s*\((\d+)\//;
   MISMATCHED_ROW = /^\s*The test data set at index \(\d+\) does not match the expected test parameters/;
+  UNRUNNABLE_CASE = /^\s*Reason: '((?:Unknown test case argument's \[.*\] found|Fuzzer argument '.+' must be declared before the test config argument\(s\) \[.*\])\.)'\s*$/;
   BANNER = /^\s*Godot Engine v(\S+?)(?:\s+-\s+\S+)?\s*$/;
   LEFT_OUT = /^gdharness left out (res:\/\/.+?\.gd) > ([^:\s]+):(-?\d+)\s*$/;
   DRIVER_FALLBACK = /^\s*WARNING: Your video card drivers .*, switching to /;
@@ -17130,7 +17140,7 @@ var init_tool_definitions = __esm(() => {
         path: {
           type: ["string", "array"],
           items: { type: "string" },
-          description: 'A test directory or suite file inside the project, or a list of them, all run on one engine: a named set of suites boots once rather than once per suite. An entry given twice, or a suite inside a directory also listed, runs once. An entry "suite.gd:test_name" runs that case alone, as gdharness test reads it and as tests runs it, so it cannot share the list with a whole suite or a directory. An entry that is not there is left out and named under missing, the rest run, and such a run is never called passed; when no entry is there the run is refused before the engine starts, naming each one. A script named that declares no test_ function at the top level is refused the same way, and so is a directory holding no suite. A script that declares test_ functions and does not extend GdUnitTestSuite, which gdUnit4 never runs and never mentions, is refused when named, and under a directory run whole it is named under notSuites and the run is not called passed. A case declared there that gdUnit4 never ran, in a suite that passed, comes back under testsNotRun, and a row it skipped for data that does not fit the case under rowsMismatched with the reason gdUnit4 gave; neither run is called passed. Default tests and test, those the project has, which is where gdharness test looks.'
+          description: 'A test directory or suite file inside the project, or a list of them, all run on one engine: a named set of suites boots once rather than once per suite. An entry given twice, or a suite inside a directory also listed, runs once. An entry "suite.gd:test_name" runs that case alone, as gdharness test reads it and as tests runs it, so it cannot share the list with a whole suite or a directory. An entry that is not there is left out and named under missing, the rest run, and such a run is never called passed; when no entry is there the run is refused before the engine starts, naming each one. A script named that declares no test_ function at the top level is refused the same way, and so is a directory holding no suite. A script that declares test_ functions and does not extend GdUnitTestSuite, which gdUnit4 never runs and never mentions, is refused when named, and under a directory run whole it is named under notSuites and the run is not called passed. A case declared there that gdUnit4 never ran, in a suite that passed, comes back under testsNotRun, a row it skipped for data that does not fit the case under rowsMismatched, and a case it skipped because it cannot run it as declared (a parameter nothing fills, or a fuzzer after a setting) under casesUnrunnable, each with the reason gdUnit4 gave; none of those runs is called passed. Default tests and test, those the project has, which is where gdharness test looks.'
         },
         ignore: {
           type: "array",
@@ -18620,7 +18630,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. 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, and alternatives separated by | met by whichever appears first ("*won*|*lost*"); 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, and says under looking_ms how long the looks took between them.'
+          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, and alternatives separated by | met by whichever appears first ("*won*|*lost*"); 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, and says under looking_ms how long the looks took between them. A look on a large screen is read about 2ms to a frame, so no frame grows by more, except the last look as the time runs out, which is read whole; longest_hold_ms is the longest the looks held one frame, which tells a long frame the game logs apart from one the wait caused.'
         },
         includeHidden: {
           type: "boolean",
@@ -53509,10 +53519,14 @@ ${error.text}`;
       test: `${row.suite} > ${row.name}`,
       reason: row.reason
     }));
+    const casesUnrunnable = casePrinted.unrunnable.map((one) => ({
+      test: `${one.suite} > ${one.name}`,
+      reason: one.reason
+    }));
     return this.jsonTextResponse({
-      passed: !timedOut && exitCode === 0 && nothingRan === null && report.tests > 0 && report.failures === 0 && report.errors === 0 && hookFailures.length === 0 && uncaught.length === 0 && undeclaredPrinted.length === 0 && declaredNotPrinted.length === 0 && countedLeaks.length === 0 && missing.length === 0 && testsNotRun.length === 0 && casesNotRun.length === 0 && rowsMismatched.length === 0 && notSuites.length === 0,
+      passed: !timedOut && exitCode === 0 && nothingRan === null && report.tests > 0 && report.failures === 0 && report.errors === 0 && hookFailures.length === 0 && uncaught.length === 0 && undeclaredPrinted.length === 0 && declaredNotPrinted.length === 0 && countedLeaks.length === 0 && missing.length === 0 && testsNotRun.length === 0 && casesNotRun.length === 0 && rowsMismatched.length === 0 && casesUnrunnable.length === 0 && notSuites.length === 0,
       verdict: [
-        verdict === "passed" && undeclaredPrinted.length + declaredNotPrinted.length + countedLeaks.length + testsNotRun.length + casesNotRun.length + rowsMismatched.length + notSuites.length > 0 ? undefined : verdict,
+        verdict === "passed" && undeclaredPrinted.length + declaredNotPrinted.length + countedLeaks.length + testsNotRun.length + casesNotRun.length + rowsMismatched.length + casesUnrunnable.length + notSuites.length > 0 ? undefined : verdict,
         ...[false, true].map((warning) => {
           const count = undeclaredPrinted.filter((error) => error.warning === warning).length;
           const word = warning ? "warning" : "error";
@@ -53526,12 +53540,14 @@ ${error.text}`;
         countedLeaks.length > 0 ? "the engine exited holding what it should have freed" : undefined,
         testsNotRun.length + casesNotRun.length > 0 ? `not run: ${[...testsNotRun, ...casesNotRun].join(", ")}` : undefined,
         rowsMismatched.length > 0 ? `${rowsMismatched.length === 1 ? "one row" : `${String(rowsMismatched.length)} rows`} skipped for data that does not fit the case` : undefined,
+        casesUnrunnable.length > 0 ? `${casesUnrunnable.length === 1 ? "one case" : `${String(casesUnrunnable.length)} cases`} skipped as gdUnit4 cannot run ${casesUnrunnable.length === 1 ? "it" : "them"} as declared` : undefined,
         notSuites.length > 0 ? `${notSuites.length === 1 ? "one script declares" : `${String(notSuites.length)} scripts declare`} cases gdUnit4 never runs` : undefined
       ].filter((part) => part !== undefined).join("; "),
       ...missing.length > 0 ? { missing } : {},
       ...notSuites.length > 0 ? { notSuites } : {},
       ...testsNotRun.length + casesNotRun.length > 0 ? { testsNotRun: [...testsNotRun, ...casesNotRun] } : {},
       ...rowsMismatched.length > 0 ? { rowsMismatched } : {},
+      ...casesUnrunnable.length > 0 ? { casesUnrunnable } : {},
       ...timedOut ? { timedOut, hung, silentForMs } : {},
       exitCode,
       exitSignal: run.exitSignal ?? undefined,
@@ -53565,6 +53581,7 @@ ${error.text}`;
         testsNotRun.length > 0 ? `${testsNotRun.join(", ")} ${testsNotRun.length === 1 ? "was" : "were"} asked for and not run, so the run is not called passed: gdUnit4 runs a test_ function only in a script that extends GdUnitTestSuite, and leaves out a suite whose script does not load.` : undefined,
         casesNotRun.length > 0 ? `${casesNotRun.join(", ")} ${casesNotRun.length === 1 ? "is a case" : "are cases"} of a suite that ran and passed, and gdUnit4 never ran ${casesNotRun.length === 1 ? "it" : "them"} and said nothing of it, so the run is not called passed, as gdharness test judges it.` : undefined,
         rowsMismatched.length > 0 ? `gdUnit4 skipped what rowsMismatched names because the row's data does not fit the case's parameters, though it printed ${rowsMismatched.length === 1 ? "the row" : "each row"} passed first; each entry carries gdUnit4's reason. The run is not called passed, as gdharness test judges it.` : undefined,
+        casesUnrunnable.length > 0 ? `gdUnit4 skipped what casesUnrunnable names because it cannot run ${casesUnrunnable.length === 1 ? "that case" : "those cases"} as declared, though it printed ${casesUnrunnable.length === 1 ? "it" : "each"} passed first; each entry carries gdUnit4's reason. A parameter is filled only by _test_parameters, a fuzzer or a setting gdUnit4 names (timeout, do_skip, skip_reason, fuzzer_iterations, fuzzer_seed), and fuzzers come before the settings. The run is not called passed, as gdharness test judges it.` : undefined,
         notSuites.length > 0 ? "What notSuites names declares cases gdUnit4 never runs, so the run is not called passed, as gdharness test judges it." : undefined,
         briefed > 0 ? `${briefed} of the ${failed.length} failing cases, those with the largest reports, are named with their first message only, since their reports would have made the answer too large to deliver; pass one case's suite path to see its reports.` : undefined,
         notApplied.length > 0 ? "An ignore entry named a case that ran all the same: gdUnit4 leaves a case out only as suite_name:test_name, and reads an entry with no colon as a suite name or a piece of a suite path. ignoreNotApplied gives the form for each case that ran." : undefined,

package/build/godot/addons/gdharness_editor/scene_uids.gd

@@ -25,29 +25,41 @@ static func save_keeping_uid(resource: Resource, file_path: String) -> Error:
 	var marked: Error = ResourceSaver.set_uid(file_path, uid)
 	if marked != OK:
 		return marked
-	return _with_external_uids(file_path)
+	return _as_the_editor_writes(file_path)
 
 
-## Puts back the uid on each external resource the text file at [param file_path] names. Only the
-## editor's file system tells the saver a path's uid, so a headless save writes every reference by
-## path alone, and each breaks when the file it names is moved.
-static func _with_external_uids(file_path: String) -> Error:
+## Writes the text file at [param file_path] as the editor's save would have.
+##
+## Only the editor's file system tells the saver a path's uid, so a headless save writes every
+## reference by path alone, and each breaks when the file it names is moved: the uid is put back on
+## each external resource.
+##
+## The saver leaves out a shader parameter holding the default the renderer gives it, and a headless
+## engine's renderer gives none, so every parameter a ShaderMaterial never set was written as null.
+## Loading null clears the parameter, so the line changes nothing, and the editor drops it again.
+static func _as_the_editor_writes(file_path: String) -> Error:
 	if not (file_path.ends_with(".tscn") or file_path.ends_with(".tres")):
 		return OK
 	var lines: PackedStringArray = FileAccess.get_file_as_string(file_path).split("\n")
 	var pattern: RegEx = RegEx.create_from_string(' path="([^"]+)"')
+	var unset: RegEx = RegEx.create_from_string("^shader_parameter/\\S+ = null$")
+	var kept: PackedStringArray = []
 	var changed: bool = false
-	for at: int in lines.size():
-		var line: String = lines[at]
-		if not line.begins_with("[ext_resource ") or line.contains(' uid="'):
-			continue
-		var named: RegExMatch = pattern.search(line)
-		if named == null:
+	for line: String in lines:
+		if unset.search(line) != null:
+			changed = true
 			continue
-		var uid: String = reference_uid(named.get_string(1))
+		var named: RegExMatch = (
+			pattern.search(line)
+			if line.begins_with("[ext_resource ") and not line.contains(' uid="')
+			else null
+		)
+		var uid: String = "" if named == null else reference_uid(named.get_string(1))
 		if not uid.is_empty():
-			lines[at] = line.replace(' path="', uid + ' path="')
+			line = line.replace(' path="', uid + ' path="')
 			changed = true
+		var _added: bool = kept.append(line)
+	lines = kept
 	if not changed:
 		return OK
 	var file: FileAccess = FileAccess.open(file_path, FileAccess.WRITE)

package/build/godot/addons/gdharness_editor/tools/animation_states.gd

@@ -137,13 +137,26 @@ func connect_animation_states(args: Dictionary) -> Dictionary:
 	sm.add_transition(StringName(from_state), StringName(to_state), transition)
 	if not sm.has_transition(StringName(from_state), StringName(to_state)):
 		return scene.refuse("The state machine did not take the transition.")
+	_tell_the_tree(sm)
 	var files: Dictionary = found[2]
-	return _finish(
-		scene,
-		Callable(),
-		files,
-		{ "ok": true, "from": from_state, "to": to_state, "advanceMode": advance_mode }
-	)
+	var made: Dictionary = {
+		"ok": true,
+		"from": from_state,
+		"to": to_state,
+		"transitionType": transition_type,
+		"advanceMode": advance_mode,
+	}
+	if not advance_condition.is_empty():
+		made["advanceCondition"] = advance_condition
+	return _finish(scene, Callable(), files, made)
+
+
+## Has the AnimationTree playing [param sm] list its parameters again. Adding or removing a
+## transition does not say the tree changed, so the save kept the parameters from before it: a
+## condition's parameter was written by the next call to change the machine, and a removed one's
+## stayed until then.
+static func _tell_the_tree(sm: AnimationNodeStateMachine) -> void:
+	var _told: Error = sm.emit_signal(&"tree_changed")
 
 
 ## Why [param sm] cannot take a transition from [param from_state] to [param to_state], or "".
@@ -270,6 +283,7 @@ func disconnect_animation_states(args: Dictionary) -> Dictionary:
 	sm.remove_transition(StringName(from_state), StringName(to_state))
 	if sm.has_transition(StringName(from_state), StringName(to_state)):
 		return scene.refuse("The state machine did not let go of the transition.")
+	_tell_the_tree(sm)
 	var files: Dictionary = found[2]
 	return _finish(
 		scene, Callable(), files, { "ok": true, "removed": { "from": from_state, "to": to_state } }

package/build/godot/addons/gdharness_editor/tools/scene_tools.gd

@@ -718,6 +718,15 @@ func set_node_properties(args: Dictionary) -> Dictionary:
 		if property != "name" and property in node and not named.has(property):
 			named.append(property)
 	var source: String = scene.values_from(node, old_path)
+	# Read before the write, which frees the node.
+	var unsaved: Array[String] = []
+	for declared: Dictionary in node.get_property_list():
+		var declared_name: String = str(declared.get("name", ""))
+		if (
+			named.has(declared_name)
+			and not GdhRead.as_int(declared.get("usage", 0)) & PROPERTY_USAGE_STORAGE
+		):
+			unsaved.append(declared_name)
 	var carried: GdhPaths = GdhPaths.new()
 	var _rewritten: int = carried.carry(
 		scene,
@@ -751,7 +760,7 @@ func set_node_properties(args: Dictionary) -> Dictionary:
 		answer["droppedNodes"] = dropped["nodes"]
 	_note_put_back(answer, scene, id, new_path)
 	_note_loads_as(answer, scene, new_path)
-	_note_left_out(answer, scene.written_pack, new_path, named, source)
+	_note_left_out(answer, scene.written_pack, new_path, named, unsaved, source)
 	if new_path != old_path:
 		answer.merge(GdhKin.follow(scene_path, old_path, new_path, carried))
 	return answer
@@ -793,9 +802,15 @@ static func _note_put_back(answer: Dictionary, scene: GdhSceneFile, id: int, at:
 
 ## Notes under notStored each of [param named] the file saved from [param pack] does not set on the
 ## node at [param at]: a set gave it the value the node has without it, so the packer leaves it out,
-## as the editor does, and it follows [param source], or its default, from then on.
+## as the editor does, and it follows [param source], or its default, from then on. [param unsaved]
+## are those of them the node never stores by name.
 static func _note_left_out(
-	answer: Dictionary, pack: PackedScene, at: String, named: Array[String], source: String
+	answer: Dictionary,
+	pack: PackedScene,
+	at: String,
+	named: Array[String],
+	unsaved: Array[String],
+	source: String
 ) -> void:
 	var stored: Dictionary = {}
 	var state: SceneState = pack.get_state()
@@ -803,9 +818,13 @@ static func _note_left_out(
 		if str(state.get_node_path(index)).trim_prefix("./") == at:
 			for property: int in state.get_node_property_count(index):
 				stored[str(state.get_node_property_name(index, property))] = true
+	# A property the file never holds by name, as a Control's position, which its offsets hold, is
+	# stored when what changed with it is.
+	var also: Dictionary = answer.get("alsoChanged", {})
+	var held_with_it: bool = also.keys().any(func(other: Variant) -> bool: return stored.has(other))
 	var left: Array[String] = []
 	for asked: String in named:
-		if not stored.has(asked):
+		if not stored.has(asked) and not (held_with_it and unsaved.has(asked)):
 			left.append(asked)
 	if left.is_empty():
 		return

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

@@ -17,6 +17,11 @@ const MOST_FRAMES: int = 600
 ## How long a wait for words leaves between looks, as a multiple of what the last look took: nine
 ## gives looking about a tenth of the time.
 const LOOKS_APART: int = 9
+## The longest a wait for words holds one of the game's frames while it looks, in microseconds: a
+## look over a screen too large to read in that time carries on in the next frame from where it
+## stopped. Read whole, a look over an interface of about 1,000 labels held a frame for 28ms every
+## few dozen, which a game logging its own frame times took for a hitch of its own.
+const LOOK_SLICE_USEC: int = 2000
 ## How a property wait compares what it reads with the value: equality by default, and order for a
 ## number that steps rather than lands, as a day counter on a fast clock goes from 31 to 34 between
 ## two looks and a wait for 32 never sees it.
@@ -785,9 +790,12 @@ static func _declared_slot(holder: Variant, named: String) -> Dictionary:
 ## looking takes about a tenth of the time. Every frame on a hall of 3,500 nodes held the game at a
 ## sixth of its frame rate, and its clock, which advances by the frame's delta, lost three quarters
 ## of its time, so a wait for a date timed out on a clock that turned a day every thirty seconds.
-## The answer says how many frames the wait spanned, how many looks it took and how long they took
-## between them, which is how a caller sees what it cost and whether the game lost its speed to the
-## looks or to something else.
+## Each look is read a slice at a time, [constant LOOK_SLICE_USEC] to a frame, so the frames it runs
+## in keep their length; the last is read whole, since the wait answers on it.
+##
+## The answer says how many frames the wait spanned, how many looks it took, how long they took
+## between them and the longest they held one frame, which is how a caller sees what it cost and
+## whether the game lost its speed, or a frame its length, to the looks or to something else.
 func _wait_until_said(
 	node_path: String, said: String, timeout_ms: int, include_hidden: bool
 ) -> Dictionary:
@@ -795,18 +803,29 @@ func _wait_until_said(
 	var frames: int = 0
 	var looks: int = 0
 	var looked_usec: int = 0
+	var held_usec: int = 0
 	var next_look: int = 0
 	var looked_at_frame: int = 0
 	var found: bool = false
+	var look: GdhLook = null
+	var look_began: int = 0
 	while true:
-		if Time.get_ticks_usec() >= next_look:
-			var looking: int = Time.get_ticks_usec()
-			found = _anything_says(node_path, said, include_hidden)
-			looks += 1
-			var took: int = Time.get_ticks_usec() - looking
-			looked_usec += took
-			next_look = Time.get_ticks_usec() + took * LOOKS_APART
+		if look == null and Time.get_ticks_usec() >= next_look:
+			look = GdhLook.new(_under(node_path), said, include_hidden)
+			look_began = Time.get_ticks_usec()
+		if look != null:
+			var held: int = look.go_on(LOOK_SLICE_USEC)
+			looked_usec += held
+			held_usec = maxi(held_usec, held)
 			looked_at_frame = frames
+			if look.done:
+				looks += 1
+				found = look.found
+				# From where the look began, since the frames it was read across are the game's:
+				# counted from its end, a look spread over a third of a second waited out its nine
+				# lengths after that, and a wait on 3,500 nodes looked four times in two seconds.
+				next_look = look_began + look.took_usec * (LOOKS_APART + 1)
+				look = null
 		if found or Time.get_ticks_msec() - started >= timeout_ms:
 			break
 		await _host.get_tree().process_frame
@@ -815,14 +834,18 @@ func _wait_until_said(
 	# never having come. Taken once a whole frame has run since the last look, which is two frame
 	# starts: a first look that outlasted the timeout otherwise left none, so the wait answered with
 	# the game not having run at all, and a command sent during that look not yet read.
+	var heard: bool = found
 	if not found:
 		while frames - looked_at_frame < 2:
 			await _host.get_tree().process_frame
 			frames += 1
-		var last: int = Time.get_ticks_usec()
-		found = _anything_says(node_path, said, include_hidden)
+		var last: GdhLook = GdhLook.new(_under(node_path), said, include_hidden)
+		var held: int = last.go_on(-1)
 		looks += 1
-		looked_usec += Time.get_ticks_usec() - last
+		looked_usec += held
+		held_usec = maxi(held_usec, held)
+		found = last.found
+		heard = last.heard
 
 	var answer: Dictionary = {
 		"type": "condition",
@@ -834,10 +857,11 @@ func _wait_until_said(
 		"frames": frames,
 		"looks": looks,
 		"looking_ms": looked_usec / 1000.0,
+		"longest_hold_ms": held_usec / 1000.0,
 	}
 	# Words that are there and cannot be read look, from a wait that ran out, like words that never
 	# came.
-	if not found and not include_hidden and _anything_says(node_path, said, true):
+	if not found and heard:
 		answer["unseen_note"] = (
 			(
 				"Something under %s says it, but is hidden or drawn outside the viewport or a "
@@ -849,22 +873,8 @@ func _wait_until_said(
 	return answer
 
 
-## Whether anything under [param node_path] says [param said], the node itself included, and where
-## the player can read it 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:
-		return false
-	var pending: Array[Node] = [root]
-	while not pending.is_empty():
-		var node: Node = pending.pop_back()
-		if GdhSays.says(node, said) and (include_hidden or GdhQueries.readable(node)):
-			return true
-		pending.append_array(node.get_children(true))
-	return false
+func _under(node_path: String) -> Node:
+	return _host.get_tree().root.get_node_or_null(node_path)
 
 
 ## Remembers that a signal fired and what it carried, for a wait that polls rather than
@@ -942,6 +952,56 @@ class GdhTrace:
 			dropped += 1
 
 
+## One look for whether anything under a node says some words, the node itself included, and where
+## the player can read it 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.
+class GdhLook:
+	extends RefCounted
+	## Whether a node that counts says the words.
+	var found: bool = false
+	## Whether any node says them, hidden or not: words that are there and cannot be read look,
+	## from a wait that ran out, like words that never came.
+	var heard: bool = false
+	var done: bool = false
+	## How long the look has taken over every frame it has run in.
+	var took_usec: int = 0
+	var _said: String
+	var _include_hidden: bool
+	## Untyped, since a node waiting here can be freed between two frames of the look.
+	var _pending: Array = []
+
+	func _init(root: Node, said: String, include_hidden: bool) -> void:
+		_said = said
+		_include_hidden = include_hidden
+		if root != null:
+			_pending.append(root)
+
+	## Reads on until the look is done or [param budget_usec] has passed, -1 for no limit, and
+	## answers how long it read.
+	func go_on(budget_usec: int) -> int:
+		var from: int = Time.get_ticks_usec()
+		while not _pending.is_empty():
+			if budget_usec >= 0 and Time.get_ticks_usec() - from >= budget_usec:
+				break
+			var next: Variant = _pending.pop_back()
+			if not is_instance_valid(next):
+				continue
+			var node: Node = next
+			if GdhSays.says(node, _said):
+				heard = true
+				if _include_hidden or GdhQueries.readable(node):
+					found = true
+					_pending.clear()
+					break
+			_pending.append_array(node.get_children(true))
+		done = _pending.is_empty()
+		var read: int = Time.get_ticks_usec() - from
+		took_usec += read
+		return read
+
+
 ## A signal recorded from when it was armed until it is collected.
 class GdhWatch:
 	extends RefCounted

package/build/godot/operations/export_presets.gd

@@ -121,6 +121,26 @@ static func _runnable(config: ConfigFile, section: String) -> bool:
 	return GdhRead.as_bool(config.get_value(section, "runnable", false))
 
 
+## The name of the preset [param platform] runs, or "" when it has none: the one its section names,
+## or in a file saved before that section, the last preset of the platform keeping the key, which is
+## the one the editor ends up running. Read from the section alone, a file of that age had no
+## runnable preset, so a preset added for its platform took the place of the one it had.
+static func _runnable_name(config: ConfigFile, platform: String) -> String:
+	if config.has_section_key(RUNNABLE_SECTION, platform):
+		return str(config.get_value(RUNNABLE_SECTION, platform))
+	var named: String = ""
+	var at: int = 0
+	while config.has_section("preset." + str(at)):
+		var section: String = "preset." + str(at)
+		if (
+			str(config.get_value(section, "platform", "")) == platform
+			and GdhRead.as_bool(config.get_value(section, "runnable", false))
+		):
+			named = str(config.get_value(section, "name", ""))
+		at += 1
+	return named
+
+
 ## Adds an export preset to export_presets.cfg, written with the keys the editor's Project > Export
 ## writes for a new one, and every option in [code]known_options[/code] (what
 ## [method export_options] answers for the platform) at its default. The editor also writes the
@@ -160,7 +180,7 @@ func add_export_preset(params: Dictionary) -> Dictionary:
 			)
 		index += 1
 	# A platform with no preset to run takes the new one, as the editor's dialog does.
-	var runnable: bool = not config.has_section_key(RUNNABLE_SECTION, platform)
+	var runnable: bool = _runnable_name(config, platform).is_empty()
 	if runnable:
 		config.set_value(RUNNABLE_SECTION, platform, preset_name)
 
@@ -609,6 +629,7 @@ func remove_export_preset(params: Dictionary) -> Dictionary:
 	var index: int = found["index"]
 	var section: String = found["section"]
 	var platform: String = str(config.get_value(section, "platform", ""))
+	var was_runnable: bool = _runnable_name(config, platform) == preset_name
 	var last: int = index
 	while config.has_section("preset." + str(last + 1)):
 		last += 1
@@ -622,11 +643,17 @@ func remove_export_preset(params: Dictionary) -> Dictionary:
 		if keeping != OK:
 			return _log.failure("Failed to save %s: %s" % [CREDENTIALS_FILE, error_string(keeping)])
 		answer["credentials"] = CREDENTIALS_FILE
-	if str(config.get_value(RUNNABLE_SECTION, platform, "")) == preset_name:
-		config.set_value(RUNNABLE_SECTION, platform, null)
-		answer["runnableNow"] = null
+	if was_runnable:
+		if config.has_section_key(RUNNABLE_SECTION, platform):
+			config.set_value(RUNNABLE_SECTION, platform, null)
+		# A file saved before the section can mark another preset of the platform too, which the
+		# editor then runs.
+		var kept: String = _runnable_name(config, platform)
+		answer["runnableNow"] = kept
+		if kept.is_empty():
+			answer["runnableNow"] = null
 		var at: int = 0
-		while config.has_section("preset." + str(at)):
+		while kept.is_empty() and config.has_section("preset." + str(at)):
 			if str(config.get_value("preset." + str(at), "platform", "")) == platform:
 				var next: String = str(config.get_value("preset." + str(at), "name", ""))
 				config.set_value(RUNNABLE_SECTION, platform, next)

package/package.json

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