gdharness 1.3.13 → 1.3.15

package/build/cli.js

@@ -10896,7 +10896,13 @@ function exitNamed(code) {
     return `0x${unsigned.toString(16).toUpperCase()} (${status})`;
   }
   const gdunit = GDUNIT_EXITS.get(code);
-  return gdunit === undefined ? String(code) : `${String(code)} (${gdunit})`;
+  if (gdunit !== undefined) {
+    return `${String(code)} (${gdunit})`;
+  }
+  if (code > 0 && code < 256 && !GODOT_EXITS.has(code)) {
+    return `${String(code)} (a code neither Godot nor gdUnit4 ends with, so most likely a quit(${String(code)}) in the project's code the engine ran)`;
+  }
+  return String(code);
 }
 function rowsAcross(engines) {
   const dealtOut = new Map;
@@ -11132,7 +11138,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, 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_EXITS, TAIL = 60, MOST_NAMED = 8;
+var SUITE_OPENED, TIME, CASE_LINE, STATISTICS, ERROR_LINE, WARNING_LINE, EXECUTED, 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_EXITS, GODOT_EXITS, TAIL = 60, MOST_NAMED = 8;
 var init_suite_judge = __esm(() => {
   init_engine_leaks();
   init_junit();
@@ -11169,6 +11175,7 @@ var init_suite_judge = __esm(() => {
     [104, "gdUnit4's code for a Godot version it does not support"],
     [105, "gdUnit4's code for scripts that did not compile"]
   ]);
+  GODOT_EXITS = new Set([1, 255]);
 });
 
 // src/engine-launch.ts
@@ -11247,16 +11254,24 @@ function resPathOf(entry, projectPath, cwd) {
 function homeOf(projectPath) {
   return mainCheckoutOf(projectPath) ?? projectPath;
 }
-function sweepRunDirectories(runs) {
+function sweepRunDirectories(runs, kept = KEPT_RUN_DIRECTORIES) {
   if (!existsSync5(runs)) {
     return;
   }
+  const ended = [];
   for (const entry of readdirSync3(runs)) {
-    const pid = Number(/^\d+-(\d+)$/.exec(entry)?.[1]);
-    if (!Number.isInteger(pid) || !alive(pid)) {
+    const named = /^(\d+)-(\d+)$/.exec(entry);
+    const pid = Number(named?.[2]);
+    if (!Number.isInteger(pid)) {
       rmSync4(join7(runs, entry), { recursive: true, force: true });
+    } else if (!alive(pid)) {
+      ended.push({ entry, started: Number(named?.[1]) });
     }
   }
+  ended.sort((a, b) => b.started - a.started);
+  for (const { entry } of ended.slice(kept)) {
+    rmSync4(join7(runs, entry), { recursive: true, force: true });
+  }
 }
 function roomFor(most, processors, available, said = "of memory free", processorsSaid = `the machine has ${plural(processors, "processor")}`) {
   const byMemory = Math.floor((available - MEMORY_KEPT) / MEMORY_PER_ENGINE);
@@ -11445,7 +11460,7 @@ function endTree(child) {
     process6.kill(-child.pid, "SIGKILL");
   } catch {}
 }
-var EngineUsageError, MOST_ENGINES = 4, SILENCE_FLOOR_SECONDS = 300, CONTROL_SEQUENCE, WINDOWS_EXCEPTION = 3221225472, MEMORY_KEPT, MEMORY_PER_ENGINE, LOOK_MS = 500, COMMIT_ASK_MS = 15000, AUTOLOAD_FAILED = "Failed to instantiate an autoload";
+var EngineUsageError, MOST_ENGINES = 4, SILENCE_FLOOR_SECONDS = 300, CONTROL_SEQUENCE, WINDOWS_EXCEPTION = 3221225472, MEMORY_KEPT, MEMORY_PER_ENGINE, LOOK_MS = 500, COMMIT_ASK_MS = 15000, AUTOLOAD_FAILED = "Failed to instantiate an autoload", KEPT_RUN_DIRECTORIES = 5;
 var init_engine_launch = __esm(() => {
   init_alive();
   init_desktop();
@@ -15995,7 +16010,7 @@ var init_tool_definitions = __esm(() => {
     {
       name: "project_settings",
       title: "Project settings",
-      description: "Reads or writes project.godot (settings, autoloads, the main scene, input actions and plugins) and the audio bus layout, default_bus_layout.tres unless audio/buses/default_bus_layout names another. project_info include lists the autoloads, input actions and audio buses as the project holds them. A write with an editor open on the project is handed to the editor, which takes the settings the write changed or names from the file (named under editorAdopted), including a setting the file already held, since the editor can hold another value after the file was put back, or reloads the bus layout, so it answers the new values and does not save the old ones back over them. editorNote is an editor that could not take the write, or one on another release's addon that was not asked, which still holds the old values until editor_launch restart. An enabled plugin's code still loads on the editor's next start. set answers old_value and new_value, with was_new true when project.godot did not set the setting before, and was_default true when what it held was the engine's own default, which old_value then is. add_input_action on an action that exists, one of the engine's ui_ actions included, replaces its events, and its deadzone when one is given, and answers was_new false with what it held under old_events and old_deadzone. A set of the value the setting already holds, in the same type, writes nothing and answers unchanged true and saved false. unset takes a setting's line out of project.godot, the way back from a set of a misspelt name, and answers removed, old_value and default_value, the value that holds now (null for a setting the engine does not declare; for an override, name.feature, holds is the base setting's value its builds read now); on one the file does not set it answers removed false and writes nothing. Every write keeps the sections and keys of project.godot in the order the file had them, so a change moves no other line; the save is the engine's, and like the editor's it writes Godot's header and config/features into a file that lacks them. get answers exists, true for any setting the engine knows, at_default, true when the value is the engine's own default and so has no line in project.godot, and overrides, the value each feature's override holds. An override answers override_of, its base setting, and one project.godot does not set answers exists false with holds, the base setting's value. Each setting under prefix carries at_default too, so a family read separates what the project sets from the engine's defaults; it is absent for a setting the engine registers no default for, such as an input action the project added, which only the project can have set.",
+      description: "Reads or writes project.godot (settings, autoloads, the main scene, input actions and plugins) and the audio bus layout, default_bus_layout.tres unless audio/buses/default_bus_layout names another. project_info include lists the autoloads, input actions and audio buses as the project holds them. A write with an editor open on the project is handed to the editor, which takes the settings the write changed or names from the file (named under editorAdopted), including a setting the file already held, since the editor can hold another value after the file was put back, or reloads the bus layout, so it answers the new values and does not save the old ones back over them. editorNote is an editor that could not take the write, or one on another release's addon that was not asked, which still holds the old values until editor_launch restart. An enabled plugin's code still loads on the editor's next start. set answers old_value and new_value, with was_new true when project.godot did not set the setting before, and was_default true when what it held was the engine's own default, which old_value then is. add_input_action on an action that exists, one of the engine's ui_ actions included, replaces its events, and its deadzone when one is given, and answers was_new false with what it held under old_events and old_deadzone. A set of the value the setting already holds, in the same type, writes nothing and answers unchanged true and saved false. unset takes a setting's line out of project.godot, the way back from a set of a misspelt name, and answers removed, old_value and default_value, the value that holds now (null for a setting the engine does not declare; for an override, name.feature, holds is the base setting's value its builds read now); on one the file does not set it answers removed false and writes nothing. Every write changes only the lines of the settings it names and keeps every other line as the file had it, in its place: the engine's own save would sort a dictionary's keys and write what a project_settings_override file laid over the project. get answers exists, true for any setting the engine knows, at_default, true when the value is the engine's own default and so has no line in project.godot, and overrides, the value each feature's override holds. An override answers override_of, its base setting, and one project.godot does not set answers exists false with holds, the base setting's value. Each setting under prefix carries at_default too, so a family read separates what the project sets from the engine's defaults; it is absent for a setting the engine registers no default for, such as an input action the project added, which only the project can have set.",
       parameters: {
         projectPath: PROJECT_PATH,
         setting: {
@@ -17502,7 +17517,7 @@ var init_tool_definitions = __esm(() => {
           type: ["boolean", "array"],
           items: { type: "string" },
           ops: ["call"],
-          description: 'call: read the object the call answered with in the same answer, under result_properties: true for every variable its script declares, or a list of names, each a colon path walked from that object the way property paths are ("dead_allowed", "terms:0:name"). A name that is not there is listed under result_properties_missing with why, and a result that is not an object answers properties_note instead. Without it an object comes back as its class and id only.'
+          description: `call: read the object the call answered with in the same answer, under result_properties: true for every variable its script declares, or a list of names, each a colon path walked from that object the way property paths are ("dead_allowed", "terms:0:name"). For a list or a dictionary the call answered with, they are read off each object in it: result_properties is then a list, or a dictionary under the same keys, with null for an element that is no object. A name that is not there is listed under result_properties_missing with why, led by the element's index or key for a list or dictionary, and a result with no object in it answers properties_note instead. Without it an object comes back as its class, its script_class or script, and id, which is the object's instance id (get_instance_id()) and never a property of its own named id: read that one through properties.`
         },
         timeoutMs: {
           type: "integer",
@@ -17912,7 +17927,7 @@ var init_tool_definitions = __esm(() => {
     {
       name: "debug_state",
       title: "Debugger state",
-      description: "Where the debugged game is stopped: the stack trace, what is in scope at a frame with the values, or the debugger's console output so far, its last thousand lines, with any earlier ones counted under notShown. For a game this server started the output is what the game printed; the errors and warnings it reported, with where each happened, are in editor_output. For a game this server started, its keeper's debugger answers: each frame names its script as the project spells it under script and on this machine under path, and held says which thread stopped and why. For a game the editor plays, the editor's debug adapter answers. A stop is reported by the editor's adapter only to the sessions connected when it happened, so a server that connected afterwards, which is every server after a reconnect, is shown a thread and no frames about a game still sitting at its breakpoint. That server asks the runtime instead: a held game accepts a connection and never answers, and the refusal then says held rather than running, and that the stack cannot be read from here. debug_control continue lets it go, and the next stop is one this session is told about, with its stack. A function that awaited is resumed with no caller below it, since the call that started it returned at the await, so its frame is the only one. The variables give an object as its class and id only, and evaluate reads into it: an expression worked out by the game at a frame, with the frame's locals, the globals and every global class in scope and the frame's instance as self, such as wave.spawned or wave.spawned.size(). The game runs what the expression calls, so a call that changes something changes the game. A frame with no instance, a static function's called on its class, is refused, since the engine lets the game go on rather than evaluate there; the frame below it has one. The compiler's own locals, named with @ such as a for loop's @counter_pos, are left out.",
+      description: "Where the debugged game is stopped: the stack trace, what is in scope at a frame with the values, or the debugger's console output so far, its last thousand lines, with any earlier ones counted under notShown. For a game this server started the output is what the game printed; the errors and warnings it reported, with where each happened, are in editor_output. For a game this server started, its keeper's debugger answers: each frame names its script as the project spells it under script and on this machine under path, and held says which thread stopped and why. For a game the editor plays, the editor's debug adapter answers. A stop is reported by the editor's adapter only to the sessions connected when it happened, so a server that connected afterwards, which is every server after a reconnect, is shown a thread and no frames about a game still sitting at its breakpoint. That server asks the runtime instead: a held game accepts a connection and never answers, and the refusal then says held rather than running, and that the stack cannot be read from here. debug_control continue lets it go, and the next stop is one this session is told about, with its stack. A function that awaited is resumed with no caller below it, since the call that started it returned at the await, so its frame is the only one. The variables give an object as its class and instance id only, and evaluate reads into it: an expression worked out by the game at a frame, with the frame's locals, the globals and every global class in scope and the frame's instance as self, such as wave.spawned or wave.spawned.size(). The game runs what the expression calls, so a call that changes something changes the game. A frame with no instance, a static function's called on its class, is refused, since the engine lets the game go on rather than evaluate there; the frame below it has one. The compiler's own locals, named with @ such as a for loop's @counter_pos, are left out.",
       parameters: {
         frameId: {
           type: "number",
@@ -18370,12 +18385,14 @@ function unitsOf(suites, times, splitPast = SPLIT_PAST_SECONDS) {
   return suites.flatMap((suite) => {
     const time = times[suite.path];
     const costOf = (func) => time?.cases[func] ?? caseCost;
+    const timedCase = (func) => time?.cases[func] !== undefined;
     const around = time === undefined ? aroundCost : Math.max(0, time.seconds - Object.values(time.cases).reduce((sum, s) => sum + s, 0));
     const whole = around + suite.cases.reduce((sum, func) => sum + costOf(func), 0);
     const wholly = {
       suite: suite.path,
       cases: suite.cases,
       cost: whole,
+      timed: suite.cases.every(timedCase),
       windowed: suite.windowed,
       headless: suite.headless
     };
@@ -18390,6 +18407,7 @@ function unitsOf(suites, times, splitPast = SPLIT_PAST_SECONDS) {
             suite: suite.path,
             cases: [func],
             cost: around + costOf(func),
+            timed: timedCase(func),
             windowed: false,
             headless: suite.headless
           }
@@ -18400,6 +18418,7 @@ function unitsOf(suites, times, splitPast = SPLIT_PAST_SECONDS) {
         cases: [func],
         row: { index, rest: index === rows.length - 1 },
         cost: around + seconds,
+        timed: true,
         windowed: false,
         headless: suite.headless
       }));
@@ -18417,7 +18436,7 @@ function dealt(units, declared, most) {
   const restart = windowed.length > 0 ? ENGINE_START_SECONDS : 0;
   const total = units.reduce((sum, unit) => sum + unit.cost, 0);
   const slowest = Math.max(together, headless[0]?.cost ?? 0);
-  const count = Math.max(1, Math.min(most, headless.length + (windowed.length > 0 ? 1 : 0), Math.ceil(total / Math.max(slowest, ENGINE_START_SECONDS))));
+  const count = Math.max(1, Math.min(most, headless.length + (windowed.length > 0 ? 1 : 0), Math.ceil(total / Math.max(slowest, ENGINE_START_SECONDS)) + headless.filter((unit) => !unit.timed).length));
   const bins = Array.from({ length: count }, () => []);
   const loads = Array.from({ length: count }, (_, lane) => lane === 0 ? together + restart : 0);
   for (const unit of headless) {
@@ -57961,7 +57980,7 @@ function failed(faults, engines, runDirectory, so) {
   for (const engine of engines) {
     console.log(`what ${engine.name} printed: ${engine.log}`);
   }
-  console.log(`Every engine's output is kept under ${runDirectory} until the next run.`);
+  console.log(`Every engine's output is kept under ${runDirectory} until ${String(KEPT_RUN_DIRECTORIES)} later runs have failed.`);
   return 1;
 }
 
@@ -58748,7 +58767,7 @@ ${readFileSync22(engine.log, "utf8")}`);
   }
   const problems = failed.reduce((sum, engine) => sum + engine.verdict.faults.length, across.length + uncollected.length);
   console.log(`Failed: ${plural(problems, "problem")}, listed above. Ran ${totals}`);
-  console.log(`Every engine's output is kept under ${logs.shown} until the next run.`);
+  console.log(`Every engine's output is kept under ${logs.shown} until ${String(KEPT_RUN_DIRECTORIES)} later runs have failed.`);
   return 1;
 }
 function writeEarlyResult(file, startedAt, problems, logs) {

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

@@ -245,6 +245,14 @@ func _wait_for_the_profiler() -> void:
 		OS.delay_msec(1)
 
 
+## Whether this runtime is listening for gdharness's server. It is not in a release build, a script
+## run, a scene the project keeps quiet, an engine `gdharness spread` started, or a game that could
+## not have its port, though the node is there in all of them, so ask this rather than whether the
+## node exists.
+func serving() -> bool:
+	return _enabled and _server != null and _server.is_listening()
+
+
 func _ready() -> void:
 	name = "GdharnessRuntime"
 	# The TCP control loop runs in _process. With the default PROCESS_MODE_INHERIT it stops

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

@@ -694,12 +694,27 @@ static func _reads_the_result(asked: Variant) -> bool:
 
 ## What [param asked] reads off the object a call answered with: every variable its script declares
 ## when [param asked] is true, or the properties a list names, each a path walked from the object.
+## Off each object of a list or a dictionary the call answered with too, in the result's shape.
 ##
-## In the same answer because an object handed back is otherwise only its class and an id, and
-## reading one field of it meant finding the same object again by a path into the game's private
-## state, which works only where the caller already knows a key. A name that is not there is listed
-## rather than refusing the answer, since the call has run by then and its result is what was asked.
+## In the same answer because an object handed back is otherwise only its class and its instance
+## id, and reading one field of it meant finding the same object again by a path into the game's
+## private state, which works only where the caller already knows a key; a catalogue of records
+## handed back as a list took one call per record. A name that is not there is listed rather than
+## refusing the answer, since the call has run by then and its result is what was asked.
 func _read_off_result(result: Variant, asked: Variant) -> Dictionary:
+	var missing: Array[String] = []
+	if result is Array:
+		var list: Array = result
+		var read_each: Array = []
+		for index: int in list.size():
+			read_each.append(_read_off_element(list[index], "[%d]" % index, asked, missing))
+		return _read_off_many(read_each, list, "Array", missing)
+	if result is Dictionary:
+		var map: Dictionary = result
+		var read_by_key: Dictionary = {}
+		for key: Variant in map:
+			read_by_key[str(key)] = _read_off_element(map[key], "[%s]" % str(key), asked, missing)
+		return _read_off_many(read_by_key, map.values(), "Dictionary", missing)
 	if result is Object and not is_instance_valid(result):
 		return {
 			"properties_note": "the call answered an object that has since been freed, so nothing was read"
@@ -710,6 +725,49 @@ func _read_off_result(result: Variant, asked: Variant) -> Dictionary:
 			"the call answered %s, which has no properties to read" % type_string(typeof(result))
 		}
 	var object: Object = result
+	var one: Dictionary = _read_off_object(object, asked)
+	missing = one["missing"]
+	var answered: Dictionary = {"result_properties": one["read"]}
+	if not missing.is_empty():
+		answered["result_properties_missing"] = missing
+	return answered
+
+
+## What was read off one element of a list or a dictionary a call answered with, or null for one
+## that is no object; why a name was not there goes into [param missing], led by [param named].
+func _read_off_element(element: Variant, named: String, asked: Variant, missing: Array[String]) -> Variant:
+	if not element is Object:
+		return null
+	if not is_instance_valid(element):
+		missing.append("%s is an object that has since been freed" % named)
+		return null
+	var object: Object = element
+	var one: Dictionary = _read_off_object(object, asked)
+	var whys: Array[String] = one["missing"]
+	for why: String in whys:
+		missing.append("%s %s" % [named, why])
+	return one["read"]
+
+
+## The answer for a list or a dictionary, [param read] holding what each element gave, unless none
+## of [param elements] is an object.
+static func _read_off_many(
+	read: Variant, elements: Array, shape: String, missing: Array[String]
+) -> Dictionary:
+	if not elements.any(func(element: Variant) -> bool: return element is Object):
+		return {
+			"properties_note":
+			"the call answered %s with no object in it, so there are no properties to read" % shape
+		}
+	var answered: Dictionary = {"result_properties": read}
+	if not missing.is_empty():
+		answered["result_properties_missing"] = missing
+	return answered
+
+
+## What [param asked] reads off [param object], under read, and why each name it could not read is
+## not there, under missing.
+func _read_off_object(object: Object, asked: Variant) -> Dictionary:
 	var wanted: Array[String] = []
 	if asked is Array:
 		for name: Variant in asked:
@@ -724,10 +782,7 @@ func _read_off_result(result: Variant, asked: Variant) -> Dictionary:
 			missing.append(str(walked["message"]))
 		else:
 			read[path] = _values.serialize(walked["value"])
-	var answered: Dictionary = {"result_properties": read}
-	if not missing.is_empty():
-		answered["result_properties_missing"] = missing
-	return answered
+	return {"read": read, "missing": missing}
 
 
 ## The variables the script attached to [param object] declares, in the order it declares them.

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

@@ -892,10 +892,12 @@ class GdhTrace:
 		elif value is Dictionary:
 			var map: Dictionary = value
 			_last = map.duplicate(true)
+		# Game time unrounded: a frame can be a tenth of a millisecond long, and a rate worked out over
+		# one from times cut to a ten-thousandth was off by its own size.
 		var change: Dictionary = {
 			"frame": frame,
 			"elapsed_ms": elapsed,
-			"game_time": snappedf(game_time, 0.0001),
+			"game_time": game_time,
 			"value": values.serialize(value),
 		}
 		if changes.size() < MOST_CHANGES:

package/build/godot/loader/loader.gd

@@ -1,16 +1,27 @@
 extends Node
-## Brings gdharness's runtime up in a debug build that has its addon, and does nothing anywhere else.
+## Brings gdharness's runtime up in a debug build that has its addon, and does nothing elsewhere.
 ##
-## `project.godot` names this file rather than the addon's script. `addons/` is often not committed
-## and exports leave it out, so an entry naming the addon boots a fresh clone or an exported build
-## with a missing script. `gdharness setup` writes this file, and `gdharness doctor` says when it is
-## not the one that gdharness ships. The runtime refuses a `-s` script run by itself unless
-## `gdharness/runtime/serve_script_runs` is on, so that is left to it.
+## `project.godot` names this file rather than the addon's script. The addons folder is often not
+## committed and exports leave it out, so an entry naming the addon boots a fresh clone or an
+## exported build with a missing script. `gdharness setup` writes this file, and `gdharness doctor`
+## says when it is not the one that gdharness ships. The runtime refuses a `-s` script run by itself
+## unless the project's serve_script_runs setting is on, so that is left to it.
 
 ## Loaded by path as it runs rather than preloaded: a preload resolves when this script is parsed,
 ## and in a build without the addon that is the missing script this file is here to avoid.
 const RUNTIME: String = "res://addons/gdharness_runtime/runtime_autoload.gd"
 
+var _runtime: Node
+
+
+## Whether gdharness's runtime is listening in this engine: false in a release build, a script run
+## and an engine without the addon, though this node is in every one of them.
+func serving() -> bool:
+	if not is_instance_valid(_runtime) or not _runtime.has_method("serving"):
+		return false
+	var answered: Variant = _runtime.call("serving")
+	return answered is bool and answered
+
 
 func _ready() -> void:
 	if not OS.is_debug_build() or not ResourceLoader.exists(RUNTIME):
@@ -26,3 +37,4 @@ func _ready() -> void:
 	# autoloads, and a deferred add would bring the runtime up only after the main scene's _ready.
 	# Added now, it announces before the main scene runs, as it does when an entry names it.
 	add_child(runtime)
+	_runtime = runtime

package/build/godot/operations/project_file.gd

@@ -5,10 +5,14 @@ extends RefCounted
 ## The engine writes each section's keys in the order it registered them, and an engine running a
 ## script registers them in another order than the editor does, so a one-setting change moved lines
 ## nobody touched across several sections and a commit of it read as a rewrite. The save is still the
-## engine's, for what only it gets right: the header and each value's text. The order is taken from
-## the file as it was, and so is every line of a key the call did not change: the engine leaves out
-## each key at its default, so a project holding `unsafe_call_argument=0` on purpose lost the line to
-## a change of another key.
+## engine's, for what only it gets right: the header and the text of each value the call changed.
+## The order is taken from the file as it was, and so is every line of a key the call did not change,
+## because the engine writes its settings as it holds them rather than as the file had them. It
+## leaves out each key at its default, so a project holding `unsafe_call_argument=0` on purpose lost
+## the line to a change of another key. It writes a dictionary with its keys sorted, so gdUnit4's
+## session hooks, which run in the order listed, changed order. And it writes what a
+## `project_settings_override` file laid over the project, so a player's window mode in the user
+## directory became the game's default.
 
 const PATH: String = "res://project.godot"
 
@@ -35,30 +39,48 @@ static func save(changed: PackedStringArray) -> Error:
 	return OK
 
 
-## [param written] with its sections and their keys put in the order [param before] has them, and
-## each line [param before] has for a key [param written] lacks put back, unless that key's setting
-## is in [param changed]. Every other line of the result is a line of [param written], so nothing the
-## engine wrote is lost or changed.
+## [param before] with the lines of the settings in [param changed] as [param written] has them: one
+## the engine wrote goes in its place, or where the engine put it relative to its neighbours when it
+## is new, and one the engine left out leaves the file. Every other line is [param before]'s, in its
+## place, and a key the engine wrote that the file did not hold and the call did not change stays out.
+## The header is [param written]'s.
 static func in_order_of(before: String, written: String, changed: PackedStringArray) -> String:
 	var old: Dictionary = _parsed(before)
 	var fresh: Dictionary = _parsed(written)
 	var old_sections: Array[Dictionary] = old["sections"]
-	var fresh_sections: Array[Dictionary] = fresh["sections"]
+	var all_fresh: Array[Dictionary] = fresh["sections"]
+
+	var old_text: Dictionary[String, Dictionary] = {}
+	for section: Dictionary in old_sections:
+		var texts: Dictionary[String, String] = {}
+		for entry: Dictionary in section["entries"]:
+			texts[str(entry["key"])] = str(entry["text"])
+		old_text[str(section["name"])] = texts
 
 	var by_name: Dictionary[String, Dictionary] = {}
 	var fresh_names: Array[String] = []
+	var fresh_sections: Array[Dictionary] = []
 	var entry_of: Dictionary[String, Dictionary] = {}
 	var fresh_keys: Dictionary[String, Array] = {}
-	for section: Dictionary in fresh_sections:
+	for section: Dictionary in all_fresh:
 		var name: String = section["name"]
-		by_name[name] = section
-		fresh_names.append(name)
+		var held: Dictionary = old_text.get(name, {})
 		var texts: Dictionary[String, String] = {}
 		var keys: Array[String] = []
 		for entry: Dictionary in section["entries"]:
 			var key: String = entry["key"]
-			texts[key] = str(entry["text"])
+			if changed.has(_setting_of(name, key)):
+				texts[key] = str(entry["text"])
+			elif held.has(key):
+				texts[key] = str(held[key])
+			else:
+				continue
 			keys.append(key)
+		if keys.is_empty():
+			continue
+		by_name[name] = section
+		fresh_names.append(name)
+		fresh_sections.append(section)
 		entry_of[name] = texts
 		fresh_keys[name] = keys
 

package/build/keeper.js

@@ -8331,6 +8331,7 @@ var GDUNIT_EXITS = new Map([
   [104, "gdUnit4's code for a Godot version it does not support"],
   [105, "gdUnit4's code for scripts that did not compile"]
 ]);
+var GODOT_EXITS = new Set([1, 255]);
 
 // src/windows-ask.ts
 var SCRIPT = [
@@ -8386,6 +8387,9 @@ async function linuxStartTimes(pids) {
   }
   return began;
 }
+async function linuxStartEarliest() {
+  return 1000 + Math.ceil(1000 / (await ticksPerSecond() ?? 100));
+}
 var ticksAnswered;
 async function ticksPerSecond() {
   if (ticksAnswered !== undefined) {
@@ -9906,11 +9910,10 @@ import { setTimeout as delay2 } from "node:timers/promises";
 var RESTARTED_WITHIN_MS = 2000;
 var LIST_WITHIN_MS = 15000;
 var POLL_MS = 250;
-function successorAmong(listed, exitedPid, engine, notBefore, exitedAt, secondsOnly) {
-  const slack = secondsOnly ? 1000 : 0;
+function successorAmong(listed, exitedPid, engine, notBefore, exitedAt, early) {
   const fold = (name) => process.platform === "win32" ? name.toLowerCase() : name;
   const wanted = fold(basename5(engine.replaceAll("\\", "/")));
-  const found = listed.filter((one) => one.pid !== exitedPid && fold(readCommandLine(one.command).executable) === wanted && one.startedAt + slack >= notBefore && one.startedAt + slack >= exitedAt - RESTARTED_WITHIN_MS);
+  const found = listed.filter((one) => one.pid !== exitedPid && fold(readCommandLine(one.command).executable) === wanted && one.startedAt + early >= notBefore && one.startedAt + early >= exitedAt - RESTARTED_WITHIN_MS);
   return found.length === 1 ? found[0] ?? null : null;
 }
 async function followSuccessor(exitedPid, engine, notBefore, exitedAt, transcript) {
@@ -9981,7 +9984,7 @@ async function followOnWindows(exitedPid, engine, notBefore, exitedAt) {
       candidates.push({ pid: Number(fields[1]), startedAt: Number(fields[2]), command: fields[3].trim() });
     }
   }
-  const successor = successorAmong(candidates, exitedPid, engine, notBefore, exitedAt, false);
+  const successor = successorAmong(candidates, exitedPid, engine, notBefore, exitedAt, 0);
   holder.stdin.end(successor === null ? `
 ` : `${String(successor.pid)}
 `);
@@ -9996,6 +9999,7 @@ async function followOnWindows(exitedPid, engine, notBefore, exitedAt) {
 }
 async function followOnPosix(exitedPid, engine, notBefore, exitedAt, transcript) {
   const linux = process.platform === "linux";
+  const early = linux ? await linuxStartEarliest() : 1000;
   let printed;
   try {
     ({ stdout: printed } = await runHidden("ps", ["-e", "-o", linux ? "pid=,args=" : "pid=,lstart=,args="], {
@@ -10029,7 +10033,7 @@ async function followOnPosix(exitedPid, engine, notBefore, exitedAt, transcript)
       }
     }
   }
-  const timely = listed.filter((one) => successorAmong([one], exitedPid, engine, notBefore, exitedAt, true) !== null);
+  const timely = listed.filter((one) => successorAmong([one], exitedPid, engine, notBefore, exitedAt, early) !== null);
   const ours = canonical(transcript);
   const candidates = [];
   for (const one of timely) {
@@ -10038,7 +10042,7 @@ async function followOnPosix(exitedPid, engine, notBefore, exitedAt, transcript)
       candidates.push(one);
     }
   }
-  const successor = successorAmong(candidates, exitedPid, engine, notBefore, exitedAt, true);
+  const successor = successorAmong(candidates, exitedPid, engine, notBefore, exitedAt, early);
   if (successor === null) {
     return null;
   }

package/package.json

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