gdharness 1.2.29 → 1.2.31

package/build/godot/operations/class_cache.gd

@@ -93,13 +93,13 @@ func _entry_for(path: String, skipped: Array[Dictionary]) -> Dictionary:
 	if declared.is_empty():
 		return {}
 
-	var base: String = _base_of(path, header, skipped)
-	if base.is_empty():
+	var base: Variant = _base_of(path, header, skipped)
+	if base == null:
 		return {}
 
 	# The field order is the editor's, so a rebuilt file reads as one the editor wrote.
 	return {
-		"base": StringName(base),
+		"base": StringName(str(base)),
 		"class": StringName(declared),
 		"icon": str(header.get("icon", "")),
 		"is_abstract": Read.as_bool(header.get("abstract", false)),
@@ -109,46 +109,157 @@ func _entry_for(path: String, skipped: Array[Dictionary]) -> Dictionary:
 	}
 
 
-# What the editor records as the base: the nearest ancestor with a class_name, else the native
-# class at the top of the chain. A script that extends by path is followed to its own header.
-func _base_of(path: String, header: Dictionary, skipped: Array[Dictionary]) -> String:
-	var visited: Array[String] = [path]
-	var current: Dictionary = header
+# What the editor records as the base, worked out as the engine's own class scan works it out,
+# measured on 4.7.2 against `--import`, so a rebuilt list is the one the editor would write and a
+# rebuild over a current list changes nothing:
+#
+# - nothing extended: RefCounted;
+# - one name, a global class or a native one: that name, unresolved;
+# - a dotted name, `Heard.Named`, an inner class of a global class: nothing, as the scan does not
+#   look names up;
+# - a path: what that script's class records, after walking into the inner classes named after
+#   the path, `"res://heard.gd".Named`, so a parent with a class_name is passed over for its own
+#   base. A path the engine cannot open records nothing, and it opens a relative one from the
+#   project root rather than from the script's folder.
+#
+# Null for a script that extends itself, which is left out of the list and named in [param skipped].
+func _base_of(path: String, header: Dictionary, skipped: Array[Dictionary]) -> Variant:
+	var visited: Array[String] = [path + ":"]
+	var extends_what: Variant = header.get("extends", null)
 	while true:
-		var extends_what: String = str(current.get("extends", ""))
-		if extends_what.is_empty():
+		if extends_what == null:
 			return "RefCounted"
-		if not (extends_what.begins_with('"') or extends_what.begins_with("'")):
-			return extends_what
-		var parent_path: String = extends_what.substr(1, extends_what.length() - 2)
-		if not parent_path.begins_with("res://"):
-			parent_path = visited[visited.size() - 1].get_base_dir().path_join(parent_path)
-		if not FileAccess.file_exists(parent_path):
-			skipped.append({"path": path, "reason": "extends a script that does not exist: " + parent_path})
+		var parts: Dictionary = _extends_parts(str(extends_what))
+		var parent_path: String = parts["path"]
+		var names: Array[String] = parts["names"]
+		if parent_path.is_empty():
+			return names[0] if names.size() == 1 else ""
+		var opened: String = _as_the_engine_opens(parent_path)
+		if not FileAccess.file_exists(opened):
 			return ""
-		if parent_path in visited:
+		var reached: String = opened + ":" + ".".join(PackedStringArray(names))
+		if reached in visited:
 			skipped.append({"path": path, "reason": "extends itself through " + parent_path})
+			return null
+		visited.append(reached)
+		var lines: PackedStringArray = FileAccess.get_file_as_string(opened).split("\n")
+		if names.is_empty():
+			extends_what = _header_in(lines).get("extends", null)
+			continue
+		var inner: Dictionary = _inner_class(lines, names)
+		if inner.is_empty():
 			return ""
-		visited.append(parent_path)
-		current = _header_of(parent_path)
-		var parent_name: String = str(current.get("class_name", ""))
-		if not parent_name.is_empty():
-			return parent_name
+		extends_what = inner.get("extends", null)
 	return ""
 
 
