gdharness 1.2.30 → 1.2.31

package/build/cli.js

@@ -11153,7 +11153,7 @@ var init_tool_definitions = __esm(() => {
   };
   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
   };
   XY = {
@@ -11608,7 +11608,11 @@ var init_tool_definitions = __esm(() => {
       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"
@@ -11656,7 +11660,11 @@ var init_tool_definitions = __esm(() => {
       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",
@@ -11683,7 +11691,7 @@ var init_tool_definitions = __esm(() => {
     {
       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_PATH,
         scenePath: SCENE_PATH,
@@ -39556,6 +39564,9 @@ var init_godot_bridge = __esm(() => {
       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;
@@ -39577,18 +39588,19 @@ var init_godot_bridge = __esm(() => {
         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 {
@@ -39740,7 +39752,7 @@ var init_godot_bridge = __esm(() => {
           return;
       }
     }
-    invokeToolDirect(toolName, args, resourceKey) {
+    invokeToolDirect(toolName, args, counted, resourceKey) {
       if (!this.isConnected()) {
         return Promise.reject(new Error("Godot is not connected"));
       }
@@ -39762,7 +39774,8 @@ var init_godot_bridge = __esm(() => {
           resolve,
           reject,
           startedAt: Date.now(),
-          resourceKey
+          resourceKey,
+          counted
         });
         this.emitBridgeEvent("tool_start", {
           tool: toolName,
@@ -41127,11 +41140,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 {
@@ -41139,11 +41167,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)) } : {}
   };
 }
 function typedBefore(content, line, character) {
@@ -41247,7 +41275,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}` });
@@ -45472,7 +45500,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":
@@ -46202,8 +46230,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);
@@ -47303,7 +47353,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`);
@@ -47328,7 +47378,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) {
@@ -47396,10 +47446,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
       },
@@ -49987,14 +50041,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;
@@ -50018,9 +50074,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/build/godot/addons/gdharness_editor/property_values.gd

@@ -162,6 +162,9 @@ func cannot_hold(
 ## max_value) is set once more after the rest, so the order a caller wrote them in does not decide
 ## what is saved.
 ##
+## A name may be a colon path into a property's components, "position:x" or "region_rect:size:y",
+## spelled as the runtime tools spell it, so one axis can be written without restating the others.
+##
 ## Nothing here saves, so a refusal partway leaves the change in memory and the file as it was. The
 ## caller returns the refusal instead of saving.
 func write_all(target: Object, properties: Dictionary) -> String:
@@ -169,19 +172,23 @@ func write_all(target: Object, properties: Dictionary) -> String:
 	for key: Variant in properties:
 		var property: String = str(key)
 		var declared: Dictionary = declaration(target, property)
+		if declared.is_empty() and ":" in property:
+			declared = _component_slot(target, property)
+			if declared.has("refused"):
+				return str(declared["refused"])
 		if declared.is_empty():
 			return "%s has no property %s" % [target.get_class(), property]
 		var value: Array = value_for(target, declared, properties[key])
 		if not value[0]:
 			return str(value[1])
-		target.set(property, value[1])
+		_write(target, property, value[1])
 		given[property] = value[1]
 
 	for property: String in given:
-		if not same(target.get(property), given[property]):
-			target.set(property, given[property])
+		if not same(read_at(target, property), given[property]):
+			_write(target, property, given[property])
 	for property: String in given:
-		var held: Variant = target.get(property)
+		var held: Variant = read_at(target, property)
 		if not same(held, given[property]):
 			return (
 				(
@@ -193,6 +200,58 @@ func write_all(target: Object, properties: Dictionary) -> String:
 	return ""
 
 
+## What [param target] holds under [param key], a property or a colon path into one's components.
+func read_at(target: Object, key: String) -> Variant:
+	if ":" in key and declaration(target, key).is_empty():
+		return target.get_indexed(NodePath(key))
+	return target.get(key)
+
+
+## Writes [param value] under [param key], putting a changed component back into the property it
+## was read out of, and that one into the one above it.
+func _write(target: Object, key: String, value: Variant) -> void:
+	if ":" in key and declaration(target, key).is_empty():
+		target.set_indexed(NodePath(key), value)
+	else:
+		target.set(key, value)
+
+
+## The declaration the last step of [param path] would have, typed as the component it reaches, so
+## a fraction for an integer vector's axis is refused as one for an int property is; or
+## {"refused": why} for the first step that is not there.
+func _component_slot(target: Object, path: String) -> Dictionary:
+	var steps: PackedStringArray = path.split(":")
+	var owner: String = target.get_class()
+	if declaration(target, steps[0]).is_empty():
+		return {"refused": "%s has no property %s" % [owner, steps[0]]}
+	var value: Variant = target.get(steps[0])
+	var walked: String = steps[0]
+	for index: int in range(1, steps.size()):
+		var step: String = steps[index]
+		var has: PackedStringArray = Serialisation.components_of(value)
+		var kind: String = type_string(typeof(value))
+		var sort: String = ("an " if kind.left(1).to_upper() in ["A", "E", "I", "O", "U"] else "a ") + kind
+		if has.is_empty():
+			return {
+				"refused":
+				(
+					(
+						"%s.%s is %s, which a path does not step into: a path reaches the components of a "
+						+ "vector, a colour, a rectangle or a transform."
+					)
+					% [owner, walked, sort]
+				)
+			}
+		if not step in has:
+			return {
+				"refused":
+				"%s.%s is %s, so it has no %s; it has %s" % [owner, walked, sort, step, ", ".join(has)]
+			}
+		value = value[step]
+		walked += ":" + step
+	return {"name": path, "type": typeof(value), "usage": PROPERTY_USAGE_DEFAULT}
+
+
 ## [param raw] as the value [param declared] takes, as [ok, value] or [false, why not].
 func value_for(target: Object, declared: Dictionary, raw: Variant) -> Array:
 	var property: String = str(declared.get("name", ""))
@@ -607,57 +666,24 @@ func _parse_new_resource(type_tag: String, value: Dictionary) -> Array:
 	return [true, built]
 
 
-## A dictionary with no tag, read against the type the property declares. Anything else is a
-## dictionary the property genuinely wants, and its values are read as values in their own right:
-## kept as the tags they arrived as, a Vector2 read off one node and written to another was saved as
-## a dictionary holding the word "Vector2".
+## A dictionary with no tag, read against the type the property declares, by the fields the tagged
+## form of that type carries: the shape a read answers with, untagged, is a value too. A rectangle
+## written as the position and size a read gave was refused while the four numbers were taken, and
+## a Rect2i, an AABB or a transform had no untagged form at all. Anything else is a dictionary the
+## property genuinely wants, and its values are read as values in their own right: kept as the tags
+## they arrived as, a Vector2 read off one node and written to another was saved as a dictionary
+## holding the word "Vector2".
 func _parse_shaped_dictionary(value: Dictionary, expected_type: int, elements: Array) -> Variant:
-	match expected_type:
-		TYPE_VECTOR2:
-			if value.has("x") and value.has("y"):
-				return Vector2(Read.as_float(value["x"]), Read.as_float(value["y"]))
-		TYPE_VECTOR2I:
-			if value.has("x") and value.has("y"):
-				return Vector2i(Read.as_int(value["x"]), Read.as_int(value["y"]))
-		TYPE_VECTOR3:
-			if value.has("x") and value.has("y") and value.has("z"):
-				return Vector3(
-					Read.as_float(value["x"]), Read.as_float(value["y"]), Read.as_float(value["z"])
-				)
-		TYPE_VECTOR3I:
-			if value.has("x") and value.has("y") and value.has("z"):
-				return Vector3i(Read.as_int(value["x"]), Read.as_int(value["y"]), Read.as_int(value["z"]))
-		TYPE_VECTOR4:
-			if value.has("x") and value.has("y") and value.has("z") and value.has("w"):
-				return Vector4(
-					Read.as_float(value["x"]),
-					Read.as_float(value["y"]),
-					Read.as_float(value["z"]),
-					Read.as_float(value["w"])
-				)
-		TYPE_COLOR:
-			if value.has("r") and value.has("g") and value.has("b"):
-				return Color(
-					Read.as_float(value["r"]),
-					Read.as_float(value["g"]),
-					Read.as_float(value["b"]),
-					Read.as_float(value.get("a", 1), 1.0)
-				)
-		TYPE_RECT2:
-			if value.has("x") and value.has("y") and value.has("width") and value.has("height"):
-				return Rect2(
-					Read.as_float(value["x"]),
-					Read.as_float(value["y"]),
-					Read.as_float(value["width"]),
-					Read.as_float(value["height"])
-				)
-		TYPE_NODE_PATH:
-			if value.has("path"):
-				return NodePath(str(value["path"]))
-	if expected_type != TYPE_NIL and expected_type != TYPE_DICTIONARY:
-		return value
-
-	return _parse_entries(value, elements)
+	if expected_type == TYPE_NIL or expected_type == TYPE_DICTIONARY:
+		return _parse_entries(value, elements)
+	var tag: String = type_string(expected_type)
+	if Serialisation.REQUIRED.has(tag):
+		var tagged: Dictionary = value.duplicate()
+		tagged["_type"] = tag
+		var built: Variant = _values.deserialize_value(tagged)
+		if typeof(built) == expected_type:
+			return built
+	return value
 
 
 ## The entries of a dictionary a property holds, each value read as a value in its own right, and

package/build/godot/addons/gdharness_editor/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/godot/addons/gdharness_editor/tools/resource_tools.gd

@@ -18,6 +18,9 @@ const SHADER_ENTRY: Dictionary[String, String] = {
 	"canvas_item": "fragment", "spatial": "fragment", "particles": "process", "sky": "sky", "fog": "fog"
 }
 
+## How many cells a read of a tile map lists, enough for a level's worth and not a whole world's.
+const CELLS_SHOWN: int = 1000
+
 var _editor_plugin: EditorPlugin = null
 var _properties: PropertyValues = PropertyValues.new()
 var _values: Serialisation = Serialisation.new()
@@ -126,8 +129,8 @@ func _save_checked(resource: Resource, path: String, names: Array, previous: Var
 	else:
 		for key: Variant in names:
 			var property: String = str(key)
-			var read: Variant = loaded.get(property)
-			if not PropertyValues.same(read, resource.get(property)):
+			var read: Variant = _properties.read_at(loaded, property)
+			if not PropertyValues.same(read, _properties.read_at(resource, property)):
 				lost = (
 					(
 						"%s.%s would load from the file as %s: it is not a property the file keeps, so "
@@ -552,7 +555,13 @@ func _cell(entry: Variant, index: int, tile_set: TileSet) -> Array:
 	var atlas_coords: Vector2i = atlas_at[1]
 	var alternative: int = Read.as_int(cell.get("alternativeTile", 0))
 	if not source.has_tile(atlas_coords):
-		return [false, "Source %d has no tile at %s" % [source_id, atlas_coords]]
+		return [
+			false,
+			(
+				"cells[%d]: source %d has no tile at %s; it has %s. Nothing was placed."
+				% [index, source_id, atlas_coords, _tiles_of(source)]
+			)
+		]
 	if not source.has_alternative_tile(atlas_coords, alternative):
 		return [
 			false,
@@ -561,6 +570,72 @@ func _cell(entry: Variant, index: int, tile_set: TileSet) -> Array:
 	return [true, at[1], source_id, atlas_coords, alternative]
 
 
+## The atlas coordinates [param source] has tiles at, the first twelve and how many more, or that it
+## has none: a refusal naming the one missing sent a caller guessing which of the others exist.
+static func _tiles_of(source: TileSetSource) -> String:
+	var count: int = source.get_tiles_count()
+	if count == 0:
+		return "no tiles"
+	var named: Array[String] = []
+	for index: int in mini(count, 12):
+		named.append(str(source.get_tile_id(index)))
+	var more: String = "" if count <= 12 else " and %d more" % (count - 12)
+	return "tiles at " + ", ".join(PackedStringArray(named)) + more
+
+
+## The cells a TileMapLayer or a TileMap holds, as {"cellCount", "cells"} in the form
+## set_tilemap_cells takes, or {} for any other node. The scene keeps them as packed bytes, which a
+## read answered with and nobody could read: a probe counted three cells by decoding the base64 by
+## hand. At most CELLS_SHOWN are listed, the count saying how many there are.
+static func cells_of(node: Node) -> Dictionary:
+	var listed: Array[Dictionary] = []
+	var count: int = 0
+	var single: TileMapLayer = node as TileMapLayer
+	var layered: TileMap = node as TileMap
+	if single != null:
+		var used: Array[Vector2i] = single.get_used_cells()
+		count = used.size()
+		for at: Vector2i in used.slice(0, CELLS_SHOWN):
+			listed.append(
+				_cell_entry(
+					at,
+					single.get_cell_source_id(at),
+					single.get_cell_atlas_coords(at),
+					single.get_cell_alternative_tile(at)
+				)
+			)
+	elif layered != null:
+		for layer: int in layered.get_layers_count():
+			var used: Array[Vector2i] = layered.get_used_cells(layer)
+			count += used.size()
+			for at: Vector2i in used:
+				if listed.size() >= CELLS_SHOWN:
+					break
+				var entry: Dictionary = _cell_entry(
+					at,
+					layered.get_cell_source_id(layer, at),
+					layered.get_cell_atlas_coords(layer, at),
+					layered.get_cell_alternative_tile(layer, at)
+				)
+				entry["layer"] = layer
+				listed.append(entry)
+	else:
+		return {}
+	var answer: Dictionary = {"cellCount": count, "cells": listed}
+	if count > listed.size():
+		answer["cellsNote"] = "The first %d of %d cells are listed." % [listed.size(), count]
+	return answer
+
+
+static func _cell_entry(at: Vector2i, source_id: int, atlas: Vector2i, alternative: int) -> Dictionary:
+	return {
+		"coords": {"x": at.x, "y": at.y},
+		"sourceId": source_id,
+		"atlasCoords": {"x": atlas.x, "y": atlas.y},
+		"alternativeTile": alternative,
+	}
+
+
 func _cell_at(node: Node, layer: int, at: Vector2i) -> Array:
 	var layered: TileMap = node as TileMap
 	if layered != null:

package/build/godot/addons/gdharness_editor/tools/scene_tools.gd

@@ -5,6 +5,7 @@ extends Node
 
 const Read = preload("../reading.gd")
 const PropertyValues = preload("../property_values.gd")
+const ResourceTools = preload("resource_tools.gd")
 const SceneFile = preload("../scene_file.gd")
 const Serialisation = preload("../serialisation.gd")
 
@@ -101,8 +102,8 @@ func _kept(scene: SceneFile, saved: Node, node: Node, names: Array) -> String:
 		return "%s is not in the scene as it would be saved." % at
 	for key: Variant in names:
 		var property: String = str(key)
-		var loaded: Variant = copy.get(property)
-		if not scene.kept(saved, loaded, node.get(property)):
+		var loaded: Variant = _properties.read_at(copy, property)
+		if not scene.kept(saved, loaded, _properties.read_at(node, property)):
 			return (
 				(
 					"%s.%s would load from the file as %s: the scene does not keep it, because the property "
@@ -601,7 +602,7 @@ func set_node_properties(args: Dictionary) -> Dictionary:
 
 	var held: Dictionary = {}
 	for key: Variant in properties:
-		held[str(key)] = _readable(node, node.get(str(key)))
+		held[str(key)] = _readable(node, _properties.read_at(node, str(key)))
 	var new_path: String = scene.path_of(node)
 	var written: Dictionary = scene.write(
 		func(saved: Node) -> String: return _kept(scene, saved, node, properties.keys())
@@ -633,6 +634,7 @@ func get_node_properties(args: Dictionary) -> Dictionary:
 	# variable read as changed; and a value this scene sets back to the default was hidden, so the
 	# names this scene's file sets are always answered.
 	var props: Dictionary = _properties_of(node, include_defaults, scene.set_here(node))
+	var cells: Dictionary = ResourceTools.cells_of(node)
 	scene.close()
 	var answer: Dictionary = {
 		"ok": true,
@@ -640,6 +642,7 @@ func get_node_properties(args: Dictionary) -> Dictionary:
 		"properties": props,
 		"unsavedInEditor": SceneFile.unsaved(scene_path)
 	}
+	answer.merge(cells)
 	# An empty answer read as a node with nothing on it, rather than one with nothing changed.
 	if props.is_empty() and not include_defaults:
 		answer["note"] = (
@@ -757,6 +760,10 @@ func connect_signal(args: Dictionary) -> Dictionary:
 	# asked for. Left alone, the answer gave the flags asked for and the file kept the old ones.
 	var callable: Callable = Callable(target, method_name)
 	var method_found: bool = target.has_method(method_name)
+	var flags_before: int = -1
+	for connection: Dictionary in source.get_signal_connection_list(signal_name):
+		if connection.get("callable") == callable:
+			flags_before = Read.as_int(connection.get("flags", 0))
 	if source.is_connected(signal_name, callable):
 		source.disconnect(signal_name, callable)
 	var connect_result: Error = source.connect(signal_name, callable, flags)
@@ -776,7 +783,7 @@ func connect_signal(args: Dictionary) -> Dictionary:
 	if not written.is_empty():
 		return written
 
-	return {
+	var answer: Dictionary = {
 		"ok": true,
 		"sourceNodePath": from,
 		"signalName": signal_name,
@@ -788,6 +795,14 @@ func connect_signal(args: Dictionary) -> Dictionary:
 		# next; a caller told nothing learnt of a misspelt one only when the signal fired.
 		"methodFound": method_found
 	}
+	# A second connect of the same pair read exactly like the first, so a caller could not tell a
+	# connection made from one that was already there, and a list showing one where two were made
+	# looked like a lost write.
+	if flags_before >= 0:
+		answer["alreadyConnected"] = true
+		if flags_before != Read.as_int(saved_flags[0]):
+			answer["flagsBefore"] = _flag_names(flags_before)
+	return answer
 
 
 ## The two ends of a connection in [param scene], as [source, target], or [null, why not].