gdharness 1.1.53 → 1.1.54

package/build/cli.js

@@ -9131,7 +9131,7 @@ var init_gdscript_source = __esm(() => {
 
 // src/class-cache.ts
 import { existsSync as existsSync9, readdirSync as readdirSync3, readFileSync as readFileSync7, statSync as statSync4 } from "node:fs";
-import { join as join9 } from "node:path";
+import { join as join9, posix } from "node:path";
 function isToolScript(source) {
   return TOOL.test(codeOf(source));
 }
@@ -9237,6 +9237,27 @@ function missingMemberIn(message) {
   const enumName = inBase[3];
   return enumName === undefined ? { kind: "member", member, type } : { kind: "enum member", member, type, enum: enumName };
 }
+function externalMemberIn(message, line, classes) {
+  const member = /Could not resolve external class member "([A-Za-z_]\w*)"/.exec(message)?.[1];
+  if (member === undefined || line === undefined) {
+    return null;
+  }
+  for (const [, type] of line.matchAll(new RegExp(String.raw`\b([A-Za-z_]\w*)\s*\.\s*${member}\b`, "g"))) {
+    if (type !== undefined && classes.has(type)) {
+      return { kind: "member", member, type };
+    }
+  }
+  return null;
+}
+function baseScriptOf(source, from, classes) {
+  const found = /^(?:@\w+(?:\([^)]*\))?\s+)*(?:class_name\s+\w+\s+)?extends\s+(?:"([^"]+)"|'([^']+)'|([A-Za-z_]\w*))/m.exec(source);
+  const quoted = found?.[1] ?? found?.[2];
+  if (quoted !== undefined) {
+    return quoted.startsWith("res://") ? quoted : posix.join(posix.dirname(from), quoted).replace(/^res:\/(?!\/)/, "res://");
+  }
+  const named = found?.[3];
+  return named === undefined ? undefined : classes.get(named);
+}
 function declaresMember(source, missing) {
   const name = missing.member.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   const top = String.raw`^(?:@\w+(?:\([^)]*\))?\s+)*`;
@@ -9296,24 +9317,39 @@ function classesNamedIn(source, known) {
   }
   return [...named].sort();
 }