-# The declarations at the top of a script: class_name, what it extends (a class name, or a
-# quoted path), and the @tool, @abstract and @icon annotations. Reading stops at the first
-# statement that is none of those, which is where the body begins.
+# The path and the class names an `extends` names, from the text after the keyword:
+# `"res://heard.gd".Named` is the path and ["Named"], `Heard.Named` no path and two names. The
+# reading stops at whatever follows, a colon or a comment.
+static func _extends_parts(text: String) -> Dictionary:
+	var rest: String = text.strip_edges()
+	var path: String = ""
+	if rest.begins_with('"') or rest.begins_with("'"):
+		var closing: int = rest.find(rest[0], 1)
+		if closing == -1:
+			return {"path": "", "names": [] as Array[String]}
+		path = rest.substr(1, closing - 1)
+		rest = rest.substr(closing + 1)
+	var names: Array[String] = []
+	var name_at: RegEx = Patterns.compiled("^([A-Za-z_][A-Za-z0-9_]*)")
+	var dotted: bool = not path.is_empty()
+	while true:
+		if dotted:
+			if not rest.begins_with("."):
+				break
+			rest = rest.substr(1)
+		dotted = true
+		var found: RegExMatch = name_at.search(rest)
+		if found == null:
+			break
+		names.append(found.get_string(1))
+		rest = rest.substr(found.get_end())
+	return {"path": path, "names": names}
+
+
+# The file the engine's class scan reads for an `extends` path. It opens the path as written, and
+# the engine runs from the project root, so a relative path is read from there.
+static func _as_the_engine_opens(path: String) -> String:
+	if path.is_absolute_path():
+		return path
+	var absolute: String = ProjectSettings.globalize_path("res://").path_join(path).simplify_path()
+	return ProjectSettings.localize_path(absolute)
+
+
+# The inner class [param names] reaches in a script of [param lines], one class inside the
+# previous, as {"found": true, "extends": the text after its keyword} with no "extends" for one that
+# extends nothing, or {} when one of them is not there.
+func _inner_class(lines: PackedStringArray, names: Array[String]) -> Dictionary:
+	var class_line: RegEx = Patterns.compiled("^class\\s+([A-Za-z_][A-Za-z0-9_]*)\\s*(.*)$")
+	var inline_extends: RegEx = Patterns.compiled("^extends\\s+(.*)$")
+	var start: int = 0
+	var end: int = lines.size()
+	var depth: int = 0
+	var found: Dictionary = {}
+	for name: String in names:
+		var at: int = -1
+		found = {"found": true}
+		for index: int in range(start, end):
+			var text: String = lines[index].strip_edges()
+			if text.is_empty() or text.begins_with("#") or _indent(lines[index]) != depth:
+				continue
+			var declared: RegExMatch = class_line.search(text)
+			if declared == null or declared.get_string(1) != name:
+				continue
+			at = index
+			var inline: RegExMatch = inline_extends.search(declared.get_string(2).strip_edges())
+			if inline != null:
+				found["extends"] = inline.get_string(1)
+			break
+		if at == -1:
+			return {}
+		start = at + 1
+		var body_end: int = start
+		var body_depth: int = -1
+		for index: int in range(start, end):
+			var text: String = lines[index].strip_edges()
+			if not text.is_empty() and not text.begins_with("#"):
+				var width: int = _indent(lines[index])
+				if width <= depth:
+					break
+				if body_depth == -1:
+					body_depth = width
+			body_end = index + 1
+		end = body_end
+		depth = body_depth
+		if not found.has("extends"):
+			var body: Dictionary = _header_in(lines.slice(start, end))
+			if body.has("extends"):
+				found["extends"] = body["extends"]
+	return found
+
+
+static func _indent(line: String) -> int:
+	return line.length() - line.lstrip(" \t").length()
+
+
 func _header_of(path: String) -> Dictionary:
+	if not FileAccess.file_exists(path):
+		return {}
+	return _header_in(FileAccess.get_file_as_string(path).split("\n"))
+
+
+# The declarations at the top of a script: class_name, what it extends (the text after the
+# keyword, a class name or a quoted path, either followed by inner class names), and the @tool,
+# @abstract and @icon annotations. Reading stops at the first statement that is none of those,
+# which is where the body begins.
+func _header_in(lines: PackedStringArray) -> Dictionary:
 	var header: Dictionary = {}
-	var file: FileAccess = FileAccess.open(path, FileAccess.READ)
-	if not file:
-		return header
 	var annotation: RegEx = Patterns.compiled('^@([a-z_]+)(?:\\(\\s*(?:"([^"]*)")?[^)]*\\))?\\s*')
