gdharness 1.1.4 → 1.1.5

package/build/cli.js

@@ -41827,6 +41827,7 @@ class GodotServer {
     const ghosts = blind.stillHeld ?? [];
     let waitedForEditorMs = 0;
     let first;
+    let completedBefore;
     for (;; ) {
       const busySince = Date.now();
       let wasBusy = false;
@@ -41841,8 +41842,9 @@ class GodotServer {
       if (first.isError) {
         return first;
       }
-      const declined = asParams(JSON.parse(first.content[0]?.text ?? "{}"))["started"] === false;
-      if (!declined || Date.now() - started >= timeoutMs) {
+      const firstAnswer = asParams(JSON.parse(first.content[0]?.text ?? "{}"));
+      completedBefore = readNumber(firstAnswer, "scansCompletedBefore");
+      if (firstAnswer["started"] !== false || Date.now() - started >= timeoutMs) {
         break;
       }
       await new Promise((settle) => setTimeout(settle, 100));
@@ -41853,7 +41855,9 @@ class GodotServer {
       await new Promise((settle) => setTimeout(settle, 100));
       const status = asParams(await this.godotBridge.invokeTool("rescan_filesystem", { ...args, statusOnly: true }));
       const pending = Boolean(status["pending"]) && Date.now() - started < SCAN_START_MS;
-      busy = Boolean(status["scanning"]) || Boolean(status["importing"]) || pending;
+      const completed = readNumber(status, "scansCompleted");
+      const notYetOver = completedBefore !== undefined && completed !== undefined && completed <= completedBefore;
+      busy = Boolean(status["scanning"]) || Boolean(status["importing"]) || pending || notYetOver;
       if (busy) {
         idleSince = null;
       } else {

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

@@ -11,12 +11,14 @@ var _editor_plugin: EditorPlugin = null
 var _values: Serialisation = Serialisation.new()
 var _properties: PropertyValues = PropertyValues.new()
 
-## How many times the editor has said its filesystem changed, which a scan run on the main thread
-## does before `scan()` returns: counted so a rescan can tell a scan that ran there from one the
-## editor declined.
-var _scans_finished: int = 0
-
-## When the last scan finished, on the engine's clock, or -1 before the first. The editor writes
+## How many scans the editor has completed, counted off `sources_changed`, which it emits at the end
+## of every scan once the reimport the scan found is done: the one moment a scan is over. Neither
+## flag it offers says so. A threaded scan stops reporting itself when its thread finishes, and its
+## import runs a frame or more later when the thread is joined; an editor in the background took
+## long enough over that frame that a rescan answered before the import of 211 changed scenes began.
+var _scans_completed: int = 0
+
+## When the last scan completed, on the engine's clock, or -1 before the first. The editor writes
 ## the class cache a frame after it stops reporting a scan, measured on 4.7.2, so a game started
 ## in between reads a file being rewritten; how long ago the scan ended is what tells a caller
 ## whether that write can still be coming.
@@ -26,14 +28,14 @@ var _scan_finished_at_msec: int = -1
 func set_editor_plugin(plugin: EditorPlugin) -> void:
 	_editor_plugin = plugin
 	var filesystem: EditorFileSystem = EditorInterface.get_resource_filesystem()
-	if not filesystem.filesystem_changed.is_connected(_scan_finished):
-		var watched: int = filesystem.filesystem_changed.connect(_scan_finished)
+	if not filesystem.sources_changed.is_connected(_scan_completed):
+		var watched: int = filesystem.sources_changed.connect(_scan_completed)
 		if watched != OK:
-			push_error("gdharness could not watch for finished scans: %d" % watched)
+			push_error("gdharness could not watch for completed scans: %d" % watched)
 
 
-func _scan_finished() -> void:
-	_scans_finished += 1
+func _scan_completed(_sources_exist: bool) -> void:
+	_scans_completed += 1
 	_scan_finished_at_msec = Time.get_ticks_msec()
 
 
@@ -658,8 +660,8 @@ func rescan_filesystem(args: Dictionary) -> Dictionary:
 	# conditions from its progress dialog. Declined and said, so the caller waits and asks again.
 	var busy: bool = filesystem.is_scanning() or filesystem.is_importing()
 	var started: bool = false
+	var completed_before: int = _scans_completed
 	if not Read.as_bool(args.get("statusOnly", false)) and not busy:
-		var finished_before: int = _scans_finished
 		filesystem.scan()
 		# Whether the scan ran, read off the editor rather than assumed. `scan()` returns without
 		# a word while the thread of the scan before is still to be joined, which is a frame or
@@ -668,16 +670,19 @@ func rescan_filesystem(args: Dictionary) -> Dictionary:
 		# downstream, a rescan after 698 files were rewritten answered finished in 1.5s and the
 		# one changed file stayed on its old import. A threaded scan reports itself from inside
 		# the call, and one run on this thread has finished and signalled before it returns.
-		started = filesystem.is_scanning() or _scans_finished != finished_before
+		started = filesystem.is_scanning() or _scans_completed != completed_before
 
 	# Importing is reported separately from scanning, and a class is not registered until
-	# both are done, so a caller watching only one of them can look too early.
+	# both are done, so a caller watching only one of them can look too early. The two counts are
+	# what a caller waits on: the scan it asked for is over once the count has moved past the one
+	# from before it was asked.
 	return {
 		"ok": true,
 		"started": started,
 		"scanning": filesystem.is_scanning(),
 		"importing": filesystem.is_importing(),
-		"scansFinished": _scans_finished,
+		"scansCompletedBefore": completed_before,
+		"scansCompleted": _scans_completed,
 	}
 
 

package/build/godot/operations/import_pipeline.gd

@@ -8,6 +8,11 @@ const IMPORTABLE_EXTENSIONS: Array[String] = [
 	"png", "jpg", "jpeg", "webp", "svg", "wav", "mp3", "ogg", "ttf", "otf", "glb", "gltf", "fbx", "obj"
 ]
 
+## How many resources a scene's dependencies are followed through before the walk stops: a scene's
+## materials and what they use are a handful, and a project that references its way around a cycle
+## is not walked for ever.
+const DEPENDENCY_WALK_LIMIT: int = 200
+
 var _log: Log
 var _files: FileWalk = FileWalk.new()
 
@@ -416,12 +421,18 @@ func _import_status_of(resource_path: String, import_file_path: String) -> Dicti
 	# before the image was is built without it. Read off what the imported scene depends on, not off
 	# file times: a texture a 3D scene uses is reimported compressed after the scene, so its outputs
 	# are always the newer, and 33 correct scenes read as stale when judged that way.
+	#
+	# Followed through the resources the scene depends on, since a post-import script that swaps each
+	# material for a saved one leaves the scene depending on the material and only the material on
+	# the image: 211 correct scenes read as stale when only the scene's own list was read. And not
+	# held against a scene an import script shaped at all, since the script may replace a material
+	# with one using other images entirely, which is the scene it was meant to build.
 	var without: Array[String] = []
 	var images: Array[String] = _images_of(resource_path)
-	if not images.is_empty():
-		var depended: PackedStringArray = ResourceLoader.get_dependencies(resource_path)
+	if not images.is_empty() and not _shaped_by_a_script(import_file_path):
+		var depended: Dictionary[String, bool] = _depended_on(resource_path)
 		for image: String in images:
-			if FileAccess.file_exists(image + ".import") and not _names(depended, image):
+			if FileAccess.file_exists(image + ".import") and not depended.has(image):
 				without.append(image)
 	if not without.is_empty():
 		status["status"] = "needs_reimport"
@@ -442,13 +453,38 @@ static func _recorded_source_md5(resource_path: String) -> String:
 	return str(config.get_value("", "source_md5", ""))
 
 
-## Whether [param dependencies], as [method ResourceLoader.get_dependencies] lists them, include
-## [param path]; each entry may carry a uid and a type ahead of the path.
-static func _names(dependencies: PackedStringArray, path: String) -> bool:
-	for entry: String in dependencies:
-		if entry == path or entry.ends_with("::" + path):
-			return true
-	return false
+## The path of one entry [method ResourceLoader.get_dependencies] lists, past any uid and type.
+static func _path_of(entry: String) -> String:
+	var at: int = entry.rfind("::")
+	return entry if at < 0 else entry.substr(at + 2)
+
+
+## Every path [param resource_path] depends on, through the resources it depends on in turn, as far
+## as [constant DEPENDENCY_WALK_LIMIT] resources; a set, keyed by path.
+static func _depended_on(resource_path: String) -> Dictionary[String, bool]:
+	var found: Dictionary[String, bool] = {}
+	var pending: Array[String] = [resource_path]
+	var walked: int = 0
+	while not pending.is_empty() and walked < DEPENDENCY_WALK_LIMIT:
+		var next: String = pending.pop_back()
+		walked += 1
+		for entry: String in ResourceLoader.get_dependencies(next):
+			var path: String = _path_of(entry)
+			if found.has(path):
+				continue
+			found[path] = true
+			# Only what can hold further references: an image or a sound depends on nothing.
+			if path.get_extension().to_lower() in ["tres", "res", "tscn", "scn", "material"]:
+				pending.append(path)
+	return found
+
+
+## Whether the import of the file [param import_file_path] describes runs a post-import script.
+static func _shaped_by_a_script(import_file_path: String) -> bool:
+	var config: ConfigFile = ConfigFile.new()
+	if config.load(import_file_path) != OK:
+		return false
+	return not str(config.get_value("params", "import_script/path", "")).is_empty()
 
 
 ## The files an import wrote, from its sidecar's [code]dest_files[/code]; empty when it lists none.

package/build/index.js

@@ -34566,6 +34566,7 @@ class GodotServer {
     const ghosts = blind.stillHeld ?? [];
     let waitedForEditorMs = 0;
     let first;
+    let completedBefore;
     for (;; ) {
       const busySince = Date.now();
       let wasBusy = false;
@@ -34580,8 +34581,9 @@ class GodotServer {
       if (first.isError) {
         return first;
       }
-      const declined = asParams(JSON.parse(first.content[0]?.text ?? "{}"))["started"] === false;
-      if (!declined || Date.now() - started >= timeoutMs) {
+      const firstAnswer = asParams(JSON.parse(first.content[0]?.text ?? "{}"));
+      completedBefore = readNumber(firstAnswer, "scansCompletedBefore");
+      if (firstAnswer["started"] !== false || Date.now() - started >= timeoutMs) {
         break;
       }
       await new Promise((settle) => setTimeout(settle, 100));
@@ -34592,7 +34594,9 @@ class GodotServer {
       await new Promise((settle) => setTimeout(settle, 100));
       const status = asParams(await this.godotBridge.invokeTool("rescan_filesystem", { ...args, statusOnly: true }));
       const pending = Boolean(status["pending"]) && Date.now() - started < SCAN_START_MS;
-      busy = Boolean(status["scanning"]) || Boolean(status["importing"]) || pending;
+      const completed = readNumber(status, "scansCompleted");
+      const notYetOver = completedBefore !== undefined && completed !== undefined && completed <= completedBefore;
+      busy = Boolean(status["scanning"]) || Boolean(status["importing"]) || pending || notYetOver;
       if (busy) {
         idleSince = null;
       } else {

package/package.json

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