gdharness 1.1.1 → 1.1.3

package/build/cli.js

@@ -15992,7 +15992,7 @@ var init_tool_definitions = __esm(() => {
       requires: ["projectPath"],
       operations: {
         status: {
-          summary: "which resources are outdated or failed, or one resource with resourcePath",
+          summary: "which resources are outdated or failed, or one resource with resourcePath: a source changed since its import, an import whose output under .godot/imported is gone (missing_outputs), and a glTF scene imported before the images it uses (imported_before), each with its reason",
           requires: []
         },
         options: { summary: "the import options of one resource", requires: ["resourcePath"] },
@@ -41842,13 +41842,23 @@ class GodotServer {
       if (!declined || Date.now() - started >= timeoutMs) {
         break;
       }
+      await new Promise((settle) => setTimeout(settle, 100));
     }
     let busy = true;
-    while (busy && Date.now() - started < timeoutMs) {
+    let idleSince = null;
+    while (Date.now() - started < timeoutMs) {
       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;
+      if (busy) {
+        idleSince = null;
+      } else {
+        idleSince ??= Date.now();
+        if (Date.now() - idleSince >= SCAN_SETTLED_MS) {
+          break;
+        }
+      }
     }
     if (!busy && projectPath !== "" && (atRisk.length > 0 || ghosts.length > 0 || blind.unchecked !== undefined)) {
       const until = Date.now() + CACHE_WRITE_MS;
@@ -42318,7 +42328,7 @@ async function runGodotServer() {
   const server = new GodotServer;
   await server.run();
 }
-var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, run7, __dirname2, EDITOR_RESTART_TIMEOUT_MS = 90000, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, PLAY_STARTS_WITHIN_MS = 30000, STOP_WAIT_MS = 1e4, EXIT_REPORTED_WITHIN_MS = 2000, CONSOLE_WRAPPER, LONGEST_BOOT_NOTED_MS, MOST_GROUPS = 20, VALUE_NAMES, BRIDGE_RETRY_MS = 2000, SUCCESSOR_CHECK_MS = 1e4, HANDOVER_MS, HANDOVER_POLL_MS = 250, CACHE_WRITE_MS = 2000, SCAN_WAIT_MS = 30000, PLAYING_STATUS_MS = 1000, SCAN_START_MS = 2000, WAIT_FOR_RUN_MS = 600000, RUN_POLL_MS = 250, PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, PROJECT_INFO_SECTIONS2, RUNNER_DIRECTORY = "addons/gdUnit4/";
+var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, run7, __dirname2, EDITOR_RESTART_TIMEOUT_MS = 90000, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, PLAY_STARTS_WITHIN_MS = 30000, STOP_WAIT_MS = 1e4, EXIT_REPORTED_WITHIN_MS = 2000, CONSOLE_WRAPPER, LONGEST_BOOT_NOTED_MS, MOST_GROUPS = 20, VALUE_NAMES, BRIDGE_RETRY_MS = 2000, SUCCESSOR_CHECK_MS = 1e4, HANDOVER_MS, HANDOVER_POLL_MS = 250, CACHE_WRITE_MS = 2000, SCAN_WAIT_MS = 30000, PLAYING_STATUS_MS = 1000, SCAN_START_MS = 2000, SCAN_SETTLED_MS = 500, WAIT_FOR_RUN_MS = 600000, RUN_POLL_MS = 250, PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, PROJECT_INFO_SECTIONS2, RUNNER_DIRECTORY = "addons/gdUnit4/";
 var init_server3 = __esm(() => {
   init_mcp();
   init_stdio2();

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

@@ -11,12 +11,10 @@ var _editor_plugin: EditorPlugin = null
 var _values: Serialisation = Serialisation.new()
 var _properties: PropertyValues = PropertyValues.new()
 
-## How many scans the editor has finished, counted off its own signal, and what the count was when
-## a scan was last asked for. A queued scan has not started, so the flags the engine offers read
-## the same as one that is over; the count is what tells the two apart.
+## 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
-var _scans_finished_at_request: int = 0
-var _scan_pending: bool = false
 
 ## When the last scan finished, 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
@@ -36,7 +34,6 @@ func set_editor_plugin(plugin: EditorPlugin) -> void:
 
 func _scan_finished() -> void:
 	_scans_finished += 1
-	_scan_pending = false
 	_scan_finished_at_msec = Time.get_ticks_msec()
 
 
@@ -662,31 +659,24 @@ func rescan_filesystem(args: Dictionary) -> Dictionary:
 	var busy: bool = filesystem.is_scanning() or filesystem.is_importing()
 	var started: bool = false
 	if not Read.as_bool(args.get("statusOnly", false)) and not busy:
-		_scans_finished_at_request = _scans_finished
-		_scan_pending = true
+		var finished_before: int = _scans_finished
 		filesystem.scan()
-		started = true
+		# 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
+		# more after that scan stops reporting itself, and that scan then signals as it is joined.
+		# Taken as started, the answer came from a scan begun before the files were written:
+		# 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
 
 	# 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.
-	#
-	# `pending` is the third state, and it is the one that was missing. A scan is queued rather
-	# than run, so for the first frames after asking, both flags are false and the editor has not
-	# started: a caller polling them reads "finished" off a scan that has not begun. Measured, a
-	# headless editor of 400 scripts takes 1619ms and answered honestly, while a downstream editor
-	# of 376 classes answered finished 296ms in and then wrote its own stale class list over the
-	# cache that had just been corrected. Whoever reads this is waiting for the scan to have
-	# landed, so "not yet" and "over" must not be spelled the same.
-	var scanning: bool = filesystem.is_scanning()
-	var importing: bool = filesystem.is_importing()
-	if scanning or importing or _scans_finished != _scans_finished_at_request:
-		_scan_pending = false
 	return {
 		"ok": true,
 		"started": started,
-		"scanning": scanning,
-		"importing": importing,
-		"pending": _scan_pending,
+		"scanning": filesystem.is_scanning(),
+		"importing": filesystem.is_importing(),
 		"scansFinished": _scans_finished,
 	}
 
@@ -704,7 +694,6 @@ func scan_status(_args: Dictionary) -> Dictionary:
 		"ok": true,
 		"scanning": filesystem.is_scanning(),
 		"importing": filesystem.is_importing(),
-		"pending": _scan_pending,
 		"sinceScanFinishedMs":
 		-1 if _scan_finished_at_msec < 0 else Time.get_ticks_msec() - _scan_finished_at_msec,
 	}

package/build/godot/operations/import_pipeline.gd

@@ -380,12 +380,106 @@ func _import_status_of(resource_path: String, import_file_path: String) -> Dicti
 			"source_exists": true
 		}
 
-	var source_modified: int = FileAccess.get_modified_time(resource_path)
-	var import_modified: int = FileAccess.get_modified_time(import_file_path)
-
-	return {
-		"path": resource_path,
-		"status": "needs_reimport" if source_modified > import_modified else "up_to_date",
-		"import_file_exists": true,
-		"source_exists": true
+	var status: Dictionary = {
+		"path": resource_path, "status": "up_to_date", "import_file_exists": true, "source_exists": true
 	}
+	if FileAccess.get_modified_time(resource_path) > FileAccess.get_modified_time(import_file_path):
+		status["status"] = "needs_reimport"
+		status["reason"] = "the source changed after it was imported"
+		return status
+
+	# The sidecar alone does not say the import is there: deleting the outputs under
+	# .godot/imported is the ordinary way to force one, and a resource whose output is gone was
+	# answered as current, which is what a reimport is then skipped on.
+	var outputs: Array[String] = _outputs_of(import_file_path)
+	var missing: Array[String] = []
+	for output: String in outputs:
+		if not FileAccess.file_exists(output):
+			missing.append(output)
+	if not missing.is_empty():
+		status["status"] = "needs_reimport"
+		status["reason"] = "its imported output is not on disk"
+		status["missing_outputs"] = missing
+		return status
+
+	# A scene imported before the textures it uses were: it loads each image as it imports, so one
+	# imported ahead of them is built without them, and nothing about its own files says so. A second
+	# reimport started over one in progress did exactly that downstream, and 64 scenes that were
+	# untextured all read as up to date here.
+	var built_at: int = _oldest(outputs, import_file_path)
+	var before: Array[String] = []
+	for image: String in _images_of(resource_path):
+		if FileAccess.file_exists(image + ".import"):
+			if _newest(_outputs_of(image + ".import"), image + ".import") > built_at:
+				before.append(image)
+	if not before.is_empty():
+		status["status"] = "needs_reimport"
+		status["reason"] = "it was imported before the images it uses, so it was built without them"
+		status["imported_before"] = before
+	return status
+
+
+## The files an import wrote, from its sidecar's [code]dest_files[/code]; empty when it lists none.
+static func _outputs_of(import_file_path: String) -> Array[String]:
+	var config: ConfigFile = ConfigFile.new()
+	var outputs: Array[String] = []
+	if config.load(import_file_path) != OK:
+		return outputs
+	var listed: Variant = config.get_value("deps", "dest_files", [])
+	if listed is Array:
+		for one: Variant in listed:
+			outputs.append(str(one))
+	return outputs
+
+
+## When the earliest of [param outputs] was written, or [param fallback] when none is on disk.
+static func _oldest(outputs: Array[String], fallback: String) -> int:
+	var oldest: int = -1
+	for output: String in outputs:
+		if FileAccess.file_exists(output):
+			var at: int = FileAccess.get_modified_time(output)
+			oldest = at if oldest < 0 else mini(oldest, at)
+	return oldest if oldest >= 0 else FileAccess.get_modified_time(fallback)
+
+
+## When the latest of [param outputs] was written, or [param fallback] when none is on disk.
+static func _newest(outputs: Array[String], fallback: String) -> int:
+	var newest: int = -1
+	for output: String in outputs:
+		if FileAccess.file_exists(output):
+			newest = maxi(newest, FileAccess.get_modified_time(output))
+	return newest if newest >= 0 else FileAccess.get_modified_time(fallback)
+
+
+## The image files a glTF scene refers to by path, resolved against the scene's own directory.
+## Embedded images and every other scene format answer nothing.
+static func _images_of(scene_path: String) -> Array[String]:
+	var images: Array[String] = []
+	var text: String = ""
+	match scene_path.get_extension().to_lower():
+		"gltf":
+			text = FileAccess.get_file_as_string(scene_path)
+		"glb":
+			# A 12-byte header, then the first chunk: its length, its type, and for "JSON" the text.
+			var bytes: PackedByteArray = FileAccess.get_file_as_bytes(scene_path)
+			if bytes.size() >= 20 and bytes.decode_u32(16) == 0x4E4F534A:
+				var length: int = bytes.decode_u32(12)
+				text = bytes.slice(20, mini(20 + length, bytes.size())).get_string_from_utf8()
+	if text.is_empty():
+		return images
+	var parsed: Variant = JSON.parse_string(text)
+	if not parsed is Dictionary:
+		return images
+	var document: Dictionary = parsed
+	var listed: Variant = document.get("images", [])
+	if not listed is Array:
+		return images
+	for image: Variant in listed:
+		if not image is Dictionary:
+			continue
+		var entry: Dictionary = image
+		var uri: String = str(entry.get("uri", ""))
+		if uri.is_empty() or uri.begins_with("data:"):
+			continue
+		images.append(scene_path.get_base_dir().path_join(uri.uri_decode()).simplify_path())
+	return images

package/build/index.js

@@ -30118,7 +30118,7 @@ var TOOL_SPECS = [
     requires: ["projectPath"],
     operations: {
       status: {
-        summary: "which resources are outdated or failed, or one resource with resourcePath",
+        summary: "which resources are outdated or failed, or one resource with resourcePath: a source changed since its import, an import whose output under .godot/imported is gone (missing_outputs), and a glTF scene imported before the images it uses (imported_before), each with its reason",
         requires: []
       },
       options: { summary: "the import options of one resource", requires: ["resourcePath"] },
@@ -31475,6 +31475,7 @@ function scanWaitAnswer(scanned) {
 }
 var PLAYING_STATUS_MS = 1000;
 var SCAN_START_MS = 2000;
+var SCAN_SETTLED_MS = 500;
 var WAIT_FOR_RUN_MS = 600000;
 var RUN_POLL_MS = 250;
 var PATH_SOLUTIONS = [
@@ -34579,13 +34580,23 @@ class GodotServer {
       if (!declined || Date.now() - started >= timeoutMs) {
         break;
       }
+      await new Promise((settle) => setTimeout(settle, 100));
     }
     let busy = true;
-    while (busy && Date.now() - started < timeoutMs) {
+    let idleSince = null;
+    while (Date.now() - started < timeoutMs) {
       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;
+      if (busy) {
+        idleSince = null;
+      } else {
+        idleSince ??= Date.now();
+        if (Date.now() - idleSince >= SCAN_SETTLED_MS) {
+          break;
+        }
+      }
     }
     if (!busy && projectPath !== "" && (atRisk.length > 0 || ghosts.length > 0 || blind.unchecked !== undefined)) {
       const until = Date.now() + CACHE_WRITE_MS;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdharness",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "mcpName": "io.github.Aureliolo/gdharness",
   "description": "A harness for driving a Godot 4 project from an agent: editor addons, a runtime bridge into the running game, an MCP server in front of them, and a CLI that installs and diagnoses the Godot side.",
   "type": "module",