-	var extends_line: RegEx = Patterns.compiled("^extends\\s+(\\S+)")
-	while not file.eof_reached():
-		var rest: String = file.get_line().strip_edges()
+	var extends_line: RegEx = Patterns.compiled("^extends\\s+(.*)$")
+	var same_line: RegEx = Patterns.compiled("^\\s+extends\\s+(.*)$")
+	for line: String in lines:
+		var rest: String = line.strip_edges()
 		# Annotations may share a line with what they annotate, as in `@abstract class_name X`.
 		var annotated: RegExMatch = annotation.search(rest)
 		while annotated != null:
@@ -167,15 +278,15 @@ func _header_of(path: String) -> Dictionary:
 			var declared: RegExMatch = Patterns.declared_class(rest)
 			if declared != null:
 				header["class_name"] = declared.get_string(1)
-				if not declared.get_string(2).is_empty():
-					header["extends"] = declared.get_string(2)
+				var after: RegExMatch = same_line.search(rest.substr(declared.get_end(1)))
+				if after != null:
+					header["extends"] = after.get_string(1)
 		elif rest.begins_with("extends"):
 			var parent: RegExMatch = extends_line.search(rest)
 			if parent != null:
 				header["extends"] = parent.get_string(1)
 		else:
 			break
-	file.close()
 	return header
 
 

package/build/godot/operations/classdb_queries.gd

@@ -2,6 +2,7 @@ extends RefCounted
 
 const Read = preload("reading.gd")
 const Log = preload("logger.gd")
+const Serialisation = preload("serialisation.gd")
 
 # The base classes each category name stands for. Kept to the list the tool's schema offers, which
 # a case holds: the schema offered physics3d and ui, which this refused, and physics answered the 3D
@@ -22,6 +23,7 @@ const CATEGORY_BASES: Dictionary = {
 }
 
 var _log: Log
+var _values: Serialisation = Serialisation.new()
 
 
 func _init(p_log: Log) -> void:
@@ -318,19 +320,24 @@ func _methods_of(class_name_str: String, include_inherited: bool) -> Array[Dicti
 				}
 			)
 		var return_info: Dictionary = m.get("return", {})
-		methods.append(
-			{
-				"name": m.get("name", ""),
-				"args": args,
-				"return":
+		(
+			methods
+			. append(
 				{
-					"type": return_info.get("type", 0),
-					"type_name": _type_name(return_info, "void"),
-					"class_name": return_info.get("class_name", "")
-				},
-				"flags": m.get("flags", 0),
-				"default_args": m.get("default_args", [])
-			}
+					"name": m.get("name", ""),
+					"args": args,
+					"return":
+					{
+						"type": return_info.get("type", 0),
+						"type_name": _type_name(return_info, "void"),
+						"class_name": return_info.get("class_name", "")
+					},
+					"flags": m.get("flags", 0),
+					# As values, tagged the way every other answer tags one: JSON writes a Vector2i it is
+					# handed as its text, so TileMapLayer.set_cell's default atlas coords read "(-1, -1)".
+					"default_args": _values.serialize_value(m.get("default_args", []))
+				}
+			)
 		)
 
 	return methods

package/build/godot/operations/project_config.gd

@@ -117,12 +117,7 @@ func set_project_setting(params: Dictionary) -> Dictionary:
 	var wanted: int = _wanted_type(setting_path, old_value if had_value else null)
 	if wanted > TYPE_NIL and final_value != null and typeof(final_value) != wanted:
 		if not _converts_faithfully(final_value, wanted):
