gdharness 1.1.15 → 1.1.17

package/build/cli.js

@@ -8571,20 +8571,57 @@ function withAddonClassesCounted(rebuilt, listed) {
   return counted;
 }
 function missingMemberIn(message) {
-  const found = /The (method|property) "([^"(]+)(?:\(\))?" is not present on the inferred type "([^"]+)"/.exec(message);
-  if (found === null) {
+  const inferred = /The (method|property) "([^"(]+)(?:\(\))?" is not present on the inferred type "([^"]+)"/.exec(message);
+  if (inferred !== null) {
+    return {
+      kind: inferred[1] === "property" ? "property" : "method",
+      member: inferred[2] ?? "",
+      type: inferred[3] ?? ""
+    };
+  }
+  const called = /Static function "([A-Za-z_]\w*)\(\)" not found in base "([A-Za-z_]\w*)"/.exec(message);
+  if (called !== null) {
+    return { kind: "static method", member: called[1] ?? "", type: called[2] ?? "" };
+  }
+  const inBase = /Cannot find member "([A-Za-z_]\w*)" in base "([A-Za-z_]\w*)((?:\.[A-Za-z_]\w*)*)"/.exec(message);
+  if (inBase === null) {
     return null;
   }
-  return {
-    kind: found[1] === "property" ? "property" : "method",
-    member: found[2] ?? "",
-    type: found[3] ?? ""
-  };
+  const member = inBase[1] ?? "";
+  const type = inBase[2] ?? "";
+  const within = (inBase[3] ?? "").split(".").filter((part) => part !== "");
+  const enumName = within.at(-1);
+  return enumName === undefined ? { kind: "member", member, type } : { kind: "enum member", member, type, enum: enumName };
 }
 function declaresMember(source, missing) {
   const name = missing.member.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const declaration = missing.kind === "method" ? new RegExp(String.raw`^\s*(?:static\s+)?func\s+${name}\s*\(`, "m") : new RegExp(String.raw`^\s*(?:static\s+)?(?:@export\s+)?(?:var|const)\s+${name}\b`, "m");
-  return declaration.test(source);
+  if (missing.kind === "method") {
+    return new RegExp(String.raw`^\s*(?:static\s+)?func\s+${name}\s*\(`, "m").test(source);
+  }
+  if (missing.kind === "static method") {
+    return new RegExp(String.raw`^\s*static\s+func\s+${name}\s*\(`, "m").test(source);
+  }
+  if (missing.kind === "enum member") {
+    return enumValues(source, missing.enum ?? "").includes(missing.member);
+  }
+  const kinds = missing.kind === "property" ? "var|const|enum|class|signal|func" : "var|const|enum|class|signal";
+  return new RegExp(String.raw`^\s*(?:static\s+)?(?:@\w+(?:\([^)]*\))?\s+)*(?:${kinds})\s+${name}\b`, "m").test(source) || enumValues(source, null).includes(missing.member);
+}
+function enumValues(source, named) {
+  const opening = named === null ? /^\s*enum\s*\{([^}]*)\}/gm : new RegExp(String.raw`^\s*enum\s+${named.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\s*\{([^}]*)\}`, "gm");
+  const values = [];
+  for (const [, body] of source.matchAll(opening)) {
+    const uncommented = (body ?? "").split(`
+`).map((line) => line.replace(/#.*$/, "")).join(`
+`);
+    for (const part of uncommented.split(",")) {
+      const value = /^\s*([A-Za-z_]\w*)/.exec(part)?.[1];
+      if (value !== undefined) {
+        values.push(value);
+      }
+    }
+  }
+  return values;
 }
 function unknownTypeIn(message) {
   const found = /(?:Could not find (?:base class|type)|Cannot find class|Identifier) "?([A-Za-z_][A-Za-z0-9_]*)"?(?: not declared| in the current scope|\b)/.exec(message);
@@ -8615,7 +8652,7 @@ function classesNamedIn(source, known) {
 }
 function contradictedDiagnostics(messages, classes, sourceOf) {
   const read = new Map;
-  const found = [];
+  const found = new Map;
   for (const message of messages) {
     const missing = missingMemberIn(message);
     const declaredIn = missing === null ? undefined : classes.get(missing.type);
@@ -8626,20 +8663,60 @@ function contradictedDiagnostics(messages, classes, sourceOf) {
       read.set(declaredIn, sourceOf(declaredIn));
     }
     const source = read.get(declaredIn) ?? null;
-    if (source !== null && declaresMember(source, missing)) {
-      found.push({ ...missing, declaredIn });
+    const key = [missing.type, missing.enum ?? "", missing.member].join(".");
+    const already = found.get(key);
+    if (source !== null && declaresMember(source, missing) && already?.kind !== "static method") {
+      found.set(key, { ...missing, declaredIn });
     }
   }
-  return found;
+  return [...found.values()];
 }
 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 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.",
+    instanceRemedy(onInstances, dependsOn, onTheClass.length > 0),
+    classRemedy(onTheClass)
+  ].filter((part) => part !== "").join(" ");
+}
+function written(one) {
+  return [one.type, ...one.enum === undefined ? [] : [one.enum], one.member].join(".");
+}
+function declaringScripts(entries) {
+  return [...new Set(entries.map((one) => one.declaredIn))].sort();
+}
+function instanceRemedy(entries, dependsOn, besideOthers) {
+  if (entries.length === 0) {
+    return "";
+  }
+  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 `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, 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 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.";
+}
+function classRemedy(entries) {
+  if (entries.length === 0) {
+    return "";
+  }
+  const declaring = declaringScripts(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) {
@@ -17055,7 +17132,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "script_diagnostics",
-      description: "Errors and warnings for a script from the editor's language server, and whether the script is clean. Needs the editor running. 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 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. The one exception is named when it applies: 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 from the editor's language server, and whether the script is clean. Needs the editor running. 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.",
       parameters: {
         projectPath: PROJECT_PATH,
         scriptPath: SCRIPT_PATH
@@ -17276,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."
+          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"]
@@ -17537,7 +17614,7 @@ var init_tool_definitions = __esm(() => {
         pressed: {
           type: "boolean",
           ops: ["action", "key", "mouse_click"],
-          description: "action, key: leave it out and the press is a whole one, down and up a frame apart. true holds it down, false lets go of one being held. mouse_click is one raw event, so it is down unless you say false; a wheel button down is a whole step, since a wheel is never held."
+          description: "action, key, mouse_click: leave it out and the press is a whole one, down and up a frame apart. true holds it down, false lets go of one being held. A wheel button held down is still a whole step, since a wheel is never held."
         },
         strength: {
           type: "number",
@@ -17621,7 +17698,7 @@ var init_tool_definitions = __esm(() => {
           requires: ["text"]
         },
         mouse_click: {
-          summary: "one mouse button event at a position, carrying the buttons held once it has happened. A drag is a press held with pressed true, motions, and a release with pressed false. A wheel button is a whole step, press and release together as a mouse sends one, and the answer says released: a lone wheel press holds the viewport on the control that took it, so every click after it lands there",
+          summary: "click a mouse button at a position, pressed and released a frame apart, each event carrying the buttons held once it has happened; the answer says whole. A drag is a press held with pressed true, motions, and a release with pressed false. A wheel button is always a whole step, press and release together as a mouse sends one: a lone wheel press holds the viewport on the control that took it, so every click after it lands there",
           requires: ["x", "y"]
         },
         mouse_motion: {
@@ -41232,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)) {
@@ -42958,8 +43040,34 @@ class GodotServer {
       try {
         const answer = asParams(await this.godotBridge.invokeTool("reload_script", { ...args, scriptPath: reloading }));
         const methods = readArray(answer, "methods");
-        const before = readArray(answer, "heldBefore");
-        reloaded = methods ? { methods: methods.map(String), ...before ? { heldBefore: before.map(String) } : {} } : { problem: `the editor would not say what ${reloading} has after reloading it` };
+        const listed = (field) => {
+          const found = readArray(answer, field);
+          return found ? { [field]: found.map(String) } : {};
+        };
+        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)}` };
       }
@@ -42994,6 +43102,8 @@ class GodotServer {
       waitedForEditorScanMs: waitedForEditorMs > 0 ? waitedForEditorMs : undefined,
       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,
@@ -43020,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

@@ -64,6 +64,7 @@ func reload_script(args: Dictionary) -> Dictionary:
 	# than the one that mends it. Without it a caller cannot tell a copy that was already current
 	# from one this call repaired, and those are different facts about their editor.
 	var held: Array[String] = _method_names(script)
+	var held_constants: Array[String] = _constant_names(script)
 
 	# The source is read off disk and put back before reloading, which is the whole of the fix and
 	# is not obvious. `reload` recompiles from the object's own `source_code`, not from the file, so
@@ -73,14 +74,27 @@ 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)}
-
-	return {"ok": true, "script": path, "heldBefore": held, "methods": _method_names(script)}
+		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,
+		"constants": _constant_names(script),
+	}
 
 
 func _method_names(script: GDScript) -> Array[String]:
@@ -91,6 +105,24 @@ func _method_names(script: GDScript) -> Array[String]:
 	return names
 
 
+## The script's own constants, and the keys of each one that is a Dictionary as `Kind.SHORT`, which
+## is how the copy holds a named enum: a stale enum member is denied as a member of the enum rather
+## than of the class. A constant Dictionary that is not an enum is listed the same way, since the
+## map does not tell the two apart.
+func _constant_names(script: GDScript) -> Array[String]:
+	var names: Array[String] = []
+	var constants: Dictionary = script.get_script_constant_map()
+	for named: Variant in constants:
+		var value: Variant = constants[named]
+		names.append(str(named))
+		if value is Dictionary:
+			var values: Dictionary = value
+			for member: Variant in values:
+				names.append("%s.%s" % [named, member])
+	names.sort()
+	return names
+
+
 func global_classes(_args: Dictionary) -> Dictionary:
 	if not _editor_plugin:
 		return {"ok": false, "error": "Editor plugin unavailable"}

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

@@ -353,6 +353,14 @@ func _read_point(params: Dictionary, x_key: String, y_key: String, pair_key: Str
 	return "%s must be Vector2 or [x, y]" % pair_key
 
 
+## Clicks a mouse button at a position, and lets go of it again unless asked to hold it.
+##
+## The whole click by default, for the reason [method inject_action] is the whole press, and
+## because much of a UI acts on the release: a rich label opens its link then, so a click on one
+## answered input_injected and opened nothing, while the same op on the wheel was already whole.
+##
+## `pressed` is how a caller asks for one half, the way a drag is made: true holds the button down,
+## false lets go of one being held.
 func inject_mouse_click(params: Dictionary) -> Dictionary:
 	var point: Variant = _read_point(params, "x", "y", "position")
 	if point is String:
@@ -361,32 +369,37 @@ func inject_mouse_click(params: Dictionary) -> Dictionary:
 	var button: int = _resolve_mouse_button(params.get("button", MOUSE_BUTTON_LEFT))
 	if button < 0:
 		return _no_such_button(params.get("button"))
-	var pressed: bool = Read.as_bool(params.get("pressed", true), true)
+	var held: bool = Read.as_bool(params.get("pressed", true), true)
 	var double: bool = Read.as_bool(params.get("doubleClick", false))
-
-	# A button pressed somewhere puts the pointer there: the motion after a held press measures
-	# its drag from the press, which is where a real pointer would be.
-	var _moved: Vector2 = _arrive(position)
-	Input.parse_input_event(_button(position, button, pressed, double))
 	# A wheel step is a press and a release together, as a mouse sends one: there is no holding a
 	# wheel. A lone wheel press left the viewport's mouse focus on the control that took it, with
 	# the wheel's bit in the focus mask, and every click after it landed on that control rather
 	# than under the pointer, landing true and doing nothing, until a release was sent by hand.
-	var notch: bool = pressed and _mask_of(button) == 0
+	var notch: bool = held and _mask_of(button) == 0
+	var whole: bool = notch or not params.has("pressed")
+
+	# A button pressed somewhere puts the pointer there: the motion after a held press measures
+	# its drag from the press, which is where a real pointer would be.
+	var _moved: Vector2 = _arrive(position)
+	Input.parse_input_event(_button(position, button, whole or held, double))
 	if notch:
 		Input.parse_input_event(_button(position, button, false, false))
+	elif whole:
+		# A frame between the halves, as inject_action has, so a control that acts on the press and
+		# one that acts on the release each get a frame to do it in.
+		await _host.get_tree().process_frame
+		Input.parse_input_event(_button(position, button, false, false))
+		await _host.get_tree().process_frame
 
-	var answer: Dictionary = {
+	return {
 		"type": "input_injected",
 		"input_type": "mouse_click",
 		"position": [position.x, position.y],
 		"button": button,
-		"pressed": pressed,
+		"pressed": held and not whole,
+		"whole": whole,
 		"double": double
 	}
-	if notch:
-		answer["released"] = true
-	return answer
 
 
 ## Moves the pointer to a position, with the movement the event carries taken from where the

package/build/index.js

@@ -26141,20 +26141,57 @@ function withAddonClassesCounted(rebuilt, listed) {
   return counted;
 }
 function missingMemberIn(message) {
-  const found = /The (method|property) "([^"(]+)(?:\(\))?" is not present on the inferred type "([^"]+)"/.exec(message);
-  if (found === null) {
+  const inferred = /The (method|property) "([^"(]+)(?:\(\))?" is not present on the inferred type "([^"]+)"/.exec(message);
+  if (inferred !== null) {
+    return {
+      kind: inferred[1] === "property" ? "property" : "method",
+      member: inferred[2] ?? "",
+      type: inferred[3] ?? ""
+    };
+  }
+  const called = /Static function "([A-Za-z_]\w*)\(\)" not found in base "([A-Za-z_]\w*)"/.exec(message);
+  if (called !== null) {
+    return { kind: "static method", member: called[1] ?? "", type: called[2] ?? "" };
+  }
+  const inBase = /Cannot find member "([A-Za-z_]\w*)" in base "([A-Za-z_]\w*)((?:\.[A-Za-z_]\w*)*)"/.exec(message);
+  if (inBase === null) {
     return null;
   }
-  return {
-    kind: found[1] === "property" ? "property" : "method",
-    member: found[2] ?? "",
-    type: found[3] ?? ""
-  };
+  const member = inBase[1] ?? "";
+  const type = inBase[2] ?? "";
+  const within = (inBase[3] ?? "").split(".").filter((part) => part !== "");
+  const enumName = within.at(-1);
+  return enumName === undefined ? { kind: "member", member, type } : { kind: "enum member", member, type, enum: enumName };
 }
 function declaresMember(source, missing) {
   const name = missing.member.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const declaration = missing.kind === "method" ? new RegExp(String.raw`^\s*(?:static\s+)?func\s+${name}\s*\(`, "m") : new RegExp(String.raw`^\s*(?:static\s+)?(?:@export\s+)?(?:var|const)\s+${name}\b`, "m");
-  return declaration.test(source);
+  if (missing.kind === "method") {
+    return new RegExp(String.raw`^\s*(?:static\s+)?func\s+${name}\s*\(`, "m").test(source);
+  }
+  if (missing.kind === "static method") {
+    return new RegExp(String.raw`^\s*static\s+func\s+${name}\s*\(`, "m").test(source);
+  }
+  if (missing.kind === "enum member") {
+    return enumValues(source, missing.enum ?? "").includes(missing.member);
+  }
+  const kinds = missing.kind === "property" ? "var|const|enum|class|signal|func" : "var|const|enum|class|signal";
+  return new RegExp(String.raw`^\s*(?:static\s+)?(?:@\w+(?:\([^)]*\))?\s+)*(?:${kinds})\s+${name}\b`, "m").test(source) || enumValues(source, null).includes(missing.member);
+}
+function enumValues(source, named) {
+  const opening = named === null ? /^\s*enum\s*\{([^}]*)\}/gm : new RegExp(String.raw`^\s*enum\s+${named.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\s*\{([^}]*)\}`, "gm");
+  const values = [];
+  for (const [, body] of source.matchAll(opening)) {
+    const uncommented = (body ?? "").split(`
+`).map((line) => line.replace(/#.*$/, "")).join(`
+`);
+    for (const part of uncommented.split(",")) {
+      const value = /^\s*([A-Za-z_]\w*)/.exec(part)?.[1];
+      if (value !== undefined) {
+        values.push(value);
+      }
+    }
+  }
+  return values;
 }
 function unknownTypeIn(message) {
   const found = /(?:Could not find (?:base class|type)|Cannot find class|Identifier) "?([A-Za-z_][A-Za-z0-9_]*)"?(?: not declared| in the current scope|\b)/.exec(message);
@@ -26185,7 +26222,7 @@ function classesNamedIn(source, known) {
 }
 function contradictedDiagnostics(messages, classes, sourceOf) {
   const read = new Map;
-  const found = [];
+  const found = new Map;
   for (const message of messages) {
     const missing = missingMemberIn(message);
     const declaredIn = missing === null ? undefined : classes.get(missing.type);
@@ -26196,20 +26233,60 @@ function contradictedDiagnostics(messages, classes, sourceOf) {
       read.set(declaredIn, sourceOf(declaredIn));
     }
     const source = read.get(declaredIn) ?? null;
-    if (source !== null && declaresMember(source, missing)) {
-      found.push({ ...missing, declaredIn });
+    const key = [missing.type, missing.enum ?? "", missing.member].join(".");
+    const already = found.get(key);
+    if (source !== null && declaresMember(source, missing) && already?.kind !== "static method") {
+      found.set(key, { ...missing, declaredIn });
     }
   }
-  return found;
+  return [...found.values()];
 }
 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 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.",
+    instanceRemedy(onInstances, dependsOn, onTheClass.length > 0),
+    classRemedy(onTheClass)
+  ].filter((part) => part !== "").join(" ");
+}
+function written(one) {
+  return [one.type, ...one.enum === undefined ? [] : [one.enum], one.member].join(".");
+}
+function declaringScripts(entries) {
+  return [...new Set(entries.map((one) => one.declaredIn))].sort();
+}
+function instanceRemedy(entries, dependsOn, besideOthers) {
+  if (entries.length === 0) {
+    return "";
+  }
+  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 `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, 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 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.";
+}
+function classRemedy(entries) {
+  if (entries.length === 0) {
+    return "";
+  }
+  const declaring = declaringScripts(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) {
@@ -30712,7 +30789,7 @@ var TOOL_SPECS = [
   },
   {
     name: "script_diagnostics",
-    description: "Errors and warnings for a script from the editor's language server, and whether the script is clean. Needs the editor running. 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 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. The one exception is named when it applies: 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 from the editor's language server, and whether the script is clean. Needs the editor running. 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.",
     parameters: {
       projectPath: PROJECT_PATH,
       scriptPath: SCRIPT_PATH
@@ -30933,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."
+        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"]
@@ -31194,7 +31271,7 @@ var TOOL_SPECS = [
       pressed: {
         type: "boolean",
         ops: ["action", "key", "mouse_click"],
-        description: "action, key: leave it out and the press is a whole one, down and up a frame apart. true holds it down, false lets go of one being held. mouse_click is one raw event, so it is down unless you say false; a wheel button down is a whole step, since a wheel is never held."
+        description: "action, key, mouse_click: leave it out and the press is a whole one, down and up a frame apart. true holds it down, false lets go of one being held. A wheel button held down is still a whole step, since a wheel is never held."
       },
       strength: {
         type: "number",
@@ -31278,7 +31355,7 @@ var TOOL_SPECS = [
         requires: ["text"]
       },
       mouse_click: {
-        summary: "one mouse button event at a position, carrying the buttons held once it has happened. A drag is a press held with pressed true, motions, and a release with pressed false. A wheel button is a whole step, press and release together as a mouse sends one, and the answer says released: a lone wheel press holds the viewport on the control that took it, so every click after it lands there",
+        summary: "click a mouse button at a position, pressed and released a frame apart, each event carrying the buttons held once it has happened; the answer says whole. A drag is a press held with pressed true, motions, and a release with pressed false. A wheel button is always a whole step, press and release together as a mouse sends one: a lone wheel press holds the viewport on the control that took it, so every click after it lands there",
         requires: ["x", "y"]
       },
       mouse_motion: {
@@ -33692,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)) {
@@ -35418,8 +35500,34 @@ class GodotServer {
       try {
         const answer = asParams(await this.godotBridge.invokeTool("reload_script", { ...args, scriptPath: reloading }));
         const methods = readArray(answer, "methods");
-        const before = readArray(answer, "heldBefore");
-        reloaded = methods ? { methods: methods.map(String), ...before ? { heldBefore: before.map(String) } : {} } : { problem: `the editor would not say what ${reloading} has after reloading it` };
+        const listed = (field) => {
+          const found = readArray(answer, field);
+          return found ? { [field]: found.map(String) } : {};
+        };
+        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)}` };
       }
@@ -35454,6 +35562,8 @@ class GodotServer {
       waitedForEditorScanMs: waitedForEditorMs > 0 ? waitedForEditorMs : undefined,
       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,
@@ -35480,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.15",
+  "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",