gdharness 1.1.14 → 1.1.16

package/build/cli.js

@@ -605,8 +605,18 @@ function resolveHeadless(requested, host) {
   }
   return envValue("DISPLAY", host.variables) === undefined && envValue("WAYLAND_DISPLAY", host.variables) === undefined;
 }
+function resolveSilent(requested, variables) {
+  if (typeof requested === "boolean") {
+    return requested;
+  }
+  const said = envValue("GDHARNESS_SILENT", variables)?.toLowerCase();
+  return said !== undefined && said !== "0" && said !== "false";
+}
 function runArguments(options) {
   const args = options.headless ? ["--headless", "--path", options.projectPath] : ["--path", options.projectPath];
+  if (options.silent === true && !options.headless) {
+    args.push("--audio-driver", "Dummy");
+  }
   if (options.quitAfter !== undefined && options.quitAfter !== null) {
     args.push("--quit-after", String(options.quitAfter));
   }
@@ -8561,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);
@@ -8605,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);
@@ -8616,20 +8663,48 @@ 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 uncachedClassNote(types) {
   if (types.length === 0) {
@@ -17045,7 +17120,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
@@ -17137,6 +17212,11 @@ var init_tool_definitions = __esm(() => {
           ops: ["start"],
           description: "start: on Windows, show the window on the desktop in use. By default a windowed run this server starts goes on a desktop of its own, where it renders and runtime_capture works but the window never shows and never takes the keyboard. A game a visible editor plays opens on the desktop in use, and one a hidden editor (editor_launch hidden: true) plays goes on its desktop. Elsewhere than Windows the window shows either way. Default false."
         },
+        silent: {
+          type: "boolean",
+          ops: ["start"],
+          description: "start: run the game with no sound out of the machine, by starting the engine with --audio-driver Dummy: every stream still plays and every playback position still advances, so what is playing can still be asked. The editor takes no engine flags for a game it plays, so a silent windowed run is started by this server, and the debug_* tools do not answer for it. A headless run, check's included, is silent already. Default false, or true when GDHARNESS_SILENT is set in the server's environment to anything but 0 or false; silent: false then plays through the editor as before."
+        },
         savesIn: {
           type: "string",
           ops: ["start", "check"],
@@ -17261,7 +17341,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."
         }
       },
       requires: ["projectPath"]
@@ -17522,7 +17602,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",
@@ -17606,7 +17686,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: {
@@ -41722,14 +41802,16 @@ class GodotServer {
     });
     const runtimeWaitMs = this.announceBudget(args, project.value.path);
     const editorWouldPlay = !headless || editorPlaysHeadless(project.value.file);
-    if (this.godotBridge.isConnected() && editorWouldPlay && given.value.length === 0 && !needsItsOwnProcess(asked.value)) {
+    const silent = resolveSilent(args["silent"], process.env) && !headless;
+    if (this.godotBridge.isConnected() && editorWouldPlay && given.value.length === 0 && !needsItsOwnProcess(asked.value) && !silent) {
       return await this.playThroughEditor(sceneArgument, refreshed.value, scanned, project.value.path, alreadyPlaying, runtimeWaitMs, ended);
     }
     const cmdArgs = runArguments({
       projectPath: project.value.path,
       headless,
       scene: sceneArgument,
-      userArgs: given.value
+      userArgs: given.value,
+      silent
     });
     this.logDebug(`Running Godot project: ${engine.value} ${cmdArgs.join(" ")}`);
     const started = await this.launchKeptGame(engine.value, cmdArgs, project.value.path, needsItsOwnProcess(asked.value) ? environmentFor({ ...asked.value, runtimeDirectory: runtimeDirectory() }) : undefined, headless || args["visible"] === true ? undefined : HIDDEN_DESKTOP);
@@ -41740,7 +41822,7 @@ class GodotServer {
     }
     started.announcedBefore = alreadyPlaying;
     this.activeProcess = started;
-    const spawnedInstead = this.godotBridge.isConnected() && editorWouldPlay && given.value.length > 0 ? " The editor cannot be handed arguments for a game it plays, so this one was started " + "here: the debug_* tools answer only for a game the editor is playing." : this.godotBridge.isConnected() && editorWouldPlay && needsItsOwnProcess(asked.value) ? " The editor plays a game with its own environment, so a run given one was started " + "here: the debug_* tools answer only for a game the editor is playing." : "";
+    const spawnedInstead = this.godotBridge.isConnected() && editorWouldPlay && given.value.length > 0 ? " The editor cannot be handed arguments for a game it plays, so this one was started " + "here: the debug_* tools answer only for a game the editor is playing." : this.godotBridge.isConnected() && editorWouldPlay && needsItsOwnProcess(asked.value) ? " The editor plays a game with its own environment, so a run given one was started " + "here: the debug_* tools answer only for a game the editor is playing." : this.godotBridge.isConnected() && editorWouldPlay && silent ? " The editor cannot play a game silent, which takes an engine flag, so this one was " + `started here${args["silent"] === true ? "" : ", silent because GDHARNESS_SILENT says so"}: the debug_* tools answer only for a game the editor is playing, and silent: false plays it through the editor.` : "";
     const endedForThis = endedToStartThis(ended);
     const stranded = wereHereFirst.filter((one) => one.pid !== ended?.pid && alive(one.pid));
     const alsoRunning = leftRunningNote(stranded);
@@ -42941,8 +43023,16 @@ 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) } : {};
+        };
+        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)}` };
       }
@@ -42977,6 +43067,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,

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
@@ -80,7 +81,14 @@ func reload_script(args: Dictionary) -> Dictionary:
 	if failed != OK:
 		return {"ok": false, "error": "Reloading " + path + " answered error " + str(failed)}
 
-	return {"ok": true, "script": path, "heldBefore": held, "methods": _method_names(script)}
+	return {
+		"ok": true,
+		"script": path,
+		"heldBefore": held,
+		"methods": _method_names(script),
+		"heldConstantsBefore": held_constants,
+		"constants": _constant_names(script),
+	}
 
 
 func _method_names(script: GDScript) -> Array[String]:
@@ -91,6 +99,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

@@ -39,6 +39,11 @@ var _values: Values
 var _pointer: Vector2 = Vector2.ZERO
 var _pointer_placed: bool = false
 
+## When the pointer last arrived, and how long it took over the arrival before that, in seconds: what
+## turns a motion's distance into the speed a real one carries.
+var _pointer_at_usec: int = 0
+var _arrival_seconds: float = 1.0 / 60.0
+
 
 func _init(host: Node, values: Values) -> void:
 	_host = host
@@ -46,9 +51,15 @@ func _init(host: Node, values: Values) -> void:
 
 
 ## The movement a pointer arriving at [param position] carries, which is the distance from where
-## the last injected event put it, and none at all for the first. The arrival is recorded.
+## the last injected event put it, and none at all for the first. The arrival is recorded, with how
+## long it took: at least a frame, since two motions sent in one frame did not cross the screen in
+## no time at all.
 func _arrive(position: Vector2) -> Vector2:
+	var now: int = Time.get_ticks_usec()
 	var relative: Vector2 = position - _pointer if _pointer_placed else Vector2.ZERO
+	var took: float = float(now - _pointer_at_usec) / 1_000_000.0 if _pointer_placed else 0.0
+	_arrival_seconds = maxf(took, 1.0 / 60.0)
+	_pointer_at_usec = now
 	_pointer = position
 	_pointer_placed = true
 	return relative
@@ -342,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:
@@ -350,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
@@ -839,12 +863,19 @@ func _click_in_the_world(node_path: String, item: Node3D, params: Dictionary) ->
 ## The buttons a real pointer event carries are the ones held as it happens, and Input keeps that
 ## from every button event it is given, injected ones included, so a motion between a held click
 ## and its release is a drag to a control that reads the mask rather than remembering the click.
+##
+## And the speed, the distance over the time the pointer took, which only the platform fills in. A
+## menu ignores a motion with none, so that one opening under a resting pointer lights nothing: a
+## motion over an open drop-down's item answered as injected and the menu highlighted nothing. A
+## motion that goes nowhere still has none, as a resting pointer does.
 func _motion(position: Vector2, relative: Vector2) -> InputEventMouseMotion:
 	var event: InputEventMouseMotion = InputEventMouseMotion.new()
 	event.position = position
 	event.global_position = position
 	event.relative = relative
 	event.screen_relative = relative
+	event.velocity = relative / _arrival_seconds
+	event.screen_velocity = event.velocity
 	event.button_mask = Input.get_mouse_button_mask()
 	return event
 

package/build/index.js

@@ -24825,8 +24825,18 @@ function resolveHeadless(requested, host) {
   }
   return envValue("DISPLAY", host.variables) === undefined && envValue("WAYLAND_DISPLAY", host.variables) === undefined;
 }
+function resolveSilent(requested, variables) {
+  if (typeof requested === "boolean") {
+    return requested;
+  }
+  const said = envValue("GDHARNESS_SILENT", variables)?.toLowerCase();
+  return said !== undefined && said !== "0" && said !== "false";
+}
 function runArguments(options) {
   const args = options.headless ? ["--headless", "--path", options.projectPath] : ["--path", options.projectPath];
+  if (options.silent === true && !options.headless) {
+    args.push("--audio-driver", "Dummy");
+  }
   if (options.quitAfter !== undefined && options.quitAfter !== null) {
     args.push("--quit-after", String(options.quitAfter));
   }
@@ -26131,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);
@@ -26175,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);
@@ -26186,20 +26233,48 @@ 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 uncachedClassNote(types) {
   if (types.length === 0) {
@@ -30702,7 +30777,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
@@ -30794,6 +30869,11 @@ var TOOL_SPECS = [
         ops: ["start"],
         description: "start: on Windows, show the window on the desktop in use. By default a windowed run this server starts goes on a desktop of its own, where it renders and runtime_capture works but the window never shows and never takes the keyboard. A game a visible editor plays opens on the desktop in use, and one a hidden editor (editor_launch hidden: true) plays goes on its desktop. Elsewhere than Windows the window shows either way. Default false."
       },
+      silent: {
+        type: "boolean",
+        ops: ["start"],
+        description: "start: run the game with no sound out of the machine, by starting the engine with --audio-driver Dummy: every stream still plays and every playback position still advances, so what is playing can still be asked. The editor takes no engine flags for a game it plays, so a silent windowed run is started by this server, and the debug_* tools do not answer for it. A headless run, check's included, is silent already. Default false, or true when GDHARNESS_SILENT is set in the server's environment to anything but 0 or false; silent: false then plays through the editor as before."
+      },
       savesIn: {
         type: "string",
         ops: ["start", "check"],
@@ -30918,7 +30998,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."
       }
     },
     requires: ["projectPath"]
@@ -31179,7 +31259,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",
@@ -31263,7 +31343,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: {
@@ -34182,14 +34262,16 @@ class GodotServer {
     });
     const runtimeWaitMs = this.announceBudget(args, project.value.path);
     const editorWouldPlay = !headless || editorPlaysHeadless(project.value.file);
-    if (this.godotBridge.isConnected() && editorWouldPlay && given.value.length === 0 && !needsItsOwnProcess(asked.value)) {
+    const silent = resolveSilent(args["silent"], process.env) && !headless;
+    if (this.godotBridge.isConnected() && editorWouldPlay && given.value.length === 0 && !needsItsOwnProcess(asked.value) && !silent) {
       return await this.playThroughEditor(sceneArgument, refreshed.value, scanned, project.value.path, alreadyPlaying, runtimeWaitMs, ended);
     }
     const cmdArgs = runArguments({
       projectPath: project.value.path,
       headless,
       scene: sceneArgument,
-      userArgs: given.value
+      userArgs: given.value,
+      silent
     });
     this.logDebug(`Running Godot project: ${engine.value} ${cmdArgs.join(" ")}`);
     const started = await this.launchKeptGame(engine.value, cmdArgs, project.value.path, needsItsOwnProcess(asked.value) ? environmentFor({ ...asked.value, runtimeDirectory: runtimeDirectory() }) : undefined, headless || args["visible"] === true ? undefined : HIDDEN_DESKTOP);
@@ -34200,7 +34282,7 @@ class GodotServer {
     }
     started.announcedBefore = alreadyPlaying;
     this.activeProcess = started;
-    const spawnedInstead = this.godotBridge.isConnected() && editorWouldPlay && given.value.length > 0 ? " The editor cannot be handed arguments for a game it plays, so this one was started " + "here: the debug_* tools answer only for a game the editor is playing." : this.godotBridge.isConnected() && editorWouldPlay && needsItsOwnProcess(asked.value) ? " The editor plays a game with its own environment, so a run given one was started " + "here: the debug_* tools answer only for a game the editor is playing." : "";
+    const spawnedInstead = this.godotBridge.isConnected() && editorWouldPlay && given.value.length > 0 ? " The editor cannot be handed arguments for a game it plays, so this one was started " + "here: the debug_* tools answer only for a game the editor is playing." : this.godotBridge.isConnected() && editorWouldPlay && needsItsOwnProcess(asked.value) ? " The editor plays a game with its own environment, so a run given one was started " + "here: the debug_* tools answer only for a game the editor is playing." : this.godotBridge.isConnected() && editorWouldPlay && silent ? " The editor cannot play a game silent, which takes an engine flag, so this one was " + `started here${args["silent"] === true ? "" : ", silent because GDHARNESS_SILENT says so"}: the debug_* tools answer only for a game the editor is playing, and silent: false plays it through the editor.` : "";
     const endedForThis = endedToStartThis(ended);
     const stranded = wereHereFirst.filter((one) => one.pid !== ended?.pid && alive(one.pid));
     const alsoRunning = leftRunningNote(stranded);
@@ -35401,8 +35483,16 @@ 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) } : {};
+        };
+        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)}` };
       }
@@ -35437,6 +35527,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,

package/package.json

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