-function contradictedDiagnostics(messages, classes, sourceOf) {
+function contradictedDiagnostics(messages, classes, sourceOf, alsoDenied = []) {
   const keyOf = (missing) => [missing.type, missing.enum ?? "", missing.member].join(".");
-  const denials = messages.map((message) => missingMemberIn(message)).filter((missing) => missing !== null);
+  const denials = [
+    ...messages.map((message) => missingMemberIn(message)).filter((missing) => missing !== null),
+    ...alsoDenied
+  ];
   const calledOnTheClass = new Set(denials.filter((missing) => missing.kind === "static method").map((missing) => keyOf(missing)));
   const read = new Map;
+  const sourceAt = (path) => {
+    if (!read.has(path)) {
+      read.set(path, sourceOf(path));
+    }
+    return read.get(path) ?? null;
+  };
   const found = new Map;
   for (const missing of denials) {
-    const declaredIn = classes.get(missing.type);
     const key = keyOf(missing);
-    if (declaredIn === undefined || missing.kind === "method" && calledOnTheClass.has(key)) {
+    if (found.has(key) || missing.kind === "method" && calledOnTheClass.has(key)) {
       continue;
     }
-    if (!read.has(declaredIn)) {
-      read.set(declaredIn, sourceOf(declaredIn));
-    }
-    const source = read.get(declaredIn) ?? null;
-    if (source !== null && declaresMember(source, missing)) {
-      found.set(key, { ...missing, declaredIn });
+    const seen = new Set;
+    let at = classes.get(missing.type);
+    while (at !== undefined && !seen.has(at)) {
+      seen.add(at);
+      const source = sourceAt(at);
+      if (source === null) {
+        break;
+      }
+      if (declaresMember(source, missing)) {
+        found.set(key, { ...missing, declaredIn: at });
+        break;
+      }
+      at = baseScriptOf(source, at, classes);
     }
   }
   return [...found.values()];
@@ -9326,7 +9362,7 @@ function staleAnalysisNote(contradicted, dependsOn) {
   const onInstances = contradicted.filter((one) => one.kind === "method" || one.kind === "property");
   const onTheClass = contradicted.filter((one) => one.kind === "member" || one.kind === "static method" || one.kind === "enum member");
   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.",
+    `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 script under its " + "declaredIn, the class itself or a project class it extends, so those diagnostics are wrong " + "however the code is written.",
     instanceRemedy(onInstances, dependsOn, onTheClass.length > 0),
     classRemedy(onTheClass)
   ].filter((part) => part !== "").join(" ");
@@ -9343,7 +9379,7 @@ function instanceRemedy(entries, dependsOn, besideOthers) {
   }
   const declaring = declaringScripts(entries);
   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(" or ")} and then rescanning is worth a try`;
-  return `${besideOthers ? `For ${entries.map(written).join(", ")}, run` : "Run"} editor_rescan first: ` + "it costs about half a second, and it has cleared this in every reproduction measured since the " + "scan timing was fixed: both in one project, the scan returning in 243ms and 275ms, and one in " + "another where the same call also rebuilt the copy. " + "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, because they are of two things: measured in one window on " + "one editor, the analyser resolved a call to a newly added method while the built copy of that " + "same script did not have it. So the reload is worth doing and is not what clears these; the " + "scan is. 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.";
+  return `${besideOthers ? `For ${entries.map(written).join(", ")}, run` : "Run"} editor_rescan first: ` + "it costs about half a second, and it has cleared this in every reproduction measured since the " + "scan timing was fixed: both in one project, the scan returning in 243ms and 275ms, and one in " + "another where the same call also rebuilt the copy. " + "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 what that added under methodsAdded and constantsAdded. Read that and the " + "next diagnostics as two readings, because they are of two things: measured in one window on " + "one editor, the analyser resolved a call to a newly added method while the built copy of that " + "same script did not have it. So the reload is worth doing and is not what clears these; the " + "scan is. 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 classRemedy(entries) {
   if (entries.length === 0) {
@@ -9367,6 +9403,24 @@ function notReloadedNote(broughtIn, notReloaded) {
   }
   return `The scan brought in ${broughtIn.join(", ")}, and ${all.join(", ")} ${all.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. ${remedies.join(" ")}`;
 }
+function reloadDifference(reloaded) {
+  const between = (before, after) => {
+    if (before === undefined || after === undefined) {
+      return null;
+    }
+    const was = new Set(before);
+    const is = new Set(after);
+    return { added: after.filter((name) => !was.has(name)), removed: before.filter((name) => !is.has(name)) };
+  };
+  const methods = between(reloaded.heldBefore, reloaded.methods);
+  const constants = between(reloaded.heldConstantsBefore, reloaded.constants);
+  return {
+    ...reloaded.methods === undefined ? {} : { methodsHeld: reloaded.methods.length },
+    ...methods === null ? {} : { methodsAdded: methods.added, methodsRemoved: methods.removed },
+    ...reloaded.constants === undefined ? {} : { constantsHeld: reloaded.constants.length },
+    ...constants === null ? {} : { constantsAdded: constants.added, constantsRemoved: constants.removed }
+  };
+}
 function failedReloadNote(failed) {
   const missing = (before, after) => before.filter((name) => !after.includes(name));
   const lost = [
@@ -9382,7 +9436,7 @@ function failedReloadNote(failed) {
   } else if (!failed.restored) {
     copy = `${unusable} The editor compiled it again from the text it was built from, and that failed too${failed.restoredAs === "" ? "" : ` (${failed.restoredAs})`}, so it stays that way until the script compiles: reload it then, or restart the editor with editor_launch restart.`;
   } else if (unchanged) {
-    copy = "The copy the editor holds was compiled again from the text it was built from, which puts it back as it was, with the members under heldBeforeReload and heldConstantsBeforeReload.";
+    copy = "The copy the editor holds was compiled again from the text it was built from, which puts it back as it was, with the members it held before, which listMembers lists.";
   } else {
     copy = `The copy the editor holds was compiled again from the text it was built from and 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.`;
   }
@@ -17855,7 +17909,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "script_diagnostics",
-      description: "Errors and warnings for a script, or for several, from the editor's language server, and whether each is clean. Needs the editor running. Each diagnostic carries its severity (error or warning), its message, and where it is as the editor shows it: line and column counted from 1, and endLine and endColumn just past its end. Diagnostics are checked against the project's own files, and the two that the files disprove are named rather than passed on: a member the class cache's file declares, a method, property, constant, static function or enum member, comes back under contradictedByTheFile, and a class this project declares that the diagnostic could not resolve comes back under typesTheEditorHasNotLoaded, with inTheClassCache saying whether a launched game would resolve it. staleAnalysis then says what to do, and for both states it is editor_rescan first: it asks the editor already running, starts nothing, and has cleared each in every reproduction measured. Two exceptions are named when they apply. For an enum member, constant or static function of a global class the reload comes first: in the one project that has reproduced a stale enum member, editor_rescan with reloadScript on the declaring script cleared it and a plain rescan did not. And an editor whose last scan wrote the class cache shorter than the file holds a list behind the files and writes it on every scan, so on that editor the rescan loads nothing and staleAnalysis says editor_launch restart instead. What follows differs: for a stale analysed type, editor_rescan with reloadScript recompiles the held copy and editor_launch restart is the last resort that costs a window; for a class missing from the cache, project_import refresh_classes rewrites the cache from disk at the cost of a short headless engine, which matters beside a running bench.",
+      description: "Errors and warnings for a script, or for several, from the editor's language server, and whether each is clean. Needs the editor running. Each diagnostic carries its severity (error or warning), its message, and where it is as the editor shows it: line and column counted from 1, and endLine and endColumn just past its end. Diagnostics are checked against the project's own files, and the two that the files disprove are named rather than passed on: a member the class cache's file declares, or a project class it extends does, a method, property, constant, static function or enum member, comes back under contradictedByTheFile with the script declaring it, and so does one a diagnostic names alone as an external class member, read against the class it is looked up on in the line it is on; and a class this project declares that the diagnostic could not resolve comes back under typesTheEditorHasNotLoaded, with inTheClassCache saying whether a launched game would resolve it. staleAnalysis then says what to do, and for both states it is editor_rescan first: it asks the editor already running, starts nothing, and has cleared each in every reproduction measured. Two exceptions are named when they apply. For an enum member, constant or static function of a global class the reload comes first: in the one project that has reproduced a stale enum member, editor_rescan with reloadScript on the declaring script cleared it and a plain rescan did not. And an editor whose last scan wrote the class cache shorter than the file holds a list behind the files and writes it on every scan, so on that editor the rescan loads nothing and staleAnalysis says editor_launch restart instead. What follows differs: for a stale analysed type, editor_rescan with reloadScript recompiles the held copy and editor_launch restart is the last resort that costs a window; for a class missing from the cache, project_import refresh_classes rewrites the cache from disk at the cost of a short headless engine, which matters beside a running bench.",
       parameters: {
         projectPath: PROJECT_PATH,
         scriptPath: {
@@ -18080,7 +18134,11 @@ 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. 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. A @tool script is not reloaded either, since it runs inside the editor and reloading one from inside a call can take the editor down: reloadProblem says so, and editor_launch restart recompiles it. A path spelled in another case than the file is reloaded under the spelling on disk, which is the one the editor holds its copy under, and that spelling comes back under reloadedAs."
+          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. What the reload changed comes back under methodsAdded, methodsRemoved, constantsAdded and constantsRemoved, with each enum value as Kind.SHORT among the constants, since an enum member is held as a constant and never shows among the methods; methodsHeld and constantsHeld count what the copy holds afterwards, because a reload that compiled nothing and answered OK is the failure worth catching. listMembers adds the whole lists. 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. A @tool script is not reloaded either, since it runs inside the editor and reloading one from inside a call can take the editor down: reloadProblem says so, and editor_launch restart recompiles it. A path spelled in another case than the file is reloaded under the spelling on disk, which is the one the editor holds its copy under, and that spelling comes back under reloadedAs."
+        },
+        listMembers: {
+          type: "boolean",
+          description: "With reloadScript: also answer the whole member lists, heldBeforeReload and reloadedMethods for the methods, heldConstantsBeforeReload and reloadedConstants for the constants. Default false: a script holding hundreds of constants answers hundreds of lines twice to say what one reload added."
         }
       },
       requires: ["projectPath"]
@@ -39139,6 +39197,7 @@ import { existsSync as existsSync16, realpathSync as realpathSync4 } from "node:
 import { readFile, realpath } from "node:fs/promises";
 import { createConnection as createConnection3 } from "node:net";
 import { dirname as dirname14, join as join20, resolve as resolve5 } from "node:path";
+import { setTimeout as delay3 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath3, pathToFileURL } from "node:url";
 function initializeTimeoutMs() {
   const override = Number.parseInt(envValue("GDHARNESS_LSP_INITIALIZE_TIMEOUT_MS") ?? "", 10);
@@ -39177,17 +39236,38 @@ class GodotLSPClient {
   documentVersions = new Map;
   documentTurns = new Map;
   timeouts;
+  servedHere;
   constructor(port = portFromEnv("GDHARNESS_LSP_PORT", DEFAULT_LSP_PORT), host = "127.0.0.1", timeouts = {
     requestMs: REQUEST_TIMEOUT_MS2,
     referencesMs: REFERENCES_TIMEOUT_MS,
-    initializeMs: initializeTimeoutMs()
-  }) {
+    initializeMs: initializeTimeoutMs(),
+    listenMs: LANGUAGE_SERVER_START_MS
+  }, servedHere = () => false) {
     this.port = port;
     this.host = host;
     this.timeouts = timeouts;
+    this.servedHere = servedHere;
     this.pendingRequests = new Map;
   }
   async connect() {
+    const until = Date.now() + this.timeouts.listenMs;
+    for (;; ) {
+      try {
+        await this.connectOnce();
+        return;
+      } catch (error) {
+        const refused = error instanceof Error && error.message.includes("ECONNREFUSED");
+        if (!refused || !this.servedHere()) {
+          throw error;
+        }
+        if (Date.now() >= until) {
+          throw new LanguageServerNotListening(this.port, this.timeouts.listenMs);
+        }
+        await delay3(LANGUAGE_SERVER_RETRY_MS);
+      }
+    }
+  }
+  async connectOnce() {
     if (this.connected && this.socket) {
       return;
     }
@@ -39820,11 +39900,12 @@ async function handleLSPTool(client, toolName, args) {
       ...error instanceof AnotherProjectsServer ? { serves: error.serves } : {},
       ...error instanceof ArgumentRefusal ? { refusedArguments: true } : {},
       ...error instanceof NoDiagnosticsPublished ? { aboutThisFile: true } : {},
-      ...error instanceof LSPTimeout && error.method === "initialize" ? { stillReading: true } : {}
+      ...error instanceof LSPTimeout && error.method === "initialize" ? { stillReading: true } : {},
+      ...error instanceof LanguageServerNotListening ? { stillReading: true } : {}
     });
   }
 }
-var DEFAULT_LSP_PORT = 6005, DIAGNOSTICS_TIMEOUT_MS = 5000, REQUEST_TIMEOUT_MS2 = 1e4, REFERENCES_TIMEOUT_MS = 180000, LSPTimeout, ArgumentRefusal, NoDiagnosticsPublished, AnotherProjectsServer, SEVERITIES, SYMBOL_KINDS, COMPLETION_KINDS;
+var DEFAULT_LSP_PORT = 6005, DIAGNOSTICS_TIMEOUT_MS = 5000, REQUEST_TIMEOUT_MS2 = 1e4, REFERENCES_TIMEOUT_MS = 180000, LSPTimeout, LANGUAGE_SERVER_START_MS = 30000, LANGUAGE_SERVER_RETRY_MS = 250, LanguageServerNotListening, ArgumentRefusal, NoDiagnosticsPublished, AnotherProjectsServer, SEVERITIES, SYMBOL_KINDS, COMPLETION_KINDS;
 var init_lsp_client = __esm(() => {
   init_answer_json();
   init_errors();
@@ -39840,6 +39921,11 @@ var init_lsp_client = __esm(() => {
       this.seconds = timeoutMs / 1000;
     }
   };
+  LanguageServerNotListening = class LanguageServerNotListening extends Error {
+    constructor(port, waitedMs) {
+      super(`The editor on the bridge says its language server is on port ${port}, and nothing accepted a connection there in ${String(waitedMs / 1000)}s. An editor starts it a few seconds after it reaches the bridge, so straight after editor_launch this is the editor still starting, and calling again answers. One that goes on refusing could not take the port; editor_output shows what the editor printed.`);
+    }
+  };
   ArgumentRefusal = class ArgumentRefusal extends Refusal {
   };
   NoDiagnosticsPublished = class NoDiagnosticsPublished extends Error {
@@ -40249,7 +40335,7 @@ var init_project_scan = __esm(() => {
 
 // src/rename.ts
 import { existsSync as existsSync18, mkdirSync as mkdirSync11, readFileSync as readFileSync19, renameSync, unlinkSync as unlinkSync2, writeFileSync as writeFileSync13 } from "node:fs";
-import { dirname as dirname15, posix } from "node:path";
+import { dirname as dirname15, posix as posix2 } from "node:path";
 
 class Script {
   path;
@@ -40362,13 +40448,13 @@ class ClassGraph {
 }
 function resolvedPath(written, from) {
   if (written.startsWith("res://")) {
-    return `res://${posix.normalize(written.slice("res://".length))}`;
+    return `res://${posix2.normalize(written.slice("res://".length))}`;
   }
-  const directory = posix.dirname(from.slice("res://".length));
-  return `res://${posix.normalize(posix.join(directory, written))}`;
+  const directory = posix2.dirname(from.slice("res://".length));
+  return `res://${posix2.normalize(posix2.join(directory, written))}`;
 }
 function relativeTo(target, from) {
-  return posix.relative(posix.dirname(from.slice("res://".length)), target.slice("res://".length));
+  return posix2.relative(posix2.dirname(from.slice("res://".length)), target.slice("res://".length));
 }
 function scriptsOf(texts) {
   const scripts = new Map;
@@ -42030,7 +42116,7 @@ import {
   statSync as statSync9
 } from "node:fs";
 import { basename as basename7, dirname as dirname19, extname as extname2, isAbsolute as isAbsolute3, join as join26, normalize as normalize2, relative as relative5 } from "node:path";
-import { setTimeout as delay3 } from "node:timers/promises";
+import { setTimeout as delay4 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 import { promisify as promisify5 } from "node:util";
 function editorRestartTimeoutMs() {
@@ -42163,7 +42249,7 @@ async function untilGone(pids, withinMs = STOP_WAIT_MS) {
   const gone = () => pids.every((pid) => !alive(pid));
   const deadline = Date.now() + withinMs;
   while (!gone() && Date.now() < deadline) {
-    await delay3(50);
+    await delay4(50);
   }
   return gone();
 }
@@ -42962,7 +43048,7 @@ class GodotServer {
         taken = true;
         this.logDebug(`Took port ${wanted} over from pid ${announced.pid}`);
       } catch {
-        await delay3(HANDOVER_POLL_MS);
+        await delay4(HANDOVER_POLL_MS);
       }
     }
     this.notHandedOverBy = taken ? null : announced.pid;
@@ -44733,14 +44819,14 @@ class GodotServer {
   }
   whereTheFileDisagrees(diagnostics, args) {
     const messages = diagnostics.map((entry) => asParams(entry)["message"]).filter((message) => typeof message === "string");
-    const worthChecking = messages.some((message) => missingMemberIn(message) !== null || unknownTypeIn(message) !== null);
+    const worthChecking = messages.some((message) => missingMemberIn(message) !== null || unknownTypeIn(message) !== null || message.includes(EXTERNAL_MEMBER));
     const project = worthChecking ? this.project(args) : null;
     if (project === null || !project.ok) {
       return {};
     }
     const projectPath = project.value.path;
     const cached = cachedClasses(projectPath);
-    const contradicted = cached === null ? [] : contradictedDiagnostics(messages, cached, (resourcePath) => {
+    const sourceOf = (resourcePath) => {
       const contained = resolveWithinProject(projectPath, resourcePath);
       if (!contained.ok || !existsSync20(contained.absolutePath)) {
         return null;
@@ -44750,7 +44836,16 @@ class GodotServer {
       } catch {
         return null;
       }
-    });
+    };
+    const external = diagnostics.filter((entry) => String(asParams(entry)["message"]).includes(EXTERNAL_MEMBER));
+    const diagnosed = external.length === 0 ? null : sourceOf(readString(args, "scriptPath") ?? "");
+    const lines = diagnosed?.split(`
+`) ?? [];
+    const alsoDenied = cached === null ? [] : external.map((entry) => {
+      const { message, line } = asParams(entry);
+      return externalMemberIn(String(message), typeof line === "number" ? lines[line - 1] : undefined, cached);
+    }).filter((missing) => missing !== null);
+    const contradicted = cached === null ? [] : contradictedDiagnostics(messages, cached, sourceOf, alsoDenied);
     const unloaded = messages.some((message) => unknownTypeIn(message) !== null) ? unloadedTypes(messages, declaredClasses(projectPath), cached) : [];
     const notes = [];
     if (contradicted.length > 0) {
@@ -44820,7 +44915,10 @@ class GodotServer {
       await this.lspClient.disconnect();
       this.lspClient = null;
     }
-    this.lspClient ??= new GodotLSPClient(port);
+    this.lspClient ??= new GodotLSPClient(port, undefined, undefined, () => {
+      const status = this.godotBridge.getStatus();
+      return status.connected && status.lspPort === port;
+    });
     return this.lspClient;
   }
   async handleDAP(toolName, args) {
@@ -45000,7 +45098,7 @@ class GodotServer {
     try {
       const askedAt = Date.now();
       const asked = this.godotBridge.invokeTool("playing_status", {});
-      const answer = await Promise.race([asked, delay3(PLAYING_STATUS_MS).then(() => null)]);
+      const answer = await Promise.race([asked, delay4(PLAYING_STATUS_MS).then(() => null)]);
       if (answer === null) {
         this.logDebug(`playing_status did not answer within ${PLAYING_STATUS_MS}ms`);
         asked.then(() => {
@@ -45025,7 +45123,7 @@ class GodotServer {
     try {
       const answer = await Promise.race([
         this.godotBridge.invokeTool("scan_status", {}),
-        delay3(PLAYING_STATUS_MS).then(() => null)
+        delay4(PLAYING_STATUS_MS).then(() => null)
       ]);
       if (answer === null) {
         return null;
@@ -45237,7 +45335,7 @@ class GodotServer {
       if (Date.now() >= deadline) {
         return false;
       }
-      await delay3(250);
+      await delay4(250);
     }
   }
   async handleLaunchEditor(args) {
@@ -45747,7 +45845,7 @@ class GodotServer {
       if (Date.now() >= deadline) {
         return false;
       }
-      await delay3(100);
+      await delay4(100);
     }
   }
   async endActiveGame(reason, going) {
@@ -46339,7 +46437,7 @@ class GodotServer {
     while (cancelled?.aborted !== true && await this.runStillGoing(run) && Date.now() < until) {
       this.drainEditorOutput(run);
       this.drainTranscript(run);
-      await delay3(RUN_POLL_MS);
+      await delay4(RUN_POLL_MS);
     }
     return await this.handleGetDebugOutput(args, await this.runStillGoing(run) ? budgetMs : undefined);
   }
@@ -46376,7 +46474,7 @@ class GodotServer {
       if (Date.now() >= until) {
         return false;
       }
-      await delay3(50);
+      await delay4(50);
     }
   }
   async handleEditorConsole(args) {
@@ -46886,10 +46984,13 @@ class GodotServer {
       waitedMs: Date.now() - started,
       waitedForEditorScanMs: waitedForEditorMs > 0 ? waitedForEditorMs : undefined,
       reloadedAs: reloaded.as,
-      heldBeforeReload: reloaded.heldBefore,
-      reloadedMethods: reloaded.methods,
-      heldConstantsBeforeReload: reloaded.heldConstantsBefore,
-      reloadedConstants: reloaded.constants,
+      ...reloadDifference(reloaded),
+      ...args["listMembers"] === true ? {
+        heldBeforeReload: reloaded.heldBefore,
+        reloadedMethods: reloaded.methods,
+        heldConstantsBeforeReload: reloaded.heldConstantsBefore,
+        reloadedConstants: reloaded.constants
+      } : {},
       reloadProblem: reloaded.problem,
       unseenByEditor: unseen.length > 0 ? unseen : undefined,
       broughtIn: broughtIn.length > 0 ? broughtIn : undefined,
@@ -47565,7 +47666,7 @@ async function runGodotServer() {
   const server = new GodotServer;
   await server.run();
 }
-var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, run4, __dirname2, GREETING_WAIT_MS = 1e4, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, PLAY_STARTS_WITHIN_MS = 30000, STOP_WAIT_MS = 1e4, KEEPER_ANSWER_MS = 15000, EXIT_REPORTED_WITHIN_MS = 2000, CONSOLE_WRAPPER, LONGEST_BOOT_NOTED_MS, MOST_GROUPS = 20, VALUE_NAMES, BRIDGE_RETRY_MS = 2000, SUCCESSOR_CHECK_MS = 1e4, CONSOLE_WATCH_MS = 250, BOUNDARY_WAIT_MS = 2000, HANDOVER_MS, HANDOVER_POLL_MS = 250, CACHE_WRITE_MS = 2000, SCAN_WAIT_MS = 30000, STREAMS_GRACE_MS = 2000, PLAYING_STATUS_MS = 1000, SCAN_START_MS = 2000, SCAN_SETTLED_MS = 500, REIMPORT_TIMEOUT_MS = 300000, AUDIO_BUS_OPS, STALLED_AFTER_MS = 30000, TEST_HEARTBEAT_MS = 20000, DEPENDED_FAILED = "Failed to compile depended scripts", 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, run4, __dirname2, GREETING_WAIT_MS = 1e4, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, PLAY_STARTS_WITHIN_MS = 30000, STOP_WAIT_MS = 1e4, KEEPER_ANSWER_MS = 15000, EXIT_REPORTED_WITHIN_MS = 2000, CONSOLE_WRAPPER, LONGEST_BOOT_NOTED_MS, MOST_GROUPS = 20, VALUE_NAMES, BRIDGE_RETRY_MS = 2000, SUCCESSOR_CHECK_MS = 1e4, CONSOLE_WATCH_MS = 250, BOUNDARY_WAIT_MS = 2000, HANDOVER_MS, HANDOVER_POLL_MS = 250, CACHE_WRITE_MS = 2000, SCAN_WAIT_MS = 30000, STREAMS_GRACE_MS = 2000, PLAYING_STATUS_MS = 1000, SCAN_START_MS = 2000, SCAN_SETTLED_MS = 500, REIMPORT_TIMEOUT_MS = 300000, AUDIO_BUS_OPS, STALLED_AFTER_MS = 30000, TEST_HEARTBEAT_MS = 20000, DEPENDED_FAILED = "Failed to compile depended scripts", WAIT_FOR_RUN_MS = 600000, RUN_POLL_MS = 250, PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, PROJECT_INFO_SECTIONS2, RUNNER_DIRECTORY = "addons/gdUnit4/", EXTERNAL_MEMBER = 'Could not resolve external class member "';
 var init_server3 = __esm(() => {
   init_mcp();
   init_stdio2();

package/build/index.js

@@ -10261,7 +10261,7 @@ import {
   statSync as statSync8
 } from "node:fs";
 import { basename as basename5, dirname as dirname15, extname as extname2, isAbsolute as isAbsolute3, join as join22, normalize as normalize2, relative as relative4 } from "node:path";
-import { setTimeout as delay3 } from "node:timers/promises";
+import { setTimeout as delay4 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 import { promisify as promisify5 } from "node:util";
 
@@ -26191,7 +26191,7 @@ function callProgress() {
 
 // src/class-cache.ts
 import { existsSync as existsSync3, readdirSync as readdirSync2, readFileSync as readFileSync7, statSync as statSync2 } from "node:fs";
-import { join as join6 } from "node:path";
+import { join as join6, posix } from "node:path";
 
 // src/gdscript-source.ts
 var IDENTIFIER_START = /[\p{L}_]/u;
@@ -26692,6 +26692,27 @@ function missingMemberIn(message) {
   const enumName = inBase[3];
   return enumName === undefined ? { kind: "member", member, type } : { kind: "enum member", member, type, enum: enumName };
 }
+function externalMemberIn(message, line, classes) {
+  const member = /Could not resolve external class member "([A-Za-z_]\w*)"/.exec(message)?.[1];
+  if (member === undefined || line === undefined) {
+    return null;
+  }
+  for (const [, type] of line.matchAll(new RegExp(String.raw`\b([A-Za-z_]\w*)\s*\.\s*${member}\b`, "g"))) {
+    if (type !== undefined && classes.has(type)) {
+      return { kind: "member", member, type };
+    }
+  }
+  return null;
+}
+function baseScriptOf(source, from, classes) {
+  const found = /^(?:@\w+(?:\([^)]*\))?\s+)*(?:class_name\s+\w+\s+)?extends\s+(?:"([^"]+)"|'([^']+)'|([A-Za-z_]\w*))/m.exec(source);
+  const quoted = found?.[1] ?? found?.[2];
+  if (quoted !== undefined) {
+    return quoted.startsWith("res://") ? quoted : posix.join(posix.dirname(from), quoted).replace(/^res:\/(?!\/)/, "res://");
+  }
+  const named = found?.[3];
+  return named === undefined ? undefined : classes.get(named);
+}
 function declaresMember(source, missing) {
   const name = missing.member.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   const top = String.raw`^(?:@\w+(?:\([^)]*\))?\s+)*`;
@@ -26751,24 +26772,39 @@ function classesNamedIn(source, known) {
   }
   return [...named].sort();
 }
-function contradictedDiagnostics(messages, classes, sourceOf) {
+function contradictedDiagnostics(messages, classes, sourceOf, alsoDenied = []) {
   const keyOf = (missing) => [missing.type, missing.enum ?? "", missing.member].join(".");
-  const denials = messages.map((message) => missingMemberIn(message)).filter((missing) => missing !== null);
+  const denials = [
+    ...messages.map((message) => missingMemberIn(message)).filter((missing) => missing !== null),
+    ...alsoDenied
+  ];
   const calledOnTheClass = new Set(denials.filter((missing) => missing.kind === "static method").map((missing) => keyOf(missing)));
   const read = new Map;
+  const sourceAt = (path) => {
+    if (!read.has(path)) {
+      read.set(path, sourceOf(path));
+    }
+    return read.get(path) ?? null;
+  };
   const found = new Map;
   for (const missing of denials) {
-    const declaredIn = classes.get(missing.type);
     const key = keyOf(missing);
-    if (declaredIn === undefined || missing.kind === "method" && calledOnTheClass.has(key)) {
+    if (found.has(key) || missing.kind === "method" && calledOnTheClass.has(key)) {
       continue;
     }
-    if (!read.has(declaredIn)) {
-      read.set(declaredIn, sourceOf(declaredIn));
-    }
-    const source = read.get(declaredIn) ?? null;
-    if (source !== null && declaresMember(source, missing)) {
-      found.set(key, { ...missing, declaredIn });
+    const seen = new Set;
+    let at = classes.get(missing.type);
+    while (at !== undefined && !seen.has(at)) {
+      seen.add(at);
+      const source = sourceAt(at);
+      if (source === null) {
+        break;
+      }
+      if (declaresMember(source, missing)) {
+        found.set(key, { ...missing, declaredIn: at });
+        break;
+      }
+      at = baseScriptOf(source, at, classes);
     }
   }
   return [...found.values()];
@@ -26781,7 +26817,7 @@ function staleAnalysisNote(contradicted, dependsOn) {
   const onInstances = contradicted.filter((one) => one.kind === "method" || one.kind === "property");
   const onTheClass = contradicted.filter((one) => one.kind === "member" || one.kind === "static method" || one.kind === "enum member");
   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.",
+    `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 script under its " + "declaredIn, the class itself or a project class it extends, so those diagnostics are wrong " + "however the code is written.",
     instanceRemedy(onInstances, dependsOn, onTheClass.length > 0),
     classRemedy(onTheClass)
   ].filter((part) => part !== "").join(" ");
@@ -26798,7 +26834,7 @@ function instanceRemedy(entries, dependsOn, besideOthers) {
   }
   const declaring = declaringScripts(entries);
   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(" or ")} and then rescanning is worth a try`;
-  return `${besideOthers ? `For ${entries.map(written).join(", ")}, run` : "Run"} editor_rescan first: ` + "it costs about half a second, and it has cleared this in every reproduction measured since the " + "scan timing was fixed: both in one project, the scan returning in 243ms and 275ms, and one in " + "another where the same call also rebuilt the copy. " + "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, because they are of two things: measured in one window on " + "one editor, the analyser resolved a call to a newly added method while the built copy of that " + "same script did not have it. So the reload is worth doing and is not what clears these; the " + "scan is. 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.";
+  return `${besideOthers ? `For ${entries.map(written).join(", ")}, run` : "Run"} editor_rescan first: ` + "it costs about half a second, and it has cleared this in every reproduction measured since the " + "scan timing was fixed: both in one project, the scan returning in 243ms and 275ms, and one in " + "another where the same call also rebuilt the copy. " + "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 what that added under methodsAdded and constantsAdded. Read that and the " + "next diagnostics as two readings, because they are of two things: measured in one window on " + "one editor, the analyser resolved a call to a newly added method while the built copy of that " + "same script did not have it. So the reload is worth doing and is not what clears these; the " + "scan is. 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 classRemedy(entries) {
   if (entries.length === 0) {
@@ -26822,6 +26858,24 @@ function notReloadedNote(broughtIn, notReloaded) {
   }
   return `The scan brought in ${broughtIn.join(", ")}, and ${all.join(", ")} ${all.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. ${remedies.join(" ")}`;
 }
+function reloadDifference(reloaded) {
+  const between = (before, after) => {
+    if (before === undefined || after === undefined) {
+      return null;
+    }
+    const was = new Set(before);
+    const is = new Set(after);
+    return { added: after.filter((name) => !was.has(name)), removed: before.filter((name) => !is.has(name)) };
+  };
+  const methods = between(reloaded.heldBefore, reloaded.methods);
+  const constants = between(reloaded.heldConstantsBefore, reloaded.constants);
+  return {
+    ...reloaded.methods === undefined ? {} : { methodsHeld: reloaded.methods.length },
+    ...methods === null ? {} : { methodsAdded: methods.added, methodsRemoved: methods.removed },
+    ...reloaded.constants === undefined ? {} : { constantsHeld: reloaded.constants.length },
+    ...constants === null ? {} : { constantsAdded: constants.added, constantsRemoved: constants.removed }
+  };
+}
 function failedReloadNote(failed) {
   const missing = (before, after) => before.filter((name) => !after.includes(name));
   const lost = [
@@ -26837,7 +26891,7 @@ function failedReloadNote(failed) {
   } else if (!failed.restored) {
     copy = `${unusable} The editor compiled it again from the text it was built from, and that failed too${failed.restoredAs === "" ? "" : ` (${failed.restoredAs})`}, so it stays that way until the script compiles: reload it then, or restart the editor with editor_launch restart.`;
   } else if (unchanged) {
-    copy = "The copy the editor holds was compiled again from the text it was built from, which puts it back as it was, with the members under heldBeforeReload and heldConstantsBeforeReload.";
+    copy = "The copy the editor holds was compiled again from the text it was built from, which puts it back as it was, with the members it held before, which listMembers lists.";
   } else {
     copy = `The copy the editor holds was compiled again from the text it was built from and 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.`;
   }
@@ -29728,6 +29782,7 @@ import { existsSync as existsSync12, realpathSync as realpathSync3 } from "node:
 import { readFile, realpath } from "node:fs/promises";
 import { createConnection as createConnection3 } from "node:net";
 import { dirname as dirname9, join as join15, resolve as resolve3 } from "node:path";
+import { setTimeout as delay3 } from "node:timers/promises";
 import { fileURLToPath, pathToFileURL } from "node:url";
 var DEFAULT_LSP_PORT = 6005;
 var DIAGNOSTICS_TIMEOUT_MS = 5000;
@@ -29747,6 +29802,14 @@ class LSPTimeout extends Error {
     this.seconds = timeoutMs / 1000;
   }
 }
+var LANGUAGE_SERVER_START_MS = 30000;
+var LANGUAGE_SERVER_RETRY_MS = 250;
+
+class LanguageServerNotListening extends Error {
+  constructor(port, waitedMs) {
+    super(`The editor on the bridge says its language server is on port ${port}, and nothing accepted a connection there in ${String(waitedMs / 1000)}s. An editor starts it a few seconds after it reaches the bridge, so straight after editor_launch this is the editor still starting, and calling again answers. One that goes on refusing could not take the port; editor_output shows what the editor printed.`);
+  }
+}
 
 class ArgumentRefusal extends Refusal {
 }
@@ -29794,17 +29857,38 @@ class GodotLSPClient {
   documentVersions = new Map;
   documentTurns = new Map;
   timeouts;
+  servedHere;
   constructor(port = portFromEnv("GDHARNESS_LSP_PORT", DEFAULT_LSP_PORT), host = "127.0.0.1", timeouts = {
     requestMs: REQUEST_TIMEOUT_MS2,
     referencesMs: REFERENCES_TIMEOUT_MS,
-    initializeMs: initializeTimeoutMs()
-  }) {
+    initializeMs: initializeTimeoutMs(),
+    listenMs: LANGUAGE_SERVER_START_MS
+  }, servedHere = () => false) {
     this.port = port;
     this.host = host;
     this.timeouts = timeouts;
+    this.servedHere = servedHere;
     this.pendingRequests = new Map;
   }
   async connect() {
+    const until = Date.now() + this.timeouts.listenMs;
+    for (;; ) {
+      try {
+        await this.connectOnce();
+        return;
+      } catch (error) {
+        const refused = error instanceof Error && error.message.includes("ECONNREFUSED");
+        if (!refused || !this.servedHere()) {
+          throw error;
+        }
+        if (Date.now() >= until) {
+          throw new LanguageServerNotListening(this.port, this.timeouts.listenMs);
+        }
+        await delay3(LANGUAGE_SERVER_RETRY_MS);
+      }
+    }
+  }
+  async connectOnce() {
     if (this.connected && this.socket) {
       return;
     }
@@ -30493,7 +30577,8 @@ async function handleLSPTool(client, toolName, args) {
       ...error instanceof AnotherProjectsServer ? { serves: error.serves } : {},
       ...error instanceof ArgumentRefusal ? { refusedArguments: true } : {},
       ...error instanceof NoDiagnosticsPublished ? { aboutThisFile: true } : {},
-      ...error instanceof LSPTimeout && error.method === "initialize" ? { stillReading: true } : {}
+      ...error instanceof LSPTimeout && error.method === "initialize" ? { stillReading: true } : {},
+      ...error instanceof LanguageServerNotListening ? { stillReading: true } : {}
     });
   }
 }
@@ -30829,7 +30914,7 @@ function searchProject(projectPath, options) {
 
 // src/rename.ts
 import { existsSync as existsSync14, mkdirSync as mkdirSync8, readFileSync as readFileSync15, renameSync, unlinkSync as unlinkSync2, writeFileSync as writeFileSync10 } from "node:fs";
-import { dirname as dirname10, posix } from "node:path";
+import { dirname as dirname10, posix as posix2 } from "node:path";
 class Script {
   path;
   text;
@@ -30941,13 +31026,13 @@ class ClassGraph {
 }
 function resolvedPath(written, from) {
   if (written.startsWith("res://")) {
-    return `res://${posix.normalize(written.slice("res://".length))}`;
+    return `res://${posix2.normalize(written.slice("res://".length))}`;
   }
-  const directory = posix.dirname(from.slice("res://".length));
-  return `res://${posix.normalize(posix.join(directory, written))}`;
+  const directory = posix2.dirname(from.slice("res://".length));
+  return `res://${posix2.normalize(posix2.join(directory, written))}`;
 }
 function relativeTo(target, from) {
-  return posix.relative(posix.dirname(from.slice("res://".length)), target.slice("res://".length));
+  return posix2.relative(posix2.dirname(from.slice("res://".length)), target.slice("res://".length));
 }
 function scriptsOf(texts) {
   const scripts = new Map;
@@ -33678,7 +33763,7 @@ var TOOL_SPECS = [
   },
   {
     name: "script_diagnostics",
-    description: "Errors and warnings for a script, or for several, from the editor's language server, and whether each is clean. Needs the editor running. Each diagnostic carries its severity (error or warning), its message, and where it is as the editor shows it: line and column counted from 1, and endLine and endColumn just past its end. Diagnostics are checked against the project's own files, and the two that the files disprove are named rather than passed on: a member the class cache's file declares, a method, property, constant, static function or enum member, comes back under contradictedByTheFile, and a class this project declares that the diagnostic could not resolve comes back under typesTheEditorHasNotLoaded, with inTheClassCache saying whether a launched game would resolve it. staleAnalysis then says what to do, and for both states it is editor_rescan first: it asks the editor already running, starts nothing, and has cleared each in every reproduction measured. Two exceptions are named when they apply. For an enum member, constant or static function of a global class the reload comes first: in the one project that has reproduced a stale enum member, editor_rescan with reloadScript on the declaring script cleared it and a plain rescan did not. And an editor whose last scan wrote the class cache shorter than the file holds a list behind the files and writes it on every scan, so on that editor the rescan loads nothing and staleAnalysis says editor_launch restart instead. What follows differs: for a stale analysed type, editor_rescan with reloadScript recompiles the held copy and editor_launch restart is the last resort that costs a window; for a class missing from the cache, project_import refresh_classes rewrites the cache from disk at the cost of a short headless engine, which matters beside a running bench.",
+    description: "Errors and warnings for a script, or for several, from the editor's language server, and whether each is clean. Needs the editor running. Each diagnostic carries its severity (error or warning), its message, and where it is as the editor shows it: line and column counted from 1, and endLine and endColumn just past its end. Diagnostics are checked against the project's own files, and the two that the files disprove are named rather than passed on: a member the class cache's file declares, or a project class it extends does, a method, property, constant, static function or enum member, comes back under contradictedByTheFile with the script declaring it, and so does one a diagnostic names alone as an external class member, read against the class it is looked up on in the line it is on; and a class this project declares that the diagnostic could not resolve comes back under typesTheEditorHasNotLoaded, with inTheClassCache saying whether a launched game would resolve it. staleAnalysis then says what to do, and for both states it is editor_rescan first: it asks the editor already running, starts nothing, and has cleared each in every reproduction measured. Two exceptions are named when they apply. For an enum member, constant or static function of a global class the reload comes first: in the one project that has reproduced a stale enum member, editor_rescan with reloadScript on the declaring script cleared it and a plain rescan did not. And an editor whose last scan wrote the class cache shorter than the file holds a list behind the files and writes it on every scan, so on that editor the rescan loads nothing and staleAnalysis says editor_launch restart instead. What follows differs: for a stale analysed type, editor_rescan with reloadScript recompiles the held copy and editor_launch restart is the last resort that costs a window; for a class missing from the cache, project_import refresh_classes rewrites the cache from disk at the cost of a short headless engine, which matters beside a running bench.",
     parameters: {
       projectPath: PROJECT_PATH,
       scriptPath: {
@@ -33903,7 +33988,11 @@ 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. 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. A @tool script is not reloaded either, since it runs inside the editor and reloading one from inside a call can take the editor down: reloadProblem says so, and editor_launch restart recompiles it. A path spelled in another case than the file is reloaded under the spelling on disk, which is the one the editor holds its copy under, and that spelling comes back under reloadedAs."
+        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. What the reload changed comes back under methodsAdded, methodsRemoved, constantsAdded and constantsRemoved, with each enum value as Kind.SHORT among the constants, since an enum member is held as a constant and never shows among the methods; methodsHeld and constantsHeld count what the copy holds afterwards, because a reload that compiled nothing and answered OK is the failure worth catching. listMembers adds the whole lists. 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. A @tool script is not reloaded either, since it runs inside the editor and reloading one from inside a call can take the editor down: reloadProblem says so, and editor_launch restart recompiles it. A path spelled in another case than the file is reloaded under the spelling on disk, which is the one the editor holds its copy under, and that spelling comes back under reloadedAs."
+      },
+      listMembers: {
+        type: "boolean",
+        description: "With reloadScript: also answer the whole member lists, heldBeforeReload and reloadedMethods for the methods, heldConstantsBeforeReload and reloadedConstants for the constants. Default false: a script holding hundreds of constants answers hundreds of lines twice to say what one reload added."
       }
     },
     requires: ["projectPath"]
@@ -34589,7 +34678,7 @@ async function untilGone(pids, withinMs = STOP_WAIT_MS) {
   const gone = () => pids.every((pid) => !alive(pid));
   const deadline = Date.now() + withinMs;
   while (!gone() && Date.now() < deadline) {
-    await delay3(50);
+    await delay4(50);
   }
   return gone();
 }
@@ -35271,6 +35360,7 @@ function scriptsToDiagnose(projectPath, given) {
   }
   return { ok: true, value: unique };
 }
+var EXTERNAL_MEMBER = 'Could not resolve external class member "';
 function isDirectory(path) {
   try {
     return statSync8(path).isDirectory();
@@ -35450,7 +35540,7 @@ class GodotServer {
         taken = true;
         this.logDebug(`Took port ${wanted} over from pid ${announced.pid}`);
       } catch {
-        await delay3(HANDOVER_POLL_MS);
+        await delay4(HANDOVER_POLL_MS);
       }
     }
     this.notHandedOverBy = taken ? null : announced.pid;
@@ -37221,14 +37311,14 @@ class GodotServer {
   }
   whereTheFileDisagrees(diagnostics, args) {
     const messages = diagnostics.map((entry) => asParams(entry)["message"]).filter((message) => typeof message === "string");
-    const worthChecking = messages.some((message) => missingMemberIn(message) !== null || unknownTypeIn(message) !== null);
+    const worthChecking = messages.some((message) => missingMemberIn(message) !== null || unknownTypeIn(message) !== null || message.includes(EXTERNAL_MEMBER));
     const project = worthChecking ? this.project(args) : null;
     if (project === null || !project.ok) {
       return {};
     }
     const projectPath = project.value.path;
     const cached = cachedClasses(projectPath);
-    const contradicted = cached === null ? [] : contradictedDiagnostics(messages, cached, (resourcePath) => {
+    const sourceOf = (resourcePath) => {
       const contained = resolveWithinProject(projectPath, resourcePath);
       if (!contained.ok || !existsSync17(contained.absolutePath)) {
         return null;
@@ -37238,7 +37328,16 @@ class GodotServer {
       } catch {
         return null;
       }
-    });
+    };
+    const external = diagnostics.filter((entry) => String(asParams(entry)["message"]).includes(EXTERNAL_MEMBER));
+    const diagnosed = external.length === 0 ? null : sourceOf(readString(args, "scriptPath") ?? "");
+    const lines = diagnosed?.split(`
+`) ?? [];
+    const alsoDenied = cached === null ? [] : external.map((entry) => {
+      const { message, line } = asParams(entry);
+      return externalMemberIn(String(message), typeof line === "number" ? lines[line - 1] : undefined, cached);
+    }).filter((missing) => missing !== null);
+    const contradicted = cached === null ? [] : contradictedDiagnostics(messages, cached, sourceOf, alsoDenied);
     const unloaded = messages.some((message) => unknownTypeIn(message) !== null) ? unloadedTypes(messages, declaredClasses(projectPath), cached) : [];
     const notes = [];
     if (contradicted.length > 0) {
@@ -37308,7 +37407,10 @@ class GodotServer {
       await this.lspClient.disconnect();
       this.lspClient = null;
     }
-    this.lspClient ??= new GodotLSPClient(port);
+    this.lspClient ??= new GodotLSPClient(port, undefined, undefined, () => {
+      const status = this.godotBridge.getStatus();
+      return status.connected && status.lspPort === port;
+    });
     return this.lspClient;
   }
   async handleDAP(toolName, args) {
@@ -37488,7 +37590,7 @@ class GodotServer {
     try {
       const askedAt = Date.now();
       const asked = this.godotBridge.invokeTool("playing_status", {});
-      const answer = await Promise.race([asked, delay3(PLAYING_STATUS_MS).then(() => null)]);
+      const answer = await Promise.race([asked, delay4(PLAYING_STATUS_MS).then(() => null)]);
       if (answer === null) {
         this.logDebug(`playing_status did not answer within ${PLAYING_STATUS_MS}ms`);
         asked.then(() => {
@@ -37513,7 +37615,7 @@ class GodotServer {
     try {
       const answer = await Promise.race([
         this.godotBridge.invokeTool("scan_status", {}),
-        delay3(PLAYING_STATUS_MS).then(() => null)
+        delay4(PLAYING_STATUS_MS).then(() => null)
       ]);
       if (answer === null) {
         return null;
@@ -37725,7 +37827,7 @@ class GodotServer {
       if (Date.now() >= deadline) {
         return false;
       }
-      await delay3(250);
+      await delay4(250);
     }
   }
   async handleLaunchEditor(args) {
@@ -38235,7 +38337,7 @@ class GodotServer {
       if (Date.now() >= deadline) {
         return false;
       }
-      await delay3(100);
+      await delay4(100);
     }
   }
   async endActiveGame(reason, going) {
@@ -38827,7 +38929,7 @@ class GodotServer {
     while (cancelled?.aborted !== true && await this.runStillGoing(run) && Date.now() < until) {
       this.drainEditorOutput(run);
       this.drainTranscript(run);
-      await delay3(RUN_POLL_MS);
+      await delay4(RUN_POLL_MS);
     }
     return await this.handleGetDebugOutput(args, await this.runStillGoing(run) ? budgetMs : undefined);
   }
@@ -38864,7 +38966,7 @@ class GodotServer {
       if (Date.now() >= until) {
         return false;
       }
-      await delay3(50);
+      await delay4(50);
     }
   }
   async handleEditorConsole(args) {
@@ -39374,10 +39476,13 @@ class GodotServer {
       waitedMs: Date.now() - started,
       waitedForEditorScanMs: waitedForEditorMs > 0 ? waitedForEditorMs : undefined,
       reloadedAs: reloaded.as,
-      heldBeforeReload: reloaded.heldBefore,
-      reloadedMethods: reloaded.methods,
-      heldConstantsBeforeReload: reloaded.heldConstantsBefore,
-      reloadedConstants: reloaded.constants,
+      ...reloadDifference(reloaded),
+      ...args["listMembers"] === true ? {
+        heldBeforeReload: reloaded.heldBefore,
+        reloadedMethods: reloaded.methods,
+        heldConstantsBeforeReload: reloaded.heldConstantsBefore,
+        reloadedConstants: reloaded.constants
+      } : {},
       reloadProblem: reloaded.problem,
       unseenByEditor: unseen.length > 0 ? unseen : undefined,
       broughtIn: broughtIn.length > 0 ? broughtIn : undefined,

package/package.json

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