gdharness 1.3.26 → 1.3.28

package/build/cli.js

@@ -10915,6 +10915,7 @@ function readRun(printed) {
     executed,
     unloadable,
     stoppedIn,
+    running: last === null ? null : { suite: last.path, during },
     leftOut,
     engineVersion,
     orphansLeft
@@ -11395,7 +11396,7 @@ async function inTurns(items, at, run) {
 function heldToCores(cores, command, args, platform = process6.platform) {
   return cores === null || platform !== "linux" ? { command, args: [...args] } : { command: "taskset", args: ["-c", `0-${String(cores - 1)}`, command, ...args] };
 }
-async function watchedEngine(launch, args, directory, log, silenceSeconds) {
+async function watchedEngine(launch, args, directory, log, silenceSeconds, silenceIn) {
   const user = join7(directory, "user");
   const env = { ...process6.env, APPDATA: user, XDG_DATA_HOME: user };
   const output = openSync2(log, "w");
@@ -11468,6 +11469,7 @@ async function watchedEngine(launch, args, directory, log, silenceSeconds) {
     const started = Date.now();
     let lastGrowth = started;
     let text = "";
+    let allowed = { size: -1, seconds: silenceSeconds };
     while (!finished.now) {
       await delay2(LOOK_MS);
       const deadline = launch.deadlineSeconds;
@@ -11488,9 +11490,18 @@ async function watchedEngine(launch, args, directory, log, silenceSeconds) {
           stop();
         }
       } else if (ended === null && Date.now() - lastGrowth > silenceSeconds * 1000) {
-        const stoppedIn = readRun(text).stoppedIn;
+        if (allowed.size !== size) {
+          allowed = {
+            size,
+            seconds: silenceIn === undefined ? silenceSeconds : Math.max(silenceSeconds, silenceIn(readRun(text)))
+          };
+        }
+        if (Date.now() - lastGrowth <= allowed.seconds * 1000) {
+          continue;
+        }
+        const { stoppedIn } = readRun(text);
         const unstarted = helper !== null && !existsSync5(helper.pid) ? `, and it never started ${helper.how}: ${helperStep(helper.step)}` : "";
-        ended = `the engine printed nothing for ${String(silenceSeconds)} s${stoppedIn === null ? "" : ` while running ${stoppedIn}`}, so it was ended${unstarted}`;
+        ended = `the engine printed nothing for ${String(allowed.seconds)} s${stoppedIn === null ? "" : ` while running ${stoppedIn}`}, so it was ended${unstarted}`;
         stop();
       }
     }
@@ -58366,7 +58377,23 @@ function getLocalVersion() {
 
 // src/suite-run.ts
 var SLOWEST_NAMED = 5;
-var SILENCE_TIMES_SLOWEST = 4;
+var SILENCE_TIMES_TAKEN = 4;
+function silenceWhile(running, times, floorSeconds) {
+  const time = running === null ? undefined : times[running.suite];
+  if (running === null || time === undefined) {
+    return floorSeconds;
+  }
+  let taken;
+  if (running.during === null || running.during === "before") {
+    const cases = Object.values(time.cases).reduce((sum, seconds) => sum + seconds, 0);
+    taken = Math.max(0, time.seconds - cases);
+  } else {
+    const func = funcOf(running.during);
+    const row = rowOf(running.during);
+    taken = (row === null ? undefined : time.rows?.[func]?.[row]) ?? time.cases[func];
+  }
+  return Math.max(floorSeconds, SILENCE_TIMES_TAKEN * (taken ?? 0));
+}
 var VALUED2 = new Set([
   "--engines",
   "--slots",
@@ -58660,12 +58687,12 @@ ${existsSync23(path) ? readFileSync22(path, "latin1") : "missing"}`)
       console.log(`Dealt out row by row, since ${byRows.length === 1 ? "it" : "each"} took more than ${String(SPLIT_PAST_SECONDS)} s last time: ${named(byRows)}.`);
     }
     const lanes = [...new Set(plans.map((plan) => plan.lane))].map((lane) => plans.flatMap((plan, index) => plan.lane === lane ? [{ plan, index }] : []));
-    let ran = (await inTurns(lanes, room.engines, (lane) => runLane(launch, lane, units))).flat().sort((a, b) => a.index - b.index);
+    let ran = (await inTurns(lanes, room.engines, (lane) => runLane(launch, lane, times))).flat().sort((a, b) => a.index - b.index);
     if (ran.some((engine) => engine.verdict.starved) && ran.some((engine) => !engine.verdict.passed)) {
       console.log("An engine ran out of memory, so every engine that failed runs again, one at a time.");
       const again = [];
       for (const engine of ran) {
-        again.push(engine.verdict.passed ? engine : await runEngine2(launch, engine.plan, engine.index, units, "again"));
+        again.push(engine.verdict.passed ? engine : await runEngine2(launch, engine.plan, engine.index, times, "again"));
       }
       ran = again;
     }
@@ -58756,19 +58783,19 @@ async function importProject(launch) {
     launch.slots.release(lock);
   }
 }
-async function runLane(launch, lane, units) {
+async function runLane(launch, lane, times) {
   const lock = await launch.slots.take();
   try {
     const ran = [];
     for (const { plan, index } of lane) {
-      ran.push(await runEngine2(launch, plan, index, units, "", lock));
+      ran.push(await runEngine2(launch, plan, index, times, "", lock));
     }
     return ran;
   } finally {
     launch.slots.release(lock);
   }
 }
-async function runEngine2(launch, plan, index, units, again = "", slot = null) {
+async function runEngine2(launch, plan, index, times, again = "", slot = null) {
   const directory = join27(launch.runDirectory, `engine-${String(index)}${again === "" ? "" : `-${again}`}`);
   mkdirSync10(join27(directory, "user"), { recursive: true });
   const suitesFile = join27(directory, "suites.txt");
@@ -58816,15 +58843,12 @@ async function runEngine2(launch, plan, index, units, again = "", slot = null) {
     "--expected-out",
     expectedFile
   ];
-  const held = new Set(plan.suites.map((suite) => suite.path));
-  const slowest = Math.max(0, ...units.filter((unit) => held.has(unit.suite)).map((unit) => unit.cost));
-  const silence = Math.max(launch.silenceFloorSeconds, SILENCE_TIMES_SLOWEST * slowest);
   const log = join27(directory, "engine.log");
   const lock = slot ?? await launch.slots.take();
   const began = Date.now();
   let end;
   try {
-    end = await watchedEngine(launch, args, directory, log, silence);
+    end = await watchedEngine(launch, args, directory, log, launch.silenceFloorSeconds, (printed) => silenceWhile(printed.running, times, launch.silenceFloorSeconds));
   } finally {
     if (slot === null) {
       launch.slots.release(lock);

package/build/godot/addons/auto_reload/auto_reload.gd

@@ -6,10 +6,27 @@ extends EditorPlugin
 ## that keeps showing the old file is how a change reads as one that never happened. The
 ## files are polled once a second; the editor's own watcher only fires on window focus.
 
+
+## What was last seen of a watched file.
+class GdhSeen:
+	## Its modification time, in whole seconds.
+	var time: int
+	## The MD5 of its contents.
+	var md5: String
+
+	func _init(seen_time: int, seen_md5: String) -> void:
+		time = seen_time
+		md5 = seen_md5
+
+
 const CHECK_INTERVAL_SECONDS: float = 1.0
+## How long after a file's modification time its contents are compared as well. The time is in
+## whole seconds, so a second write inside the second of the first leaves it as it was and changes
+## only the contents; past that second any write moves the time.
+const SAME_SECOND_SECONDS: int = 5
 
 var _timer: Timer
-## The last modification time seen, by path.
+## What was last seen of each watched file, by path.
 var _watched_files: Dictionary = {}
 
 
@@ -22,6 +39,11 @@ func _enter_tree() -> void:
 	var watching: int = _timer.timeout.connect(_check_for_changes)
 	if watching != OK:
 		push_error("gdharness: could not start watching for changes on disk")
+	# A scene's files are watched from the moment it opens: found at the next poll instead, a file
+	# written in between was first seen already changed, and its change was never reloaded.
+	var opening: int = scene_changed.connect(_on_scene_changed)
+	if opening != OK:
+		push_error("gdharness: could not start watching the scenes the editor opens")
 	add_child(_timer)
 	_timer.start()
 	_update_watched_files()
@@ -33,12 +55,16 @@ func _exit_tree() -> void:
 		_timer.queue_free()
 
 
+func _on_scene_changed(_scene_root: Node) -> void:
+	_update_watched_files()
+
+
 func _update_watched_files() -> void:
 	var edited_scene: Node = EditorInterface.get_edited_scene_root()
 	if edited_scene and edited_scene.scene_file_path:
 		var path: String = edited_scene.scene_file_path
 		if not _watched_files.has(path):
-			_watched_files[path] = _get_modified_time(path)
+			_watched_files[path] = _seen(path)
 		_watch_node_scripts(edited_scene)
 
 
@@ -48,11 +74,15 @@ func _watch_node_scripts(node: Node) -> void:
 		var attached: Script = script
 		var path: String = attached.resource_path
 		if not path.is_empty() and not _watched_files.has(path):
-			_watched_files[path] = _get_modified_time(path)
+			_watched_files[path] = _seen(path)
 	for child: Node in node.get_children():
 		_watch_node_scripts(child)
 
 
+func _seen(path: String) -> GdhSeen:
+	return GdhSeen.new(_get_modified_time(path), _md5_of(path))
+
+
 func _get_modified_time(path: String) -> int:
 	var global_path: String = ProjectSettings.globalize_path(path)
 	if FileAccess.file_exists(global_path):
@@ -60,20 +90,32 @@ func _get_modified_time(path: String) -> int:
 	return 0
 
 
+func _md5_of(path: String) -> String:
+	var global_path: String = ProjectSettings.globalize_path(path)
+	if FileAccess.file_exists(global_path):
+		return FileAccess.get_md5(global_path)
+	return ""
+
+
 func _check_for_changes() -> void:
 	_update_watched_files()
 
+	var now: int = int(Time.get_unix_time_from_system())
 	var scenes_to_reload: Array[String] = []
 	var scripts_to_reload: Array[String] = []
 	for path: String in _watched_files.keys():
+		var last: GdhSeen = _watched_files[path]
 		var current_time: int = _get_modified_time(path)
-		var last_time: int = _watched_files[path]
-		if current_time > last_time:
-			if path.ends_with(".gd"):
-				scripts_to_reload.append(path)
-			else:
-				scenes_to_reload.append(path)
-			_watched_files[path] = current_time
+		if current_time == last.time and now - current_time >= SAME_SECOND_SECONDS:
+			continue
+		var current_md5: String = _md5_of(path)
+		_watched_files[path] = GdhSeen.new(current_time, current_md5)
+		if current_md5 == last.md5:
+			continue
+		if path.ends_with(".gd"):
+			scripts_to_reload.append(path)
+		else:
+			scenes_to_reload.append(path)
 
 	# Scripts first, so a scene reloaded after them instantiates the new code.
 	for path: String in scripts_to_reload:

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

@@ -85,16 +85,19 @@ static func button_event(
 ## [param answer], saying so when one of [param points] lies outside [param viewport]: the GUI picks
 ## what is under the pointer only inside it, so such a press or motion reaches no control, and its
 ## answer read the same as one that landed.
+##
+## The points are window pixels and the visible rect is canvas units, which differ by the window's
+## content scale and any letterbox offset, so the rect is taken into window pixels first.
 static func outside_noted(answer: Dictionary, viewport: Viewport, points: Array[Vector2]) -> Dictionary:
-	var shown: Rect2 = viewport.get_visible_rect()
+	var shown: Rect2 = viewport.get_final_transform() * viewport.get_visible_rect()
 	for point: Vector2 in points:
 		if not shown.has_point(point):
 			answer["outside_viewport"] = (
 				(
-					"%s is outside the window's viewport, %s, so no control there receives it; the game's"
+					"%s is outside the window's viewport, %s in window pixels, so no control there receives"
 					% [point, shown]
 				)
-				+ " _input and _unhandled_input still do."
+				+ " it; the game's _input and _unhandled_input still do."
 			)
 			break
 	return answer

package/package.json

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