gdharness 1.1.16 → 1.1.17

package/build/cli.js

@@ -8706,6 +8706,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 "";
@@ -17341,7 +17353,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"]
@@ -41297,6 +41309,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)) {
@@ -43027,12 +43044,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)}` };
       }
@@ -43095,7 +43130,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/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 "";
@@ -30998,7 +31010,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"]
@@ -33757,6 +33769,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)) {
@@ -35487,12 +35504,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)}` };
       }
@@ -35555,7 +35590,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.17",
   "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",