-			return _log.failure(
-				(
-					"%s is declared as %s, and %s (%s) cannot be written as that without losing something."
-					% [setting_path, type_string(wanted), str(final_value), type_string(typeof(final_value))]
-				)
-			)
+			return _log.failure(_cannot_hold(setting_path, wanted, final_value))
 		final_value = type_convert(final_value, wanted)
 
 	var answer: Dictionary = {
@@ -174,6 +169,21 @@ func _converts_faithfully(value: Variant, to: int) -> bool:
 	return type_convert(type_convert(value, to), typeof(value)) == value
 
 
+# Why [param value] cannot be written to a setting declared as [param wanted], in the words the
+# editor's property writes use for the same two cases. One sentence for both read "without losing
+# something" about a word given for a number, where nothing would be lost: it cannot become one.
+static func _cannot_hold(setting_path: String, wanted: int, value: Variant) -> String:
+	var numbers: Array[int] = [TYPE_INT, TYPE_FLOAT]
+	var declared: String = "%s is declared as %s" % [setting_path, type_string(wanted)]
+	var cost: String = " Setting it would save a different value than the one asked for."
+	if wanted == TYPE_INT and typeof(value) == TYPE_FLOAT:
+		return "%s, which holds whole numbers, and %s would be cut to fit.%s" % [declared, str(value), cost]
+	if wanted in numbers and typeof(value) in numbers:
+		return "%s, and %s is not the same number as one.%s" % [declared, str(value), cost]
+	var given: String = type_string(typeof(value))
+	return "%s, and %s (%s) cannot become one." % [declared, JSON.stringify(value), given]
+
+
 # Add an autoload singleton
 func add_autoload(params: Dictionary) -> Dictionary:
 	var name: String = str(params.get("name", ""))

package/build/godot/operations/serialisation.gd

@@ -246,6 +246,52 @@ func deserialize_value(value: Variant) -> Variant:
 	return call(builder, fields)
 
 
+## The components a path reads off [param value], by the names GDScript gives them, or none for a
+## value that has none: a vector's axes, a colour's channels, a rectangle's corners and size, a
+## transform's basis and origin. A value of one of these is a copy wherever it is read, so a write
+## into a component is a write into the copy until it is put back where it was read from.
+static func components_of(value: Variant) -> PackedStringArray:
+	match typeof(value):
+		TYPE_VECTOR2, TYPE_VECTOR2I:
+			return PackedStringArray(["x", "y"])
+		TYPE_VECTOR3, TYPE_VECTOR3I:
+			return PackedStringArray(["x", "y", "z"])
+		TYPE_VECTOR4, TYPE_VECTOR4I, TYPE_QUATERNION:
+			return PackedStringArray(["x", "y", "z", "w"])
+		TYPE_COLOR:
+			return PackedStringArray(
+				[
+					"r",
+					"g",
+					"b",
+					"a",
+					"r8",
+					"g8",
+					"b8",
+					"a8",
+					"h",
+					"s",
+					"v",
+					"ok_hsl_h",
+					"ok_hsl_s",
+					"ok_hsl_l"
+				]
+			)
+		TYPE_RECT2, TYPE_RECT2I, TYPE_AABB:
+			return PackedStringArray(["position", "size", "end"])
+		TYPE_PLANE:
+			return PackedStringArray(["normal", "x", "y", "z", "d"])
+		TYPE_BASIS:
+			return PackedStringArray(["x", "y", "z"])
+		TYPE_TRANSFORM2D:
+			return PackedStringArray(["x", "y", "origin"])
+		TYPE_TRANSFORM3D:
+			return PackedStringArray(["basis", "origin"])
+		TYPE_PROJECTION:
+			return PackedStringArray(["x", "y", "z", "w"])
+	return PackedStringArray()
+
+
 ## Whether [param entries] is a list of [key, value] pairs, as a Dictionary tag carries them.
 static func pairs(entries: Variant) -> bool:
 	if not entries is Array:

package/build/index.js

@@ -29053,6 +29053,9 @@ class GodotBridge extends EventEmitter {
     const info = this.connectionInfo;
     return this.socket?.readyState === import_websocket.default.OPEN && info !== null && (info.greeted !== true || info.identifying === true);
   }
+  requestsInFlight() {
+    return [...this.pendingRequests.values()].filter((pending) => pending.counted).map((pending) => ({ tool: pending.toolName, startedAt: pending.startedAt })).sort((a, b) => a.startedAt - b.startedAt);
+  }
   getStatus() {
     const identifying = this.connectionInfo?.identifying === true;
     const editor = identifying ? null : this.connectionInfo;
@@ -29074,18 +29077,19 @@ class GodotBridge extends EventEmitter {
       syncsBreakpoints: editor?.syncsBreakpoints,
       turnedAway: this.turnedAway ?? undefined,
       identifying: identifying ? true : undefined,
-      pendingRequests: this.pendingRequests.size,
+      pendingRequests: this.requestsInFlight().length,
       queuedResources: this.resourceQueues.size,
       listeningSince: this.listeningSince ?? undefined,
       portWanted: this.wantedPort !== 0 && this.boundPort !== null && this.boundPort !== this.wantedPort ? this.wantedPort : undefined
     };
   }
-  invokeTool(toolName, args) {
+  invokeTool(toolName, args, options = {}) {
+    const counted = options.counted ?? true;
     const resourceKey = this.getResourceKey(args);
     if (!resourceKey) {
-      return this.invokeToolDirect(toolName, args);
+      return this.invokeToolDirect(toolName, args, counted);
     }
-    return this.enqueueResourceRequest(resourceKey, () => this.invokeToolDirect(toolName, args, resourceKey));
+    return this.enqueueResourceRequest(resourceKey, () => this.invokeToolDirect(toolName, args, counted, resourceKey));
   }
   getRequestPathname(url) {
     try {
@@ -29237,7 +29241,7 @@ class GodotBridge extends EventEmitter {
         return;
     }
   }
-  invokeToolDirect(toolName, args, resourceKey) {
+  invokeToolDirect(toolName, args, counted, resourceKey) {
     if (!this.isConnected()) {
       return Promise.reject(new Error("Godot is not connected"));
     }
@@ -29259,7 +29263,8 @@ class GodotBridge extends EventEmitter {
         resolve,
         reject,
         startedAt: Date.now(),
-        resourceKey
+        resourceKey,
+        counted
       });
       this.emitBridgeEvent("tool_start", {
         tool: toolName,
@@ -31352,11 +31357,26 @@ function shownDiagnostic(entry) {
     ...code === undefined || code === null || code === 0 || code === "" ? {} : { code }
   };
 }
-function shownSymbol(entry) {
+function linesIn(content) {
+  const lines = content.split(`
+`);
+  return Math.max(1, content.endsWith(`
+`) ? lines.length - 1 : lines.length);
+}
+function lastLineOf(whole, lastOfDocument) {
+  const end = shownPosition(whole["end"]);
+  if (end === null) {
+    return null;
+  }
+  const start = shownPosition(whole["start"]);
+  const exclusive = end.column === 1 && (start === null || end.line > start.line);
+  return Math.min(exclusive ? end.line - 1 : end.line, lastOfDocument);
+}
+function shownSymbol(entry, lastOfDocument) {
   const symbol = asRecord(entry);
   const whole = asRecord(symbol["range"] ?? asRecord(symbol["location"])["range"]);
   const at = shownPosition(asRecord(symbol["selectionRange"] ?? whole)["start"]);
-  const last = shownPosition(whole["end"]);
+  const last = lastLineOf(whole, lastOfDocument);
   const children = Array.isArray(symbol["children"]) ? symbol["children"] : [];
   const { documentation, native_class: nativeClass, deprecated, detail } = symbol;
   return {
@@ -31364,11 +31384,11 @@ function shownSymbol(entry) {
     kind: named(symbol["kind"], SYMBOL_KINDS),
     ...typeof detail === "string" && detail !== "" ? { detail } : {},
     ...at === null ? {} : { line: at.line, column: at.column },
-    ...last === null ? {} : { lastLine: last.line },
+    ...last === null ? {} : { lastLine: last },
     ...typeof documentation === "string" && documentation !== "" ? { documentation } : {},
     ...typeof nativeClass === "string" && nativeClass !== "" ? { nativeClass } : {},
     ...deprecated === true ? { deprecated } : {},
-    ...children.length > 0 ? { children: children.map(shownSymbol) } : {}
+    ...children.length > 0 ? { children: children.map((child) => shownSymbol(child, lastOfDocument)) } : {}
   };
 }
 var MOST_COMPLETIONS = 100;
@@ -31473,7 +31493,7 @@ async function handleLSPTool(client, toolName, args) {
       }
       case "lsp_get_symbols": {
         const symbols = await client.getDocumentSymbols(scriptPath, content);
-        return asToolResponse({ symbols: symbols.map(shownSymbol) });
+        return asToolResponse({ symbols: symbols.map((symbol) => shownSymbol(symbol, linesIn(content))) });
       }
       default:
         return asToolResponse({ error: `Unknown LSP tool: ${toolName}` });
@@ -34298,7 +34318,7 @@ var NODE_PATH = {
 };
 var PROPERTIES = {
   type: "object",
-  description: 'Properties to set, keyed by Godot property name. Vectors, colours and the like may be written as {"x": 1, "y": 2} or tagged {"_type": "Vector2", "x": 1, "y": 2}, which is the form a read answers with, so a value read off one node can be written straight to another. A property holding a node takes the path to it from the node being set, such as "../Player". Each value is read back once set, and one the engine changed or refused is refused with what it holds.',
+  description: 'Properties to set, keyed by Godot property name. Vectors, colours and the like may be written as {"x": 1, "y": 2} or tagged {"_type": "Vector2", "x": 1, "y": 2}, which is the form a read answers with, so a value read off one node can be written straight to another. A key may also be a colon path into one of the components of a vector, a colour, a rectangle or a transform, as GDScript names them, so one axis is written alone: "position:x", "modulate:a", "region_rect:size:y"; a component the value does not have is refused, naming the ones it has. A property holding a node takes the path to it from the node being set, such as "../Player". Each value is read back once set, and one the engine changed or refused is refused with what it holds.',
   additionalProperties: true
 };
 var XY = {
@@ -34753,7 +34773,11 @@ var TOOL_SPECS = [
     requires: ["projectPath", "scenePath"],
     operations: {
       create: { effect: "destructive", summary: "a new scene with one root node", requires: [] },
-      save: { effect: "destructive", summary: "save the scene as it is in the editor", requires: [] },
+      save: {
+        effect: "destructive",
+        summary: "save the scene as it is in the editor, or as the file loads when the editor does not have it open; from says which",
+        requires: []
+      },
       save_as: { effect: "destructive", summary: "save a copy under newPath", requires: ["newPath"] }
     },
     defaultOperation: "create"
@@ -34801,7 +34825,11 @@ var TOOL_SPECS = [
     requires: ["projectPath", "scenePath"],
     operations: {
       add: { effect: "additive", summary: "add a node of any class", requires: ["nodeType", "nodeName"] },
-      get: { effect: "read", summary: "read a node's properties", requires: ["nodePath"] },
+      get: {
+        effect: "read",
+        summary: "read a node's properties, and a TileMapLayer's or TileMap's cells as set_tilemap_cells takes them, the first 1000 with cellCount for all",
+        requires: ["nodePath"]
+      },
       set: {
         effect: "destructive",
         summary: "set properties on a node",
@@ -34828,7 +34856,7 @@ var TOOL_SPECS = [
   {
     name: "scene_signal",
     title: "Scene signals",
-    description: "Signal connections in a scene file. Each connection answers with its flags as the number and as flagNames; persist is on every connection, since a scene saves no other kind. Needs the editor connected.",
+    description: "Signal connections in a scene file. Each connection answers with its flags as the number and as flagNames; persist is on every connection, since a scene saves no other kind. A connect of a pair already connected says alreadyConnected, with flagsBefore when it changed the flags. Needs the editor connected.",
     parameters: {
       projectPath: PROJECT_PATH2,
       scenePath: SCENE_PATH,
@@ -35562,7 +35590,7 @@ var TOOL_SPECS = [
       value: {
         ops: ["set"],
         blank: true,
-        description: `set: the value, fitted to the property's type. A vector, colour or the like may be written as its fields, {"x": 140, "y": 300}, or tagged, {"_type": "Vector2", "x": 140, "y": 300}, which is the form a read answers with. "" writes an empty string. A property typed as or holding an object takes a path naming one the game holds, the way call's args do, and holds that instance, or null, which the text null also means, to empty it. One declared as Variant or untyped takes anything, as the engine does: a value of the kind it holds is fitted to it, an int staying an int, and any other is stored as sent. A typed list or map, such as Array[int] or Dictionary[String, int], takes a JSON list or object with each element fitted to its element type, and an element that cannot become one is refused by its index or key, as is an object of another script than the one the list holds, whether or not that script has a class_name.`
+        description: `set: the value, fitted to the property's type. A number the property would have to cut is refused rather than truncated: a fraction into an int, a number other than 0 or 1 into a bool. A vector, colour or the like may be written as its fields, {"x": 140, "y": 300}, or tagged, {"_type": "Vector2", "x": 140, "y": 300}, which is the form a read answers with. "" writes an empty string. A property typed as or holding an object takes a path naming one the game holds, the way call's args do, and holds that instance, or null, which the text null also means, to empty it. One declared as Variant or untyped takes anything, as the engine does: a value of the kind it holds is fitted to it, an int staying an int, and any other is stored as sent, a fraction into one holding an int included. A typed list or map, such as Array[int] or Dictionary[String, int], takes a JSON list or object with each element fitted to its element type, and an element that cannot become one is refused by its index or key, as is an object of another script than the one the list holds, whether or not that script has a class_name.`
       },
       method: {
         type: "string",
@@ -35572,7 +35600,7 @@ var TOOL_SPECS = [
       args: {
         type: "array",
         ops: ["call"],
-        description: `call: the arguments, fitted to the method's parameter types. A vector, colour or the like may be written as its fields, {"x": 140, "y": 300}, or tagged, {"_type": "Vector2", "x": 140, "y": 300}. A parameter typed as an object takes a path naming one the game holds and is handed that instance: a colon path read from nodePath, "_game:run:wares:3", or one starting at a node, "/root/Main/Hud" or "/root/Main:_game:run". A path that reaches no object, or an object of another class than the parameter declares, is refused, and so are too few or too many arguments. The engine names a parameter typed as a script class without class_name by the class the script extends, so an object of that class with another script passes that check and the engine refuses the call: the answer says the method did not run, with the engine's reason. A parameter typed as a list or map, such as Array[int] or Array[Gear], is built from a JSON list or object element by element, objects named by their paths. The method itself takes its arguments here only: brackets on it holding arguments are refused.`
+        description: `call: the arguments, fitted to the method's parameter types. A number a parameter would have to cut is refused rather than truncated: a fraction for an int, a number other than 0 or 1 for a bool. A vector, colour or the like may be written as its fields, {"x": 140, "y": 300}, or tagged, {"_type": "Vector2", "x": 140, "y": 300}. A parameter typed as an object takes a path naming one the game holds and is handed that instance: a colon path read from nodePath, "_game:run:wares:3", or one starting at a node, "/root/Main/Hud" or "/root/Main:_game:run". A path that reaches no object, or an object of another class than the parameter declares, is refused, and so are too few or too many arguments. The engine names a parameter typed as a script class without class_name by the class the script extends, so an object of that class with another script passes that check and the engine refuses the call: the answer says the method did not run, with the engine's reason. A parameter typed as a list or map, such as Array[int] or Array[Gear], is built from a JSON list or object element by element, objects named by their paths. The method itself takes its arguments here only: brackets on it holding arguments are refused.`
       },
       properties: {
         type: ["boolean", "array"],
@@ -38206,7 +38234,7 @@ class GodotServer {
     const { op: _op, ...arguments_ } = args;
     const bridge = async (command, extra = {}) => {
       const contained = this.containProjectFiles({ ...arguments_, ...extra });
-      return contained.ok ? await this.handleViaBridge(command, contained.value, tool) : contained.response;
+      return contained.ok ? await this.handleViaBridge(command, contained.value, op === "" ? tool : `${tool} ${op}`) : contained.response;
     };
     switch (tool) {
       case "project_info":
@@ -38936,8 +38964,30 @@ class GodotServer {
         ]
       };
     }
+    const dropped = await this.optionsTheImporterDropped(project.value.path, params, written.payload);
+    if (dropped !== null) {
+      return dropped;
+    }
     return this.jsonTextResponse({ ...written.payload, reimport: applied.payload });
   }
+  async optionsTheImporterDropped(projectPath, params, written) {
+    const listed = written["updated_options"];
+    const updated = Array.isArray(listed) ? listed.map(String) : [];
+    const { options: _options, ...where } = params;
+    const reread = await this.operation("get_import_options", where, projectPath);
+    if (!reread.ok || updated.length === 0) {
+      return null;
+    }
+    const held = reread.payload["params"];
+    const kept = held !== null && typeof held === "object" ? Object.keys(held) : [];
+    const gone = updated.filter((name) => !kept.includes(name));
+    if (gone.length === 0) {
+      return null;
+    }
+    const applied = updated.filter((name) => kept.includes(name));
+    const named = gone.join(", ");
+    return this.createErrorResponse(`${named} ${gone.length === 1 ? "is not an option" : "are not options"} of this resource's importer: the reimport left ${gone.length === 1 ? "it" : "them"} out of the import file, so ${gone.length === 1 ? "it changed" : "they changed"} nothing.${applied.length === 0 ? "" : ` ${applied.join(", ")} ${applied.length === 1 ? "was" : "were"} applied.`} Its options are: ${kept.join(", ")}.`, ["project_import options lists every option with the value it holds"]);
+  }
   async reimport(projectPath, resourcePath, force, timeoutMs) {
     const ask = resourcePath === undefined ? { includeUpToDate: force } : { resourcePath };
     const before = await this.operation("get_import_status", ask, projectPath);
@@ -40037,7 +40087,7 @@ class GodotServer {
     }
     try {
       const askedAt = Date.now();
-      const asked = this.godotBridge.invokeTool("playing_status", {});
+      const asked = this.godotBridge.invokeTool("playing_status", {}, { counted: false });
       const answer = await Promise.race([asked, delay4(PLAYING_STATUS_MS).then(() => null)]);
       if (answer === null) {
         this.logDebug(`playing_status did not answer within ${PLAYING_STATUS_MS}ms`);
@@ -40062,7 +40112,7 @@ class GodotServer {
     }
     try {
       const answer = await Promise.race([
-        this.godotBridge.invokeTool("scan_status", {}),
+        this.godotBridge.invokeTool("scan_status", {}, { counted: false }),
         delay4(PLAYING_STATUS_MS).then(() => null)
       ]);
       if (answer === null) {
@@ -40130,10 +40180,14 @@ class GodotServer {
       this.getEditorStatusPayload(),
       this.editorServersListening()
     ]);
+    const answeredAt = Date.now();
+    const inFlight = this.godotBridge.requestsInFlight().map((request) => ({ tool: request.tool, forMs: answeredAt - request.startedAt }));
     return this.jsonTextResponse({
       editor: {
         ...editorStatus,
         ...servers,
+        pendingRequests: inFlight.length,
+        pendingRequestTools: inFlight.length === 0 ? undefined : inFlight,
         debugPort: playing?.debugPort ?? this.godotBridge.getStatus().debugPort,
         scan
       },
@@ -42721,14 +42775,16 @@ class GodotServer {
     if (!(answered instanceof BridgeTimeout)) {
       return answered;
     }
-    return this.createErrorResponse(`The editor took ${toolName} in and did not answer within ${String(answered.waitedMs / 1000)}s. An editor importing files answers nothing until the import is over, and a hidden one imports on the thread that answers.`, [
+    return this.createErrorResponse(`The editor took ${askedAs ?? toolName} in and did not answer within ${String(answered.waitedMs / 1000)}s. An editor importing files answers nothing until the import is over, and a hidden one imports on the thread that answers.`, [
       "editor_status says whether it is scanning or importing",
       "The editor still carries the request out once it is free, so read what it changed before asking again"
     ]);
   }
   async askViaBridge(toolName, args, askedAs) {
+    const named = askedAs ?? toolName;
     if (!this.godotBridge.isConnected()) {
-      const alternative = askedAs !== undefined && Object.hasOwn(EDITOR_FREE_INSTEAD, askedAs) ? EDITOR_FREE_INSTEAD[askedAs] : undefined;
+      const tool = askedAs?.split(" ")[0];
+      const alternative = tool !== undefined && Object.hasOwn(EDITOR_FREE_INSTEAD, tool) ? EDITOR_FREE_INSTEAD[tool] : undefined;
       const refused = await this.noEditorYet(args, alternative === undefined ? [] : [alternative]);
       if (refused !== null) {
         return refused;
@@ -42752,9 +42808,9 @@ class GodotServer {
       if (message.includes(`Unknown tool: ${toolName}`)) {
         const status = this.godotBridge.getStatus();
         const remedy = addonMismatch(status.addonVersion, SERVER_VERSION, status.addonDigest, shippedEditorDigest(), this.editorCodeOnDisk());
-        return this.createErrorResponse(`The editor's gdharness addon is older than this ${SERVER_VERSION} server and has no ${toolName}, so it cannot answer this call. ${remedy ?? "Restart it with editor_launch restart to load the addon the project holds."}`, ["editor_status says which addon the editor holds"]);
+        return this.createErrorResponse(`The editor's gdharness addon is older than this ${SERVER_VERSION} server and has no ${named}, so it cannot answer this call. ${remedy ?? "Restart it with editor_launch restart to load the addon the project holds."}`, ["editor_status says which addon the editor holds"]);
       }
-      return this.createErrorResponse(`The editor answered ${toolName} with an error: ${message}`);
+      return this.createErrorResponse(`The editor answered ${named} with an error: ${message}`);
     }
   }
   runtimeTimeoutMs() {

package/package.json

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