gdharness 0.13.24 → 0.13.26

package/build/cli.js

@@ -7619,6 +7619,15 @@ function contradictedDiagnostics(messages, classes, sourceOf) {
   }
   return found;
 }
+function staleAnalysisNote(contradicted, dependsOn) {
+  if (contradicted.length === 0) {
+    return "";
+  }
+  const types = new Set(contradicted.map((one) => one.type));
+  const declaring = [...new Set(contradicted.map((one) => one.declaredIn))].sort();
+  const lever = dependsOn.length === 0 ? ", and the named types depend on no other global class, so that lever is not available here. " + "That is the common case rather than the awkward one: an edit near a type that depends on " + "something refreshes it before the fault is noticed, which is why a type with no " + "dependencies is where this turns up" : `, so changing ${[...dependsOn].sort().join(", ")} and rescanning is worth a try`;
+  return `The editor is reporting against an older copy of ${types.size === 1 ? "a type" : "some types"} ` + "named under contradictedByTheFile. Each member listed is declared in the file the class cache " + "points at, so those diagnostics are wrong however the code is written. Run editor_rescan first: " + "it costs about half a second, it cleared this in one of five attempts in the project that " + "reported it, and it cleared both reproductions measured in a second project, the scan itself " + "returning in 243ms and 275ms. " + "The fault behind it is that a script the editor has loaded keeps the copy it built, and nothing " + `rebuilds that copy when the file changes; ${declaring.length === 1 ? `editor_rescan with reloadScript set to ${declaring[0]} recompiles that copy` : `reloadScript takes one script, so a call each for ${declaring.join(" and ")} recompiles those copies`} from the file into the same ` + "object and answers with the members it has afterwards under reloadedMethods. Read that and the " + "next diagnostics as two readings rather than one: a built copy has been seen stale here while " + "the diagnostics on it read clean, so the reload is worth doing and is not known to be what " + "clears these. The other lever measured is that a held type is refreshed when something it " + `depends on changes rather than when it changes itself${lever}. editor_launch restart has always ` + "worked and costs a window. project_import refresh_classes does not, and answers added: [] while " + "this is happening.";
+}
 function cacheWrittenAt(projectPath) {
   const cache = join6(projectPath, ".godot", "global_script_class_cache.cfg");
   try {
@@ -15234,6 +15243,13 @@ function argumentsOf(spec, op) {
 function toolsWithoutProjectPath() {
   return TOOL_SPECS.filter((spec) => !Object.hasOwn(spec.parameters, "projectPath")).map((spec) => spec.name).sort();
 }
+function projectPathSentence(without = toolsWithoutProjectPath()) {
+  if (without.length === 0) {
+    return "Every call takes `projectPath`";
+  }
+  const named = without.map((name) => `\`${name}\``).join(", ");
+  return `Every call takes \`projectPath\` except ${named}, which ${without.length === 1 ? "takes" : "take"} none`;
+}
 function toolSpec(name) {
   return SPECS_BY_NAME[name];
 }
@@ -15970,7 +15986,7 @@ var init_tool_definitions = __esm(() => {
         timeoutMs: { type: "number", description: "How long to wait for the scan. Default 30000." },
         reloadScript: {
           type: "string",
-          description: "A script to recompile in the editor after the scan, for the fault a scan cannot reach: a script the editor has loaded keeps the copy it built, and that copy is refreshed when one of its dependencies changes rather than when it changes itself, so a method added to a loaded class reads as missing at every caller. 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."
+          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."
         }
       },
       requires: ["projectPath"]
@@ -38133,7 +38149,7 @@ class GodotServer {
           }
         }
       }
-      notes.push(`The editor is reporting against an older copy of ${contradicted.length === 1 ? "a type" : "some types"} named under contradictedByTheFile. Each member listed is declared in the file the class cache points at, so those diagnostics are wrong however the code is written. Try editor_rescan first: it costs about half a second and cleared this in one of five measured attempts. If it does not, the lever is that a held type is refreshed when something it depends on changes rather than when it changes itself${dependsOn.size === 0 ? ", though the named types depend on no other global class, which leaves only the restart" : `, so change ${[...dependsOn].sort().join(", ")} and rescan again`}. editor_launch restart is the only remedy that has always worked, and is the one to reach for when the count above is not good enough odds. project_import refresh_classes does not, and answers added: [] while this is happening.`);
+      notes.push(staleAnalysisNote(contradicted, [...dependsOn]));
     }
     const uncached = unloaded.filter((type) => !type.inTheClassCache);
     if (uncached.length > 0) {
@@ -40642,7 +40658,7 @@ function renderToolsMarkdown() {
     `${TOOL_SPECS.length} tools, named \`domain_verb\`. A tool that does several related things takes an`,
     "`op`. An unknown op or argument is refused with the valid set listed. Generated from the server.",
     "",
-    `Every call takes \`projectPath\` except ${toolsWithoutProjectPath().map((name) => `\`${name}\``).join(", ")}, which take none: the \`runtime_*\` and \`debug_*\` ones pick between running games`,
+    `${projectPathSentence()}: the \`runtime_*\` and \`debug_*\` ones pick between running games`,
     "instead, and the others answer about the editor on this server. An argument a tool does not",
     "declare is refused rather than ignored. Answers are read from the engine after the change, not",
     "echoed from the request. Engine stderr comes back under `engine_messages`.",
@@ -40701,7 +40717,7 @@ that is running, and the project on disk. ${TOOL_SPECS.length} tools, named \`do
 
 ## Start here
 
-- Every call takes \`projectPath\` except ${toolsWithoutProjectPath().map((name) => `\\\`${name}\\\``).join(", ")}, which take none. The \`runtime_*\` and \`debug_*\` ones pick between running
+- ${projectPathSentence()}. The \`runtime_*\` and \`debug_*\` ones pick between running
   games instead; the others answer about the editor this server is connected to. There is no
   ambient project, and an argument a tool does not declare is refused rather than ignored.
 - \`editor_status\` says whether an editor is connected and whether its addon matches the server.

package/build/index.js

@@ -24879,6 +24879,15 @@ function contradictedDiagnostics(messages, classes, sourceOf) {
   }
   return found;
 }
+function staleAnalysisNote(contradicted, dependsOn) {
+  if (contradicted.length === 0) {
+    return "";
+  }
+  const types = new Set(contradicted.map((one) => one.type));
+  const declaring = [...new Set(contradicted.map((one) => one.declaredIn))].sort();
+  const lever = dependsOn.length === 0 ? ", and the named types depend on no other global class, so that lever is not available here. " + "That is the common case rather than the awkward one: an edit near a type that depends on " + "something refreshes it before the fault is noticed, which is why a type with no " + "dependencies is where this turns up" : `, so changing ${[...dependsOn].sort().join(", ")} and rescanning is worth a try`;
+  return `The editor is reporting against an older copy of ${types.size === 1 ? "a type" : "some types"} ` + "named under contradictedByTheFile. Each member listed is declared in the file the class cache " + "points at, so those diagnostics are wrong however the code is written. Run editor_rescan first: " + "it costs about half a second, it cleared this in one of five attempts in the project that " + "reported it, and it cleared both reproductions measured in a second project, the scan itself " + "returning in 243ms and 275ms. " + "The fault behind it is that a script the editor has loaded keeps the copy it built, and nothing " + `rebuilds that copy when the file changes; ${declaring.length === 1 ? `editor_rescan with reloadScript set to ${declaring[0]} recompiles that copy` : `reloadScript takes one script, so a call each for ${declaring.join(" and ")} recompiles those copies`} from the file into the same ` + "object and answers with the members it has afterwards under reloadedMethods. Read that and the " + "next diagnostics as two readings rather than one: a built copy has been seen stale here while " + "the diagnostics on it read clean, so the reload is worth doing and is not known to be what " + "clears these. The other lever measured is that a held type is refreshed when something it " + `depends on changes rather than when it changes itself${lever}. editor_launch restart has always ` + "worked and costs a window. project_import refresh_classes does not, and answers added: [] while " + "this is happening.";
+}
 function cacheWrittenAt(projectPath) {
   const cache = join3(projectPath, ".godot", "global_script_class_cache.cfg");
   try {
@@ -29084,7 +29093,7 @@ var TOOL_SPECS = [
       timeoutMs: { type: "number", description: "How long to wait for the scan. Default 30000." },
       reloadScript: {
         type: "string",
-        description: "A script to recompile in the editor after the scan, for the fault a scan cannot reach: a script the editor has loaded keeps the copy it built, and that copy is refreshed when one of its dependencies changes rather than when it changes itself, so a method added to a loaded class reads as missing at every caller. 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."
+        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."
       }
     },
     requires: ["projectPath"]
@@ -30882,7 +30891,7 @@ class GodotServer {
           }
         }
       }
-      notes.push(`The editor is reporting against an older copy of ${contradicted.length === 1 ? "a type" : "some types"} named under contradictedByTheFile. Each member listed is declared in the file the class cache points at, so those diagnostics are wrong however the code is written. Try editor_rescan first: it costs about half a second and cleared this in one of five measured attempts. If it does not, the lever is that a held type is refreshed when something it depends on changes rather than when it changes itself${dependsOn.size === 0 ? ", though the named types depend on no other global class, which leaves only the restart" : `, so change ${[...dependsOn].sort().join(", ")} and rescan again`}. editor_launch restart is the only remedy that has always worked, and is the one to reach for when the count above is not good enough odds. project_import refresh_classes does not, and answers added: [] while this is happening.`);
+      notes.push(staleAnalysisNote(contradicted, [...dependsOn]));
     }
     const uncached = unloaded.filter((type) => !type.inTheClassCache);
     if (uncached.length > 0) {

package/package.json

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