gdharness 1.1.16 → 1.1.18

package/build/cli.js

@@ -8013,7 +8013,28 @@ function reason(stdout, stderr) {
   }
   return stdout.trim().split(/\r?\n/).at(-1) ?? "no output at all";
 }
-async function runImport(godotPath, projectPath) {
+function librariesNotCopied(messages) {
+  const found = new Set;
+  for (const entry of messages) {
+    const library = /Error copying library: (.+)$/.exec(entry.text)?.[1]?.trim();
+    if (library !== undefined && library !== "") {
+      found.add(library);
+    }
+  }
+  return [...found];
+}
+function extensionRetryNote(libraries) {
+  return `The first import could not load ${libraries.join(" and ")}: on Windows an engine running as the editor ` + "loads a GDExtension from a ~ copy beside the library, and the editor open on this project holds its own " + "copy there, so the first engine started beside it cannot make one. That failed attempt moves the " + "editor's copy aside, so the import was run again and loaded the extension, and the messages are from " + "that second run. The editor's copy is left beside the library as a ~RF….TMP file, which can be deleted " + "once the editor has exited.";
+}
+async function runImport(godotPath, projectPath, once = importOnce) {
+  const first = await once(godotPath, projectPath);
+  const collided = librariesNotCopied(first.messages);
+  if (collided.length === 0) {
+    return first;
+  }
+  return { ...await once(godotPath, projectPath), librariesRetried: collided };
+}
+async function importOnce(godotPath, projectPath) {
   const logDir = scratchDirectory("import");
   try {
     const { stderr } = await run3(godotPath, ["--headless", "--log-file", join6(logDir, "engine.log"), "--path", projectPath, "--import"], { signal: callSignal() });
@@ -8706,6 +8727,18 @@ function classRemedy(entries) {
   const reload = declaring.length === 1 ? `editor_rescan with reloadScript set to ${declaring[0]}` : `editor_rescan with reloadScript, a call each for ${declaring.join(" and ")} since it takes one script,`;
   return `For ${entries.map(written).join(", ")}, run ${reload} first. In the one project that has ` + "reproduced a stale enum member, twice, the reload cleared it at once both times, and the one " + "plain editor_rescan tried left the diagnostic standing.";
 }
+function failedReloadNote(failed) {
+  const missing = (before, after) => before.filter((name) => !after.includes(name));
+  const lost = [
+    ...missing(failed.heldBefore, failed.heldAfter),
+    ...missing(failed.constantsBefore, failed.constantsAfter)
+  ];
+  const unchanged = lost.length === 0 && missing(failed.heldAfter, failed.heldBefore).length === 0 && missing(failed.constantsAfter, failed.constantsBefore).length === 0;
+  const answered = failed.codeName === "" ? `error ${failed.code}` : `error ${failed.code}, ${failed.codeName}`;
+  const copy = unchanged ? "The copy the editor holds is as it was, with the members under heldBeforeReload and heldConstantsBeforeReload." : `The copy the editor holds changed even so${lost.length === 0 ? "" : `, and has lost ${lost.join(", ")}`}: anything diagnosed against it now is answered from what is left, and reloading it once it compiles rebuilds it.`;
+  const order = failed.names.length === 0 ? "" : ` If they deny a member of ${failed.names.join(" or ")} that its file declares, the editor's copy of that class is behind: reload that class first with reloadScript and then this script, the order that cleared it in the one project that has met this.`;
+  return `${failed.script} did not compile, so nothing was reloaded: Godot answered ${answered}. ${copy} ` + `script_diagnostics on it gives the errors.${order}`;
+}
 function uncachedClassNote(types) {
   if (types.length === 0) {
     return "";
@@ -17331,7 +17364,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "editor_rescan",
-      description: "Makes the running editor scan the project filesystem, so files written outside it are picked up. A scan or an import the editor is already running is waited out first rather than scanned over, which would start a second import over it, and the answer says how long under waitedForEditorScanMs. The scan is a change-detecting walk rather than an unconditional reparse, so a file another engine has already imported reads as settled and the walk does not look inside it: its class_name then stays out of the list the editor resolves against, however many times you scan. Any class in that state is named under unseenByEditor, which is what no check on disk can see, since the declaration and the cache are both correct there and only the editor disagrees. The cure is this call on its own, with no change to the declaring script: measured against a real editor on three platforms, with idle waits of the same length ruled out so the scan is credited rather than the time it takes, and reproduced in a second project against its own reproduction in 203ms. editor_launch restart also does it and costs a window, and project_import refresh_classes does not: it rewrites the cache and does not touch what the editor is holding. A class the scan brings in is named under broughtIn, and every script naming it is reloaded in the editor and named under dependentsReloaded: what the editor compiled from them while it could not see the class stays compiled that way after the scan, and a script extending a new base class went on reporting \"Could not find base class\" until reloaded. One that would not reload is named under dependentsNotReloaded and the call is not ok. A scan writes .godot/global_script_class_cache.cfg from the list the editor is holding, so a class the editor cannot resolve goes out of that file with it. That is not a reason to refuse the scan, because on a class the editor has merely not walked yet the scan is the cure; what the answer does instead is name the loss under cacheLost and rebuild the cache from the files, naming what came back under cacheRestored, so no fresh engine, CI run or clone inherits the short file. An editor that lost classes is still holding the short list, so the note says to restart it before scanning again. The other direction is guarded the same way: a class the editor still holds for a script that was renamed or deleted comes back into the cache at a path that is not there, and the next engine to read it fails on \"Could not parse global class\" in whichever correct script shares the bare name, so the cache is rebuilt without it and the answer names it under cacheDropped; the editor goes on holding it until it is restarted, and every scan until then ends in that rebuild. A script or shader written outside the editor has no .uid sidecar until something imports it, and the scan writes one beside it, which a project that commits sidecars needs before the commit. Needs the editor connected.",
+      description: "Makes the running editor scan the project filesystem, so files written outside it are picked up. A scan or an import the editor is already running is waited out first rather than scanned over, which would start a second import over it, and the answer says how long under waitedForEditorScanMs. The scan is a change-detecting walk rather than an unconditional reparse, so a file another engine has already imported reads as settled and the walk does not look inside it: its class_name then stays out of the list the editor resolves against, however many times you scan. Any class in that state is named under unseenByEditor, which is what no check on disk can see, since the declaration and the cache are both correct there and only the editor disagrees. The cure is this call on its own, with no change to the declaring script: measured against a real editor on three platforms, with idle waits of the same length ruled out so the scan is credited rather than the time it takes, and reproduced in a second project against its own reproduction in 203ms. editor_launch restart also does it and costs a window, and project_import refresh_classes does not: it rewrites the cache and does not touch what the editor is holding. The walk also passes over a file whose .uid alone changed, so the editor keeps the old UID and every engine reading its cache warns of a duplicate; before scanning, each file whose .uid names a UID the editor does not hold for it is read again and named under uidsReread, and files on disk naming one UID between them are named under uidsDuplicatedOnDisk, which reading again cannot settle. A class the scan brings in is named under broughtIn, and every script naming it is reloaded in the editor and named under dependentsReloaded: what the editor compiled from them while it could not see the class stays compiled that way after the scan, and a script extending a new base class went on reporting \"Could not find base class\" until reloaded. One that would not reload is named under dependentsNotReloaded and the call is not ok, as it is not when the script named in reloadScript was not reloaded. A scan writes .godot/global_script_class_cache.cfg from the list the editor is holding, so a class the editor cannot resolve goes out of that file with it. That is not a reason to refuse the scan, because on a class the editor has merely not walked yet the scan is the cure; what the answer does instead is name the loss under cacheLost and rebuild the cache from the files, naming what came back under cacheRestored, so no fresh engine, CI run or clone inherits the short file. An editor that lost classes is still holding the short list, so the note says to restart it before scanning again. The other direction is guarded the same way: a class the editor still holds for a script that was renamed or deleted comes back into the cache at a path that is not there, and the next engine to read it fails on \"Could not parse global class\" in whichever correct script shares the bare name, so the cache is rebuilt without it and the answer names it under cacheDropped; the editor goes on holding it until it is restarted, and every scan until then ends in that rebuild. A script or shader written outside the editor has no .uid sidecar until something imports it, and the scan writes one beside it, which a project that commits sidecars needs before the commit. Needs the editor connected.",
       parameters: {
         projectPath: PROJECT_PATH,
         timeoutMs: {
@@ -17341,7 +17374,7 @@ var init_tool_definitions = __esm(() => {
         },
         reloadScript: {
           type: "string",
-          description: "A script to recompile in the editor after the scan, for the half a scan does not reach: a script the editor has loaded keeps the copy it built, that copy is refreshed when one of its dependencies changes rather than when it changes itself, and a scan leaves it alone. Measured here, a built copy comes back without a method added to it while script_diagnostics on the same script reads clean in the same window, so the copy the editor built and whatever the analyser resolves types against are not known to be one thing: reload for the copy, and read the diagnostics as a separate answer rather than as this one confirmed. This recompiles into the same object, so the holders that kept the stale copy alive see the new one. The methods it has afterwards come back under reloadedMethods, because a reload that compiled nothing and answered OK is the failure worth catching, and what it held before under heldBeforeReload. Its constants come back the same way, under heldConstantsBeforeReload and reloadedConstants, with each enum value as Kind.SHORT: an enum member is held as a constant and never shows among the methods."
+          description: "A script to recompile in the editor after the scan, for the half a scan does not reach: a script the editor has loaded keeps the copy it built, that copy is refreshed when one of its dependencies changes rather than when it changes itself, and a scan leaves it alone. Measured here, a built copy comes back without a method added to it while script_diagnostics on the same script reads clean in the same window, so the copy the editor built and whatever the analyser resolves types against are not known to be one thing: reload for the copy, and read the diagnostics as a separate answer rather than as this one confirmed. This recompiles into the same object, so the holders that kept the stale copy alive see the new one. The methods it has afterwards come back under reloadedMethods, because a reload that compiled nothing and answered OK is the failure worth catching, and what it held before under heldBeforeReload. Its constants come back the same way, under heldConstantsBeforeReload and reloadedConstants, with each enum value as Kind.SHORT: an enum member is held as a constant and never shows among the methods. A script that does not compile is not reloaded: reloadProblem gives Godot's error, says whether the copy the editor holds survived, and names the classes the file uses, whose held copies being behind is what failed one before."
         }
       },
       requires: ["projectPath"]
@@ -17499,7 +17532,7 @@ var init_tool_definitions = __esm(() => {
         property: {
           type: "string",
           ops: ["set"],
-          description: 'set: which one to write. Colons write through what a node holds, "_game:run:day", and a number or a key steps into a list or a map on the way, "_game:run:roster:0:name", a negative number counting from the end, and a step written as a call, "get_viewport():gui_embed_subwindows", walks through what a method taking no arguments returned. The answer reads back off the same holder, and a write that leaves the property as it was, because the engine would not take it, is refused and says what the property still holds.'
+          description: 'set: which one to write. Colons write through what a node holds, "_game:run:day", and a number or a key steps into a list or a map on the way, "_game:run:roster:0:name", a negative number counting from the end, and a step written as a call, "get_viewport():gui_embed_subwindows", walks through what a method taking no arguments returned. The answer reads back off the same holder, and a write that leaves the property as it was, because the engine would not take it, is refused and says what the property still holds. A write of the value the property already holds, at its own precision, as a float given in 64 bits to a property keeping 32, is not refused: it answers unchanged: true.'
         },
         value: {
           ops: ["set"],
@@ -17719,7 +17752,10 @@ var init_tool_definitions = __esm(() => {
           ops: ["until"],
           description: 'until: the property name, or a colon path through what the node holds, "_game:run:day", read the way runtime_inspect property reads one, a step written as a call included. Walked again on every frame, so a holder the game replaces while the wait is on is followed.'
         },
-        value: { ops: ["until"], description: "until: the value to wait for, fitted to the property's type." },
+        value: {
+          ops: ["until"],
+          description: "until: the value to wait for, fitted to the property's type. On a property declared to hold an object, null, which the text null also means; any other value is refused, since the property can never hold it."
+        },
         says: {
           type: "string",
           ops: ["until"],
@@ -40613,7 +40649,8 @@ class GodotServer {
       payload: {
         uidsCreated: given,
         stillWithoutUid: after,
-        note: uidsLeftNote(after.length)
+        note: uidsLeftNote(after.length),
+        ...imported.librariesRetried === undefined ? {} : { extensionNote: extensionRetryNote(imported.librariesRetried) }
       }
     }, scanned));
   }
@@ -40769,6 +40806,9 @@ class GodotServer {
       if (imported.messages.length > 0) {
         extra["engine_messages"] = imported.messages;
       }
+      if (imported.librariesRetried !== undefined) {
+        extra["extensionNote"] = extensionRetryNote(imported.librariesRetried);
+      }
     }
     const after = await this.operation("get_import_status", resourcePath === undefined ? { includeUpToDate: true } : { resourcePath }, projectPath);
     if (!after.ok) {
@@ -41297,6 +41337,11 @@ class GodotServer {
       shortListEditorPid: this.godotBridge.getStatus().editorPid ?? null
     });
   }
+  classesAScriptNames(projectPath, scriptPath) {
+    const source = this.sourceOfClass(projectPath, scriptPath);
+    const known = cachedClasses(projectPath) ?? declaredClasses(projectPath);
+    return source === null ? [] : classesNamedIn(source, known).filter((name) => known.get(name) !== scriptPath);
+  }
   sourceOfClass(projectPath, resourcePath) {
     const contained = resolveWithinProject(projectPath, resourcePath);
     if (!contained.ok || !existsSync15(contained.absolutePath)) {
@@ -42962,6 +43007,8 @@ class GodotServer {
     let waitedForEditorMs = 0;
     let first;
     let completedBefore;
+    let uidsReread = [];
+    let uidsDuplicatedOnDisk = [];
     for (;; ) {
       const busySince = Date.now();
       let wasBusy = false;
@@ -42978,6 +43025,11 @@ class GodotServer {
       }
       const firstAnswer = asParams(JSON.parse(first.content[0]?.text ?? "{}"));
       completedBefore = readNumber(firstAnswer, "scansCompletedBefore");
+      uidsReread = [...uidsReread, ...(readArray(firstAnswer, "uidsReread") ?? []).map(String)];
+      const duplicated = readArray(firstAnswer, "uidsDuplicatedOnDisk");
+      if (duplicated !== undefined) {
+        uidsDuplicatedOnDisk = duplicated.map((group) => Array.isArray(group) ? group.map(String) : []);
+      }
       if (firstAnswer["started"] !== false || Date.now() - started >= timeoutMs) {
         break;
       }
@@ -43027,12 +43079,30 @@ class GodotServer {
           const found = readArray(answer, field);
           return found ? { [field]: found.map(String) } : {};
         };
-        reloaded = methods ? {
-          methods: methods.map(String),
-          ...listed("heldBefore"),
-          ...listed("constants"),
-          ...listed("heldConstantsBefore")
-        } : { problem: `the editor would not say what ${reloading} has after reloading it` };
+        const failed = answer["failed"];
+        if (typeof failed === "number" && failed !== 0) {
+          reloaded = {
+            ...listed("heldBefore"),
+            ...listed("heldConstantsBefore"),
+            problem: failedReloadNote({
+              script: reloading,
+              code: failed,
+              codeName: readString(answer, "failedAs") ?? "",
+              heldBefore: listed("heldBefore")["heldBefore"] ?? [],
+              heldAfter: methods?.map(String) ?? [],
+              constantsBefore: listed("heldConstantsBefore")["heldConstantsBefore"] ?? [],
+              constantsAfter: listed("constants")["constants"] ?? [],
+              names: projectPath === "" ? [] : this.classesAScriptNames(projectPath, reloading)
+            })
+          };
+        } else {
+          reloaded = methods ? {
+            methods: methods.map(String),
+            ...listed("heldBefore"),
+            ...listed("constants"),
+            ...listed("heldConstantsBefore")
+          } : { problem: `the editor would not say what ${reloading} has after reloading it` };
+        }
       } catch (error) {
         reloaded = { problem: `${reloading} could not be reloaded: ${errorMessage(error)}` };
       }
@@ -43055,13 +43125,16 @@ class GodotServer {
     if (dependents !== null && dependents.notReloaded.length > 0) {
       notes.push(`The scan brought in ${broughtIn.join(", ")}, and ${dependents.notReloaded.map((one) => one.scriptPath).join(", ")} ${dependents.notReloaded.length === 1 ? "names one of them and" : "name them and"} could not be reloaded, so the editor still holds what it compiled while it could not see the class and reports that to the language server. editor_rescan with reloadScript on each, or editor_launch restart.`);
     }
+    for (const group of uidsDuplicatedOnDisk) {
+      notes.push(`${group.join(" and ")} name one UID in their .uid files, so Godot keeps one path for it and every engine warns "UID duplicate detected". Delete the .uid of the one that is a copy and rescan: the editor writes it a UID of its own.`);
+    }
     if (stillAtMissingPaths.length > 0) {
       notes.push(`The scan wrote the class cache with ${stillAtMissingPaths.join(", ")} at a path that is not on disk, and rebuilding the cache from the files did not take it out. The next engine to read the cache fails on "Could not parse global class" in whichever correct script shares the bare name. Restart the editor with editor_launch restart, then run project_import refresh_classes.`);
     } else if (dropped.length > 0) {
       notes.push(`The scan wrote the class cache from the list this editor is holding, and that list still has ${dropped.join(", ")} for a script that is gone, so the cache was rebuilt from the files without it. The editor goes on holding it and writes it back on every scan until it is restarted with editor_launch restart; until then a scan is followed by this same rebuild.`);
     }
     return this.jsonTextResponse({
-      ok: !busy && unseen.length === 0 && stillGone.length === 0 && stillAtMissingPaths.length === 0 && (dependents === null || dependents.notReloaded.length === 0) && checked.unchecked === undefined,
+      ok: !busy && unseen.length === 0 && stillGone.length === 0 && stillAtMissingPaths.length === 0 && (dependents === null || dependents.notReloaded.length === 0) && reloaded.problem === undefined && checked.unchecked === undefined,
       stillWorking: busy,
       waitedMs: Date.now() - started,
       waitedForEditorScanMs: waitedForEditorMs > 0 ? waitedForEditorMs : undefined,
@@ -43079,6 +43152,8 @@ class GodotServer {
       cacheDropped: dropped.length > 0 ? dropped : undefined,
       cacheAtMissingPaths: stillAtMissingPaths.length > 0 ? stillAtMissingPaths : undefined,
       classesUnchecked: checked.unchecked,
+      uidsReread: uidsReread.length > 0 ? uidsReread : undefined,
+      uidsDuplicatedOnDisk: uidsDuplicatedOnDisk.length > 0 ? uidsDuplicatedOnDisk : undefined,
       note: notes.length > 0 ? notes.join(" ") : undefined
     });
   }
@@ -43095,7 +43170,13 @@ class GodotServer {
       }
       try {
         const answer = asParams(await this.godotBridge.invokeTool("reload_script", { scriptPath }));
-        if (readArray(answer, "methods") === undefined) {
+        const failed = answer["failed"];
+        if (typeof failed === "number" && failed !== 0) {
+          notReloaded.push({
+            scriptPath,
+            problem: `it did not compile: Godot answered error ${failed}${readString(answer, "failedAs") ? `, ${readString(answer, "failedAs")}` : ""}`
+          });
+        } else if (readArray(answer, "methods") === undefined) {
           notReloaded.push({
             scriptPath,
             problem: "the editor would not say what it has after reloading it"

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

@@ -74,16 +74,22 @@ func reload_script(args: Dictionary) -> Dictionary:
 	var reader: FileAccess = FileAccess.open(path, FileAccess.READ)
 	if reader == null:
 		return {"ok": false, "error": "Could not read " + path + ": " + str(FileAccess.get_open_error())}
+	var previous: String = script.source_code
 	script.source_code = reader.get_as_text()
 	reader.close()
 
+	# A reload that fails is still answered as a call that ran, because the readings are what a
+	# caller needs then: a failure travels back as its message alone, and a project met one and
+	# could not tell whether the copy had been damaged by it or before it. The old text goes back
+	# into the object, so what it holds and the source it says it was built from still agree.
 	var failed: Error = script.reload(true)
 	if failed != OK:
-		return {"ok": false, "error": "Reloading " + path + " answered error " + str(failed)}
-
+		script.source_code = previous
 	return {
 		"ok": true,
 		"script": path,
+		"failed": failed,
+		"failedAs": error_string(failed) if failed != OK else "",
 		"heldBefore": held,
 		"methods": _method_names(script),
 		"heldConstantsBefore": held_constants,

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

@@ -665,7 +665,9 @@ func rescan_filesystem(args: Dictionary) -> Dictionary:
 	var busy: bool = filesystem.is_scanning() or filesystem.is_importing()
 	var started: bool = false
 	var completed_before: int = _scans_completed
+	var uids: Dictionary = {"reread": [], "duplicated": []}
 	if not Read.as_bool(args.get("statusOnly", false)) and not busy:
+		uids = _reread_changed_uids(filesystem)
 		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
@@ -687,9 +689,65 @@ func rescan_filesystem(args: Dictionary) -> Dictionary:
 		"importing": filesystem.is_importing(),
 		"scansCompletedBefore": completed_before,
 		"scansCompleted": _scans_completed,
+		"uidsReread": uids["reread"],
+		"uidsDuplicatedOnDisk": uids["duplicated"],
 	}
 
 
+## Has the editor read again every file whose `.uid` names a UID the editor does not hold for it.
+##
+## The scan re-reads a file when the file changes and not when only the `.uid` beside it does, so a
+## script copied with its `.uid` and then given a fresh one keeps the copied UID in the editor, and
+## every headless engine reading the editor's cache warns of a duplicate. Measured on 4.7.2: a scan
+## after the `.uid` was rewritten left both scripts on one UID in the cache. What the editor holds
+## is read off its UID table, which maps each UID to one path, so a `.uid` whose UID is missing from
+## the table or mapped to another file is one the editor has not taken in.
+##
+## Two files on disk naming one UID are left alone and named: reading them again cannot settle
+## which of them owns it, and doing it on every scan would only move the UID between them.
+func _reread_changed_uids(filesystem: EditorFileSystem) -> Dictionary:
+	var sidecars: Array[String] = []
+	_uid_files("res://", sidecars)
+	var claimed: Dictionary = {}
+	for sidecar: String in sidecars:
+		var id: int = ResourceUID.text_to_id(FileAccess.get_file_as_string(sidecar).strip_edges())
+		var path: String = sidecar.trim_suffix(".uid")
+		if id == ResourceUID.INVALID_ID or not FileAccess.file_exists(path):
+			continue
+		var paths: Array = claimed.get_or_add(id, [])
+		paths.append(path)
+	var reread: Array[String] = []
+	var duplicated: Array[Array] = []
+	for id: int in claimed:
+		var paths: Array = claimed[id]
+		if paths.size() > 1:
+			paths.sort()
+			duplicated.append(paths)
+			continue
+		var path: String = str(paths[0])
+		if ResourceUID.has_id(id) and ResourceUID.get_id_path(id) == path:
+			continue
+		filesystem.update_file(path)
+		reread.append(path)
+	reread.sort()
+	duplicated.sort()
+	return {"reread": reread, "duplicated": duplicated}
+
+
+## Every `.uid` under [param directory], skipping what the editor skips: hidden directories and any
+## holding a `.gdignore`.
+func _uid_files(directory: String, found: Array[String]) -> void:
+	var listing: DirAccess = DirAccess.open(directory)
+	if listing == null or FileAccess.file_exists(directory.path_join(".gdignore")):
+		return
+	for child: String in listing.get_directories():
+		if not child.begins_with("."):
+			_uid_files(directory.path_join(child), found)
+	for file: String in listing.get_files():
+		if file.ends_with(".uid"):
+			found.append(directory.path_join(file))
+
+
 ## Whether the editor is scanning, and how long ago its last scan finished, without asking for one.
 ##
 ## For a caller about to start a game: the editor rewrites the class cache a frame after a scan

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

@@ -640,9 +640,12 @@ func set_property(params: Dictionary) -> Dictionary:
 	# the answer then showed the old value as the new one, shaped as a success: a typed container
 	# refusing a plain list did exactly that. A value the property changed on the way in, a setter
 	# clamping it, still changed it, so only a write that left the property as it was is refused.
+	# And only one that asked for a change: the value the property already held, written again, left
+	# it as it was because nothing was asked of it.
+	var already: bool = _held_already(given, old_value)
 	if (
 		Values.comparable(given, old_value)
-		and given != old_value
+		and not already
 		and Values.comparable(now, old_value)
 		and now == old_value
 	):
@@ -663,7 +666,7 @@ func set_property(params: Dictionary) -> Dictionary:
 			)
 		}
 
-	return {
+	var answer: Dictionary = {
 		"type": "property_set",
 		"path": node_path,
 		"property": property,
@@ -671,6 +674,27 @@ func set_property(params: Dictionary) -> Dictionary:
 		"new_value": _values.serialize(now),
 		"elapsed_usec": elapsed
 	}
+	if already and Values.comparable(now, old_value) and now == old_value:
+		answer["unchanged"] = true
+	return answer
+
+
+## Whether [param given] is the value [param held] already is, at the precision the property keeps.
+##
+## A float arrives as 64 bits and most engine properties keep 32: Camera3D.h_offset given -1.1
+## reads back as -1.10000002384186, so comparing the two exactly took a write of the value already
+## held for one the engine refused (#780). Rounding both to 32 bits is exact for a 32-bit property.
+## A 64-bit one can take a write this calls the same, and then reads back changed, which the caller
+## checks before calling the write unchanged. Vectors and colours hold 32-bit parts in the value
+## itself, so they already compare at the property's precision.
+static func _held_already(given: Variant, held: Variant) -> bool:
+	if not Values.comparable(given, held):
+		return false
+	if given == held:
+		return true
+	if typeof(given) != TYPE_FLOAT or typeof(held) != TYPE_FLOAT:
+		return false
+	return PackedFloat32Array([given])[0] == PackedFloat32Array([held])[0]
 
 
 func call_method(params: Dictionary) -> Dictionary:

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

@@ -140,7 +140,23 @@ func wait_until(params: Dictionary) -> Dictionary:
 
 	var current: Variant = watched["value"]
 	var wanted: Variant = _values.fitted(params["value"], typeof(current))
+	# Read against what the property is declared as, not only against what it holds this frame: an
+	# object property holding null holds nothing typed, so any value was taken as it came and compared
+	# with null until the time ran out. #772 waited a minute for "null" that way and answered met
+	# false with value null beside it.
+	var declared: int = watched["declared"]
+	if declared == TYPE_OBJECT and wanted is String and str(wanted).strip_edges() == "null":
+		wanted = null
 	var refused: String = _not_comparable(current, wanted, node_path, property)
+	var never_held: bool = typeof(wanted) != TYPE_NIL and typeof(wanted) != TYPE_OBJECT
+	if refused.is_empty() and declared == TYPE_OBJECT and never_held:
+		refused = (
+			(
+				"%s.%s is declared to hold an object and the value to wait for is %s, which it can"
+				+ " never hold: wait for null, or for the object's own value on a property of it."
+			)
+			% [node_path, property, type_string(typeof(wanted))]
+		)
 	if not refused.is_empty():
 		return {"type": "error", "message": refused}
 
@@ -224,7 +240,19 @@ static func _watched(node: Node, node_path: String, property: String) -> Diction
 	var missing: String = Paths.nothing_under(holder, named, str(reached["called"]))
 	if not missing.is_empty():
 		return {"type": "error", "message": missing}
-	return {"value": Paths.read_under(holder, named)}
+	return {"value": Paths.read_under(holder, named), "declared": _declared_type(holder, named)}
+
+
+## The type [param named] is declared with on [param holder], or TYPE_NIL for anything that declares
+## none: an untyped property, a step into a list or map, or a call.
+static func _declared_type(holder: Variant, named: String) -> int:
+	if typeof(holder) != TYPE_OBJECT or not Paths.method_of(named).is_empty():
+		return TYPE_NIL
+	var object: Object = holder
+	for entry: Dictionary in object.get_property_list():
+		if str(entry.get("name", "")) == named:
+			return Read.as_int(entry.get("type", TYPE_NIL), TYPE_NIL)
+	return TYPE_NIL
 
 
 ## Waits until something under [param node_path] has [param said] written on it.

package/build/index.js

@@ -26276,6 +26276,18 @@ function classRemedy(entries) {
   const reload = declaring.length === 1 ? `editor_rescan with reloadScript set to ${declaring[0]}` : `editor_rescan with reloadScript, a call each for ${declaring.join(" and ")} since it takes one script,`;
   return `For ${entries.map(written).join(", ")}, run ${reload} first. In the one project that has ` + "reproduced a stale enum member, twice, the reload cleared it at once both times, and the one " + "plain editor_rescan tried left the diagnostic standing.";
 }
+function failedReloadNote(failed) {
+  const missing = (before, after) => before.filter((name) => !after.includes(name));
+  const lost = [
+    ...missing(failed.heldBefore, failed.heldAfter),
+    ...missing(failed.constantsBefore, failed.constantsAfter)
+  ];
+  const unchanged = lost.length === 0 && missing(failed.heldAfter, failed.heldBefore).length === 0 && missing(failed.constantsAfter, failed.constantsBefore).length === 0;
+  const answered = failed.codeName === "" ? `error ${failed.code}` : `error ${failed.code}, ${failed.codeName}`;
+  const copy = unchanged ? "The copy the editor holds is as it was, with the members under heldBeforeReload and heldConstantsBeforeReload." : `The copy the editor holds changed even so${lost.length === 0 ? "" : `, and has lost ${lost.join(", ")}`}: anything diagnosed against it now is answered from what is left, and reloading it once it compiles rebuilds it.`;
+  const order = failed.names.length === 0 ? "" : ` If they deny a member of ${failed.names.join(" or ")} that its file declares, the editor's copy of that class is behind: reload that class first with reloadScript and then this script, the order that cleared it in the one project that has met this.`;
+  return `${failed.script} did not compile, so nothing was reloaded: Godot answered ${answered}. ${copy} ` + `script_diagnostics on it gives the errors.${order}`;
+}
 function uncachedClassNote(types) {
   if (types.length === 0) {
     return "";
@@ -28280,7 +28292,28 @@ function reason(stdout, stderr) {
   }
   return stdout.trim().split(/\r?\n/).at(-1) ?? "no output at all";
 }
-async function runImport(godotPath, projectPath) {
+function librariesNotCopied(messages) {
+  const found = new Set;
+  for (const entry of messages) {
+    const library = /Error copying library: (.+)$/.exec(entry.text)?.[1]?.trim();
+    if (library !== undefined && library !== "") {
+      found.add(library);
+    }
+  }
+  return [...found];
+}
+function extensionRetryNote(libraries) {
+  return `The first import could not load ${libraries.join(" and ")}: on Windows an engine running as the editor ` + "loads a GDExtension from a ~ copy beside the library, and the editor open on this project holds its own " + "copy there, so the first engine started beside it cannot make one. That failed attempt moves the " + "editor's copy aside, so the import was run again and loaded the extension, and the messages are from " + "that second run. The editor's copy is left beside the library as a ~RF….TMP file, which can be deleted " + "once the editor has exited.";
+}
+async function runImport(godotPath, projectPath, once = importOnce) {
+  const first = await once(godotPath, projectPath);
+  const collided = librariesNotCopied(first.messages);
+  if (collided.length === 0) {
+    return first;
+  }
+  return { ...await once(godotPath, projectPath), librariesRetried: collided };
+}
+async function importOnce(godotPath, projectPath) {
   const logDir = scratchDirectory("import");
   try {
     const { stderr } = await run3(godotPath, ["--headless", "--log-file", join12(logDir, "engine.log"), "--path", projectPath, "--import"], { signal: callSignal() });
@@ -30988,7 +31021,7 @@ var TOOL_SPECS = [
   },
   {
     name: "editor_rescan",
-    description: "Makes the running editor scan the project filesystem, so files written outside it are picked up. A scan or an import the editor is already running is waited out first rather than scanned over, which would start a second import over it, and the answer says how long under waitedForEditorScanMs. The scan is a change-detecting walk rather than an unconditional reparse, so a file another engine has already imported reads as settled and the walk does not look inside it: its class_name then stays out of the list the editor resolves against, however many times you scan. Any class in that state is named under unseenByEditor, which is what no check on disk can see, since the declaration and the cache are both correct there and only the editor disagrees. The cure is this call on its own, with no change to the declaring script: measured against a real editor on three platforms, with idle waits of the same length ruled out so the scan is credited rather than the time it takes, and reproduced in a second project against its own reproduction in 203ms. editor_launch restart also does it and costs a window, and project_import refresh_classes does not: it rewrites the cache and does not touch what the editor is holding. A class the scan brings in is named under broughtIn, and every script naming it is reloaded in the editor and named under dependentsReloaded: what the editor compiled from them while it could not see the class stays compiled that way after the scan, and a script extending a new base class went on reporting \"Could not find base class\" until reloaded. One that would not reload is named under dependentsNotReloaded and the call is not ok. A scan writes .godot/global_script_class_cache.cfg from the list the editor is holding, so a class the editor cannot resolve goes out of that file with it. That is not a reason to refuse the scan, because on a class the editor has merely not walked yet the scan is the cure; what the answer does instead is name the loss under cacheLost and rebuild the cache from the files, naming what came back under cacheRestored, so no fresh engine, CI run or clone inherits the short file. An editor that lost classes is still holding the short list, so the note says to restart it before scanning again. The other direction is guarded the same way: a class the editor still holds for a script that was renamed or deleted comes back into the cache at a path that is not there, and the next engine to read it fails on \"Could not parse global class\" in whichever correct script shares the bare name, so the cache is rebuilt without it and the answer names it under cacheDropped; the editor goes on holding it until it is restarted, and every scan until then ends in that rebuild. A script or shader written outside the editor has no .uid sidecar until something imports it, and the scan writes one beside it, which a project that commits sidecars needs before the commit. Needs the editor connected.",
+    description: "Makes the running editor scan the project filesystem, so files written outside it are picked up. A scan or an import the editor is already running is waited out first rather than scanned over, which would start a second import over it, and the answer says how long under waitedForEditorScanMs. The scan is a change-detecting walk rather than an unconditional reparse, so a file another engine has already imported reads as settled and the walk does not look inside it: its class_name then stays out of the list the editor resolves against, however many times you scan. Any class in that state is named under unseenByEditor, which is what no check on disk can see, since the declaration and the cache are both correct there and only the editor disagrees. The cure is this call on its own, with no change to the declaring script: measured against a real editor on three platforms, with idle waits of the same length ruled out so the scan is credited rather than the time it takes, and reproduced in a second project against its own reproduction in 203ms. editor_launch restart also does it and costs a window, and project_import refresh_classes does not: it rewrites the cache and does not touch what the editor is holding. The walk also passes over a file whose .uid alone changed, so the editor keeps the old UID and every engine reading its cache warns of a duplicate; before scanning, each file whose .uid names a UID the editor does not hold for it is read again and named under uidsReread, and files on disk naming one UID between them are named under uidsDuplicatedOnDisk, which reading again cannot settle. A class the scan brings in is named under broughtIn, and every script naming it is reloaded in the editor and named under dependentsReloaded: what the editor compiled from them while it could not see the class stays compiled that way after the scan, and a script extending a new base class went on reporting \"Could not find base class\" until reloaded. One that would not reload is named under dependentsNotReloaded and the call is not ok, as it is not when the script named in reloadScript was not reloaded. A scan writes .godot/global_script_class_cache.cfg from the list the editor is holding, so a class the editor cannot resolve goes out of that file with it. That is not a reason to refuse the scan, because on a class the editor has merely not walked yet the scan is the cure; what the answer does instead is name the loss under cacheLost and rebuild the cache from the files, naming what came back under cacheRestored, so no fresh engine, CI run or clone inherits the short file. An editor that lost classes is still holding the short list, so the note says to restart it before scanning again. The other direction is guarded the same way: a class the editor still holds for a script that was renamed or deleted comes back into the cache at a path that is not there, and the next engine to read it fails on \"Could not parse global class\" in whichever correct script shares the bare name, so the cache is rebuilt without it and the answer names it under cacheDropped; the editor goes on holding it until it is restarted, and every scan until then ends in that rebuild. A script or shader written outside the editor has no .uid sidecar until something imports it, and the scan writes one beside it, which a project that commits sidecars needs before the commit. Needs the editor connected.",
     parameters: {
       projectPath: PROJECT_PATH,
       timeoutMs: {
@@ -30998,7 +31031,7 @@ var TOOL_SPECS = [
       },
       reloadScript: {
         type: "string",
-        description: "A script to recompile in the editor after the scan, for the half a scan does not reach: a script the editor has loaded keeps the copy it built, that copy is refreshed when one of its dependencies changes rather than when it changes itself, and a scan leaves it alone. Measured here, a built copy comes back without a method added to it while script_diagnostics on the same script reads clean in the same window, so the copy the editor built and whatever the analyser resolves types against are not known to be one thing: reload for the copy, and read the diagnostics as a separate answer rather than as this one confirmed. This recompiles into the same object, so the holders that kept the stale copy alive see the new one. The methods it has afterwards come back under reloadedMethods, because a reload that compiled nothing and answered OK is the failure worth catching, and what it held before under heldBeforeReload. Its constants come back the same way, under heldConstantsBeforeReload and reloadedConstants, with each enum value as Kind.SHORT: an enum member is held as a constant and never shows among the methods."
+        description: "A script to recompile in the editor after the scan, for the half a scan does not reach: a script the editor has loaded keeps the copy it built, that copy is refreshed when one of its dependencies changes rather than when it changes itself, and a scan leaves it alone. Measured here, a built copy comes back without a method added to it while script_diagnostics on the same script reads clean in the same window, so the copy the editor built and whatever the analyser resolves types against are not known to be one thing: reload for the copy, and read the diagnostics as a separate answer rather than as this one confirmed. This recompiles into the same object, so the holders that kept the stale copy alive see the new one. The methods it has afterwards come back under reloadedMethods, because a reload that compiled nothing and answered OK is the failure worth catching, and what it held before under heldBeforeReload. Its constants come back the same way, under heldConstantsBeforeReload and reloadedConstants, with each enum value as Kind.SHORT: an enum member is held as a constant and never shows among the methods. A script that does not compile is not reloaded: reloadProblem gives Godot's error, says whether the copy the editor holds survived, and names the classes the file uses, whose held copies being behind is what failed one before."
       }
     },
     requires: ["projectPath"]
@@ -31156,7 +31189,7 @@ var TOOL_SPECS = [
       property: {
         type: "string",
         ops: ["set"],
-        description: 'set: which one to write. Colons write through what a node holds, "_game:run:day", and a number or a key steps into a list or a map on the way, "_game:run:roster:0:name", a negative number counting from the end, and a step written as a call, "get_viewport():gui_embed_subwindows", walks through what a method taking no arguments returned. The answer reads back off the same holder, and a write that leaves the property as it was, because the engine would not take it, is refused and says what the property still holds.'
+        description: 'set: which one to write. Colons write through what a node holds, "_game:run:day", and a number or a key steps into a list or a map on the way, "_game:run:roster:0:name", a negative number counting from the end, and a step written as a call, "get_viewport():gui_embed_subwindows", walks through what a method taking no arguments returned. The answer reads back off the same holder, and a write that leaves the property as it was, because the engine would not take it, is refused and says what the property still holds. A write of the value the property already holds, at its own precision, as a float given in 64 bits to a property keeping 32, is not refused: it answers unchanged: true.'
       },
       value: {
         ops: ["set"],
@@ -31376,7 +31409,10 @@ var TOOL_SPECS = [
         ops: ["until"],
         description: 'until: the property name, or a colon path through what the node holds, "_game:run:day", read the way runtime_inspect property reads one, a step written as a call included. Walked again on every frame, so a holder the game replaces while the wait is on is followed.'
       },
-      value: { ops: ["until"], description: "until: the value to wait for, fitted to the property's type." },
+      value: {
+        ops: ["until"],
+        description: "until: the value to wait for, fitted to the property's type. On a property declared to hold an object, null, which the text null also means; any other value is refused, since the property can never hold it."
+      },
       says: {
         type: "string",
         ops: ["until"],
@@ -33073,7 +33109,8 @@ class GodotServer {
       payload: {
         uidsCreated: given,
         stillWithoutUid: after,
-        note: uidsLeftNote(after.length)
+        note: uidsLeftNote(after.length),
+        ...imported.librariesRetried === undefined ? {} : { extensionNote: extensionRetryNote(imported.librariesRetried) }
       }
     }, scanned));
   }
@@ -33229,6 +33266,9 @@ class GodotServer {
       if (imported.messages.length > 0) {
         extra["engine_messages"] = imported.messages;
       }
+      if (imported.librariesRetried !== undefined) {
+        extra["extensionNote"] = extensionRetryNote(imported.librariesRetried);
+      }
     }
     const after = await this.operation("get_import_status", resourcePath === undefined ? { includeUpToDate: true } : { resourcePath }, projectPath);
     if (!after.ok) {
@@ -33757,6 +33797,11 @@ class GodotServer {
       shortListEditorPid: this.godotBridge.getStatus().editorPid ?? null
     });
   }
+  classesAScriptNames(projectPath, scriptPath) {
+    const source = this.sourceOfClass(projectPath, scriptPath);
+    const known = cachedClasses(projectPath) ?? declaredClasses(projectPath);
+    return source === null ? [] : classesNamedIn(source, known).filter((name) => known.get(name) !== scriptPath);
+  }
   sourceOfClass(projectPath, resourcePath) {
     const contained = resolveWithinProject(projectPath, resourcePath);
     if (!contained.ok || !existsSync12(contained.absolutePath)) {
@@ -35422,6 +35467,8 @@ class GodotServer {
     let waitedForEditorMs = 0;
     let first;
     let completedBefore;
+    let uidsReread = [];
+    let uidsDuplicatedOnDisk = [];
     for (;; ) {
       const busySince = Date.now();
       let wasBusy = false;
@@ -35438,6 +35485,11 @@ class GodotServer {
       }
       const firstAnswer = asParams(JSON.parse(first.content[0]?.text ?? "{}"));
       completedBefore = readNumber(firstAnswer, "scansCompletedBefore");
+      uidsReread = [...uidsReread, ...(readArray(firstAnswer, "uidsReread") ?? []).map(String)];
+      const duplicated = readArray(firstAnswer, "uidsDuplicatedOnDisk");
+      if (duplicated !== undefined) {
+        uidsDuplicatedOnDisk = duplicated.map((group) => Array.isArray(group) ? group.map(String) : []);
+      }
       if (firstAnswer["started"] !== false || Date.now() - started >= timeoutMs) {
         break;
       }
@@ -35487,12 +35539,30 @@ class GodotServer {
           const found = readArray(answer, field);
           return found ? { [field]: found.map(String) } : {};
         };
-        reloaded = methods ? {
-          methods: methods.map(String),
-          ...listed("heldBefore"),
-          ...listed("constants"),
-          ...listed("heldConstantsBefore")
-        } : { problem: `the editor would not say what ${reloading} has after reloading it` };
+        const failed = answer["failed"];
+        if (typeof failed === "number" && failed !== 0) {
+          reloaded = {
+            ...listed("heldBefore"),
+            ...listed("heldConstantsBefore"),
+            problem: failedReloadNote({
+              script: reloading,
+              code: failed,
+              codeName: readString(answer, "failedAs") ?? "",
+              heldBefore: listed("heldBefore")["heldBefore"] ?? [],
+              heldAfter: methods?.map(String) ?? [],
+              constantsBefore: listed("heldConstantsBefore")["heldConstantsBefore"] ?? [],
+              constantsAfter: listed("constants")["constants"] ?? [],
+              names: projectPath === "" ? [] : this.classesAScriptNames(projectPath, reloading)
+            })
+          };
+        } else {
+          reloaded = methods ? {
+            methods: methods.map(String),
+            ...listed("heldBefore"),
+            ...listed("constants"),
+            ...listed("heldConstantsBefore")
+          } : { problem: `the editor would not say what ${reloading} has after reloading it` };
+        }
       } catch (error) {
         reloaded = { problem: `${reloading} could not be reloaded: ${errorMessage(error)}` };
       }
@@ -35515,13 +35585,16 @@ class GodotServer {
     if (dependents !== null && dependents.notReloaded.length > 0) {
       notes.push(`The scan brought in ${broughtIn.join(", ")}, and ${dependents.notReloaded.map((one) => one.scriptPath).join(", ")} ${dependents.notReloaded.length === 1 ? "names one of them and" : "name them and"} could not be reloaded, so the editor still holds what it compiled while it could not see the class and reports that to the language server. editor_rescan with reloadScript on each, or editor_launch restart.`);
     }
+    for (const group of uidsDuplicatedOnDisk) {
+      notes.push(`${group.join(" and ")} name one UID in their .uid files, so Godot keeps one path for it and every engine warns "UID duplicate detected". Delete the .uid of the one that is a copy and rescan: the editor writes it a UID of its own.`);
+    }
     if (stillAtMissingPaths.length > 0) {
       notes.push(`The scan wrote the class cache with ${stillAtMissingPaths.join(", ")} at a path that is not on disk, and rebuilding the cache from the files did not take it out. The next engine to read the cache fails on "Could not parse global class" in whichever correct script shares the bare name. Restart the editor with editor_launch restart, then run project_import refresh_classes.`);
     } else if (dropped.length > 0) {
       notes.push(`The scan wrote the class cache from the list this editor is holding, and that list still has ${dropped.join(", ")} for a script that is gone, so the cache was rebuilt from the files without it. The editor goes on holding it and writes it back on every scan until it is restarted with editor_launch restart; until then a scan is followed by this same rebuild.`);
     }
     return this.jsonTextResponse({
-      ok: !busy && unseen.length === 0 && stillGone.length === 0 && stillAtMissingPaths.length === 0 && (dependents === null || dependents.notReloaded.length === 0) && checked.unchecked === undefined,
+      ok: !busy && unseen.length === 0 && stillGone.length === 0 && stillAtMissingPaths.length === 0 && (dependents === null || dependents.notReloaded.length === 0) && reloaded.problem === undefined && checked.unchecked === undefined,
       stillWorking: busy,
       waitedMs: Date.now() - started,
       waitedForEditorScanMs: waitedForEditorMs > 0 ? waitedForEditorMs : undefined,
@@ -35539,6 +35612,8 @@ class GodotServer {
       cacheDropped: dropped.length > 0 ? dropped : undefined,
       cacheAtMissingPaths: stillAtMissingPaths.length > 0 ? stillAtMissingPaths : undefined,
       classesUnchecked: checked.unchecked,
+      uidsReread: uidsReread.length > 0 ? uidsReread : undefined,
+      uidsDuplicatedOnDisk: uidsDuplicatedOnDisk.length > 0 ? uidsDuplicatedOnDisk : undefined,
       note: notes.length > 0 ? notes.join(" ") : undefined
     });
   }
@@ -35555,7 +35630,13 @@ class GodotServer {
       }
       try {
         const answer = asParams(await this.godotBridge.invokeTool("reload_script", { scriptPath }));
-        if (readArray(answer, "methods") === undefined) {
+        const failed = answer["failed"];
+        if (typeof failed === "number" && failed !== 0) {
+          notReloaded.push({
+            scriptPath,
+            problem: `it did not compile: Godot answered error ${failed}${readString(answer, "failedAs") ? `, ${readString(answer, "failedAs")}` : ""}`
+          });
+        } else if (readArray(answer, "methods") === undefined) {
           notReloaded.push({
             scriptPath,
             problem: "the editor would not say what it has after reloading it"

package/package.json

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