gdharness 1.3.0 → 1.3.2

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

@@ -3,11 +3,11 @@ extends Node
 
 ## Resource files, shaders, tilesets and themes, written through the open editor.
 
-const FileReads = preload("../file_reads.gd")
-const HeadlessCheck = preload("../headless_check.gd")
-const PropertyValues = preload("../property_values.gd")
-const Read = preload("../reading.gd")
-const SceneFile = preload("../scene_file.gd")
+const GdhFileReads = preload("../file_reads.gd")
+const GdhHeadlessCheck = preload("../headless_check.gd")
+const GdhPropertyValues = preload("../property_values.gd")
+const GdhRead = preload("../reading.gd")
+const GdhSceneFile = preload("../scene_file.gd")
 
 # The minimal shader of a type: its declaration and the one function the engine calls for it.
 const SHADER_EMPTY: String = """shader_type %s;
@@ -23,7 +23,7 @@ const SHADER_ENTRY: Dictionary[String, String] = {
 const CELLS_SHOWN: int = 1000
 
 var _editor_plugin: EditorPlugin = null
-var _properties: PropertyValues = PropertyValues.new()
+var _properties: GdhPropertyValues = GdhPropertyValues.new()
 
 
 func set_editor_plugin(plugin: EditorPlugin) -> void:
@@ -48,7 +48,7 @@ func _written(path: String) -> void:
 	if ResourceLoader.has_cached(path):
 		var _replaced: Resource = ResourceLoader.load(path, "", ResourceLoader.CACHE_MODE_REPLACE)
 	if _editor_plugin:
-		SceneFile.scan_later()
+		GdhSceneFile.scan_later()
 
 
 ## Why a tool that creates [param path] must not write there, or "". Saving over a file that was
@@ -89,12 +89,15 @@ func _xy(value: Variant, label: String) -> Array:
 			x = pair[0]
 			y = pair[1]
 	for number: Variant in [x, y]:
-		if not (number is float or number is int) or Read.as_float(number) != floorf(Read.as_float(number)):
+		if (
+			not (number is float or number is int)
+			or GdhRead.as_float(number) != floorf(GdhRead.as_float(number))
+		):
 			return [
 				false,
 				'%s must be two whole numbers, {"x": .., "y": ..}, not %s.' % [label, JSON.stringify(value)]
 			]
-	return [true, Vector2i(Read.as_int(x), Read.as_int(y))]
+	return [true, Vector2i(GdhRead.as_int(x), GdhRead.as_int(y))]
 
 
 ## The theme on disk at this path, or null when there is not one.
@@ -119,12 +122,12 @@ func _load_theme(theme_path: String) -> Theme:
 ## Read back because a property can be set and still not be saved: one without storage, a
 ## script variable that is not exported. Both were answered as changed.
 func _save_checked(resource: Resource, path: String, names: Array, previous: Variant) -> String:
-	var saving: Error = SceneFile.save_keeping_uid(resource, path)
+	var saving: Error = GdhSceneFile.save_keeping_uid(resource, path)
 	if saving != OK:
 		return "Failed to save %s: %s" % [path, error_string(saving)]
 	var unkept: String = _unkept_headless(resource, path, names, previous)
 	if not unkept.is_empty():
-		return "Nothing was written: " + unkept + HeadlessCheck.put_back(path, previous)
+		return "Nothing was written: " + unkept + GdhHeadlessCheck.put_back(path, previous)
 	var loaded: Resource = ResourceLoader.load(path, "", ResourceLoader.CACHE_MODE_IGNORE)
 	var lost: String = ""
 	if loaded == null:
@@ -133,7 +136,7 @@ func _save_checked(resource: Resource, path: String, names: Array, previous: Var
 		for key: Variant in names:
 			var property: String = str(key)
 			var read: Variant = _properties.read_at(loaded, property)
-			if not PropertyValues.same(read, _properties.read_at(resource, property)):
+			if not GdhPropertyValues.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 "
@@ -145,19 +148,19 @@ func _save_checked(resource: Resource, path: String, names: Array, previous: Var
 	if lost.is_empty():
 		_written(path)
 		return ""
-	return lost + HeadlessCheck.put_back(path, previous)
+	return lost + GdhHeadlessCheck.put_back(path, previous)
 
 
 ## Outside the editor, puts back in the file just saved at [param path] what a script that is not a
 ## tool changed and the call did not ask for, [param names] being what it asked for, and answers ""
-## or why that did not hold. See [HeadlessCheck].
+## or why that did not hold. See [GdhHeadlessCheck].
 func _unkept_headless(resource: Resource, path: String, names: Array, previous: Variant) -> String:
 	if Engine.is_editor_hint():
 		return ""
 	var script: Script = resource.get_script()
 	var scripted: bool = script != null and not script.is_tool()
 	if not path.ends_with(".tres"):
-		if scripted or HeadlessCheck.holds_scripted_embedded(resource, {}):
+		if scripted or GdhHeadlessCheck.holds_scripted_embedded(resource, {}):
 			return (
 				(
 					(
@@ -166,7 +169,7 @@ func _unkept_headless(resource: Resource, path: String, names: Array, previous:
 					)
 					% path
 				)
-				+ HeadlessCheck.REMEDY
+				+ GdhHeadlessCheck.REMEDY
 			)
 		return ""
 	var before: String = ""
@@ -179,15 +182,15 @@ func _unkept_headless(resource: Resource, path: String, names: Array, previous:
 		var property: String = str(key)
 		asked[property] = true
 		asked[property.get_slice(":", 0)] = true
-		reached.merge(HeadlessCheck.reached(resource, property))
-	return HeadlessCheck.settle_saved(
+		reached.merge(GdhHeadlessCheck.reached(resource, property))
+	return GdhHeadlessCheck.settle_saved(
 		path,
 		before,
-		HeadlessCheck.stored(resource).values(),
+		GdhHeadlessCheck.stored(resource).values(),
 		resource if scripted else null,
 		asked,
 		reached,
-		func() -> Error: return SceneFile.save_keeping_uid(resource, path)
+		func() -> Error: return GdhSceneFile.save_keeping_uid(resource, path)
 	)
 
 
@@ -202,7 +205,7 @@ func create_resource(args: Dictionary) -> Dictionary:
 		return {"ok": false, "error": taken}
 
 	var script_path: String = str(args.get("script", ""))
-	var made: Dictionary = SceneFile.made_as(
+	var made: Dictionary = GdhSceneFile.made_as(
 		resource_type, "" if script_path == "" else _ensure_res_path(script_path), "Resource", "resourceType"
 	)
 	if made.has("error"):
@@ -229,7 +232,7 @@ func create_resource(args: Dictionary) -> Dictionary:
 		var script: Script = load(script_file) as Script
 		if script == null:
 			return {"ok": false, "error": "No script loads from " + script_file}
-		var uncompiled: String = SceneFile.uncompiled(script, script_file)
+		var uncompiled: String = GdhSceneFile.uncompiled(script, script_file)
 		if not uncompiled.is_empty():
 			return {"ok": false, "error": uncompiled}
 		var base: String = str(script.get_instance_base_type())
@@ -245,13 +248,15 @@ func create_resource(args: Dictionary) -> Dictionary:
 	if not refused.is_empty():
 		return {"ok": false, "error": refused}
 
-	var folder: String = SceneFile.make_folder_for(res_path)
+	var folder: String = GdhSceneFile.make_folder_for(res_path)
 	if not folder.is_empty():
 		return {"ok": false, "error": folder}
+	var answer: Dictionary = {"ok": true, "resourcePath": res_path, "resourceType": asked_type}
+	_properties.note_write(answer)
 	var failed: String = _save_checked(resource, res_path, properties.keys(), null)
 	if not failed.is_empty():
 		return {"ok": false, "error": failed}
-	return {"ok": true, "resourcePath": res_path, "resourceType": asked_type}
+	return answer
 
 
 func modify_resource(args: Dictionary) -> Dictionary:
@@ -284,11 +289,13 @@ func modify_resource(args: Dictionary) -> Dictionary:
 	var refused: String = _properties.write_all(resource, properties)
 	if not refused.is_empty():
 		return {"ok": false, "error": refused}
+	var answer: Dictionary = {"ok": true, "resourcePath": res_path}
+	_properties.note_write(answer)
 	var previous: PackedByteArray = FileAccess.get_file_as_bytes(res_path)
 	var failed: String = _save_checked(resource, res_path, properties.keys(), previous)
 	if not failed.is_empty():
 		return {"ok": false, "error": failed}
-	return {"ok": true, "resourcePath": res_path}
+	return answer
 
 
 ## What a resource file holds, read as a headless engine reads it with no editor connected.
@@ -300,7 +307,7 @@ func read_resource(args: Dictionary) -> Dictionary:
 	var inner: String = str(args.get("subResource", ""))
 	if not inner.is_empty():
 		res_path += "::" + inner
-	return FileReads.resource(res_path, Read.as_bool(args.get("includeDefaults", false)))
+	return GdhFileReads.resource(res_path, GdhRead.as_bool(args.get("includeDefaults", false)))
 
 
 func create_shader(args: Dictionary) -> Dictionary:
@@ -316,7 +323,7 @@ func create_shader(args: Dictionary) -> Dictionary:
 	if code == "":
 		code = SHADER_EMPTY % [shader_type, SHADER_ENTRY.get(shader_type, "fragment")]
 
-	var folder: String = SceneFile.make_folder_for(shader_path)
+	var folder: String = GdhSceneFile.make_folder_for(shader_path)
 	if not folder.is_empty():
 		return {"ok": false, "error": folder}
 	var file: FileAccess = FileAccess.open(shader_path, FileAccess.WRITE)
@@ -339,7 +346,19 @@ func create_tileset(args: Dictionary) -> Dictionary:
 	var tileset_path: String = _ensure_res_path(str(args.get("resourcePath", "")))
 	if tileset_path == "res://":
 		return {"ok": false, "error": "resourcePath is required"}
-	var taken: String = _taken(tileset_path, "resource_edit op=create_tileset")
+	# modify sets properties and builds no atlas, so the other path is the only way on offered.
+	var taken: String = (
+		""
+		if not FileAccess.file_exists(tileset_path)
+		else (
+			(
+				"%s already exists, and create_tileset builds a whole new TileSet, which would replace "
+				+ "everything in it, the tiles a scene paints with among them. Give resourcePath a path "
+				+ "nothing is at."
+			)
+			% tileset_path
+		)
+	)
 	if not taken.is_empty():
 		return {"ok": false, "error": taken}
 
@@ -367,14 +386,21 @@ func create_tileset(args: Dictionary) -> Dictionary:
 				"ok": false,
 				"error": "The TileSet did not take the atlas for %s" % atlas.texture.resource_path
 			}
-		made.append(
-			{"sourceId": added, "texture": atlas.texture.resource_path, "tiles": atlas.get_tiles_count()}
-		)
-
-	var folder: String = SceneFile.make_folder_for(tileset_path)
+		var entry: Dictionary = {
+			"sourceId": added, "texture": atlas.texture.resource_path, "tiles": atlas.get_tiles_count()
+		}
+		var blank: Array = built[2]
+		if not blank.is_empty():
+			entry["leftBlank"] = blank
+		var spare: String = built[3]
+		if not spare.is_empty():
+			entry["notInAnyTile"] = spare
+		made.append(entry)
+
+	var folder: String = GdhSceneFile.make_folder_for(tileset_path)
 	if not folder.is_empty():
 		return {"ok": false, "error": folder}
-	var saving: Error = SceneFile.save_keeping_uid(tileset, tileset_path)
+	var saving: Error = GdhSceneFile.save_keeping_uid(tileset, tileset_path)
 	if saving != OK:
 		return {"ok": false, "error": "Failed to save %s: %s" % [tileset_path, error_string(saving)]}
 
@@ -382,11 +408,14 @@ func create_tileset(args: Dictionary) -> Dictionary:
 	return {"ok": true, "tilesetPath": tileset_path, "sources": made}
 
 
-## One atlas source from its description, with its tiles made, as [true, source] or [false, why].
+## One atlas source from its description, with its tiles made, as [true, source, the grid cells left
+## without a tile for being wholly transparent, a sentence on the pixels no tile covers or ""] or
+## [false, why].
 ##
 ## Tiles are made in every cell of the grid that has a pixel that is not transparent, which is
 ## what the editor offers to do when an atlas gets a texture. Without them the atlas held no tiles,
-## and every cell painted from it drew nothing.
+## and every cell painted from it drew nothing. The cells passed over and the strip a tile size that
+## does not divide the picture leaves are said, since a count alone left a caller to work out which.
 func _atlas(entry: Variant, index: int) -> Array:
 	if not entry is Dictionary:
 		return [false, "sources[%d] must be an object with texture and tileSize" % index]
@@ -448,6 +477,7 @@ func _atlas(entry: Variant, index: int) -> Array:
 			)
 		]
 	var image: Image = texture.get_image()
+	var blank: Array = []
 	for y: int in grid.y:
 		for x: int in grid.x:
 			var cell: Vector2i = Vector2i(x, y)
@@ -457,9 +487,33 @@ func _atlas(entry: Variant, index: int) -> Array:
 				atlas.texture_region_size
 			)
 			if image != null and _blank(image, region):
+				blank.append({"x": x, "y": y})
 				continue
 			atlas.create_tile(cell)
-	return [true, atlas]
+	var covered: Vector2i = atlas.margins + grid * tile_size + (grid - Vector2i.ONE) * atlas.separation
+	var left: Vector2i = Vector2i(texture.get_size()) - covered
+	var sides: PackedStringArray = []
+	if left.x > 0:
+		var _right: bool = sides.append("%d px on the right" % left.x)
+	if left.y > 0:
+		var _bottom: bool = sides.append("%d px at the bottom" % left.y)
+	var spare: String = (
+		""
+		if sides.is_empty()
+		else (
+			"%s is %d by %d, so %s %s in no %d by %d tile."
+			% [
+				texture_path,
+				texture.get_width(),
+				texture.get_height(),
+				" and ".join(sides),
+				"is" if sides.size() == 1 else "are",
+				tile_size.x,
+				tile_size.y
+			]
+		)
+	)
+	return [true, atlas, blank, spare]
 
 
 func _blank(image: Image, region: Rect2i) -> bool:
@@ -468,12 +522,15 @@ func _blank(image: Image, region: Rect2i) -> bool:
 	return image.get_region(region).is_invisible()
 
 
-## The source ids a tile set holds, for saying what a cell could have named instead.
-func _source_ids(tile_set: TileSet) -> Array[int]:
-	var ids: Array[int] = []
+## The sources a tile set holds, as "source 0", "sources 0, 2" or "no sources", for saying what a
+## cell could have named instead.
+func _sources_of(tile_set: TileSet) -> String:
+	var ids: PackedStringArray = []
 	for index: int in tile_set.get_source_count():
-		ids.append(tile_set.get_source_id(index))
-	return ids
+		var _listed: bool = ids.append(str(tile_set.get_source_id(index)))
+	if ids.is_empty():
+		return "no sources"
+	return ("source " if ids.size() == 1 else "sources ") + ", ".join(ids)
 
 
 func set_tilemap_cells(args: Dictionary) -> Dictionary:
@@ -491,12 +548,12 @@ func set_tilemap_cells(args: Dictionary) -> Dictionary:
 	if placed.is_empty():
 		return {"ok": false, "error": "cells is empty, so there is nothing to place"}
 
-	var scene: SceneFile = SceneFile.new()
+	var scene: GdhSceneFile = GdhSceneFile.new()
 	var refused: Dictionary = scene.open(scene_path, true)
 	if not refused.is_empty():
 		return refused
 
-	var layer: int = Read.as_int(args.get("layer", 0))
+	var layer: int = GdhRead.as_int(args.get("layer", 0))
 	var found: Array = _tile_node(scene, node_path, layer)
 	if found[0] == null:
 		return scene.refuse(str(found[1]))
@@ -510,11 +567,20 @@ func set_tilemap_cells(args: Dictionary) -> Dictionary:
 	var tile_set: TileSet = layered.tile_set if layered != null else single.tile_set
 
 	scene.asked(node, ["layer_%d/tile_data" % layer if layered != null else "tile_map_data"])
-	var wanted: Array = []
+	# Every cell is checked before any is placed, and every one refused is named: stopping at the first
+	# left a caller fixing one cell a call.
+	var checked: Array = []
+	var refusals: PackedStringArray = []
 	for index: int in placed.size():
 		var cell: Array = _cell(placed[index], index, tile_set)
 		if not cell[0]:
-			return scene.refuse(str(cell[1]))
+			var _named: bool = refusals.append(str(cell[1]))
+		checked.append(cell)
+	if not refusals.is_empty():
+		return scene.refuse("%s. Nothing was placed." % "; ".join(refusals))
+	var wanted: Array = []
+	var erased: int = 0
+	for cell: Array in checked:
 		var at: Vector2i = cell[1]
 		var source_id: int = cell[2]
 		var atlas_coords: Vector2i = cell[3]
@@ -524,6 +590,8 @@ func set_tilemap_cells(args: Dictionary) -> Dictionary:
 		else:
 			single.set_cell(at, source_id, atlas_coords, alternative)
 		wanted.append([at, source_id, atlas_coords, alternative])
+		if source_id == -1:
+			erased += 1
 
 	var at_path: String = scene.path_of(node)
 	var written: Dictionary = scene.write(
@@ -539,12 +607,18 @@ func set_tilemap_cells(args: Dictionary) -> Dictionary:
 	if not written.is_empty():
 		return written
 
-	return {"ok": true, "layer": layer, "placed": wanted.size(), "requested": placed.size()}
+	return {
+		"ok": true,
+		"layer": layer,
+		"placed": wanted.size() - erased,
+		"erased": erased,
+		"requested": placed.size()
+	}
 
 
 ## The node at [param node_path] cells are painted on, with a TileSet, as [node, why not].
 ## TileMapLayer is the node since 4.3, and TileMap the one it replaced, which keeps its layers.
-func _tile_node(scene: SceneFile, node_path: String, layer: int) -> Array:
+func _tile_node(scene: GdhSceneFile, node_path: String, layer: int) -> Array:
 	var node: Node = (
 		scene.root if node_path == "." or node_path == "" else scene.root.get_node_or_null(node_path)
 	)
@@ -568,40 +642,55 @@ func _tile_node(scene: SceneFile, node_path: String, layer: int) -> Array:
 
 
 ## One cell from its description, checked against [param tile_set], as
-## [true, coords, source id, atlas coords, alternative] or [false, why].
+## [true, coords, source id, atlas coords, alternative] or [false, why]. A source of -1 erases the
+## cell, as set_cell takes it, and needs no atlasCoords.
 func _cell(entry: Variant, index: int, tile_set: TileSet) -> Array:
 	if not entry is Dictionary:
 		return [false, "cells[%d] must be an object with coords, sourceId and atlasCoords" % index]
 	var cell: Dictionary = entry
-	for field: String in ["coords", "sourceId", "atlasCoords"]:
+	for field: String in ["coords", "sourceId"]:
 		if not cell.has(field):
 			return [false, "cells[%d] has no %s" % [index, field]]
 	var at: Array = _xy(cell["coords"], "cells[%d].coords" % index)
 	if not at[0]:
 		return at
+	var coords: Vector2i = at[1]
+	var named: String = "cells[%d] at (%d, %d)" % [index, coords.x, coords.y]
+	var source_id: int = GdhRead.as_int(cell["sourceId"], -2)
+	if source_id == -1:
+		return [true, coords, -1, Vector2i(-1, -1), -1]
+	if not cell.has("atlasCoords"):
+		return [
+			false, "%s has no atlasCoords, which every cell but an erased one (sourceId -1) needs" % named
+		]
 	var atlas_at: Array = _xy(cell["atlasCoords"], "cells[%d].atlasCoords" % index)
 	if not atlas_at[0]:
 		return atlas_at
-	var source_id: int = Read.as_int(cell["sourceId"], -1)
 	if not tile_set.has_source(source_id):
-		return [false, "The TileSet has no source %d; it has %s" % [source_id, _source_ids(tile_set)]]
+		return [
+			false,
+			(
+				"%s names source %d, and the TileSet has %s; sourceId -1 erases a cell"
+				% [named, source_id, _sources_of(tile_set)]
+			)
+		]
 	var source: TileSetSource = tile_set.get_source(source_id)
 	var atlas_coords: Vector2i = atlas_at[1]
-	var alternative: int = Read.as_int(cell.get("alternativeTile", 0))
+	var alternative: int = GdhRead.as_int(cell.get("alternativeTile", 0))
 	if not source.has_tile(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)]
-			)
+			"%s: source %d has no tile at %s; it has %s" % [named, source_id, atlas_coords, _tiles_of(source)]
 		]
 	if not source.has_alternative_tile(atlas_coords, alternative):
 		return [
 			false,
-			"The tile at %s in source %d has no alternative %d" % [atlas_coords, source_id, alternative]
+			(
+				"%s: the tile at %s in source %d has no alternative %d"
+				% [named, atlas_coords, source_id, alternative]
+			)
 		]
-	return [true, at[1], source_id, atlas_coords, alternative]
+	return [true, coords, source_id, atlas_coords, alternative]
 
 
 ## The atlas coordinates [param source] has tiles at, the first twelve and how many more, or that it
@@ -691,12 +780,12 @@ func _cell_at(node: Node, layer: int, at: Vector2i) -> Array:
 ## Saves [param theme] over [param theme_path] with [param item] changed, answering "" or why not.
 func _save_theme(theme: Theme, theme_path: String, item: String) -> String:
 	var previous: PackedByteArray = FileAccess.get_file_as_bytes(theme_path)
-	var saving: Error = SceneFile.save_keeping_uid(theme, theme_path)
+	var saving: Error = GdhSceneFile.save_keeping_uid(theme, theme_path)
 	if saving != OK:
 		return "Failed to save %s: %s" % [theme_path, error_string(saving)]
 	var unkept: String = _unkept_headless(theme, theme_path, [item], previous)
 	if not unkept.is_empty():
-		return "Nothing was written: " + unkept + HeadlessCheck.put_back(theme_path, previous)
+		return "Nothing was written: " + unkept + GdhHeadlessCheck.put_back(theme_path, previous)
 	_written(theme_path)
 	return ""
 
@@ -715,13 +804,12 @@ func set_theme_color(args: Dictionary) -> Dictionary:
 	if theme == null:
 		return {"ok": false, "error": "No Theme at %s. Create one there first." % theme_path}
 
-	var c: Dictionary = args.get("color", {})
-	var color: Color = Color(
-		Read.as_float(c.get("r", 1.0), 1.0),
-		Read.as_float(c.get("g", 1.0), 1.0),
-		Read.as_float(c.get("b", 1.0), 1.0),
-		Read.as_float(c.get("a", 1.0), 1.0)
-	)
+	# Read as a property write reads a colour, html code included, so a value scene_node takes for a
+	# Button's modulate is taken for its theme colour too; "#ff8000" was refused here alone.
+	var parsed: Array = _properties.colour_from(args.get("color", {}), "color")
+	if not parsed[0]:
+		return {"ok": false, "error": parsed[1]}
+	var color: Color = parsed[1]
 	theme.set_color(color_name, control_type, color)
 
 	var unsaved: String = _save_theme(theme, theme_path, "%s/colors/%s" % [control_type, color_name])
@@ -760,18 +848,19 @@ func set_theme_font_size(args: Dictionary) -> Dictionary:
 
 	# Godot reads a size of 0 or less as unset and answers the theme's default, so -3 would be read
 	# back as 16.
-	var pixels: float = Read.as_float(args.get("size"), 0.0)
-	if not is_finite(pixels) or pixels < 1 or pixels != floorf(pixels):
-		var shown: String = str(int(pixels)) if pixels == floorf(pixels) else str(pixels)
+	var pixels: float = GdhRead.as_float(args.get("size"), 0.0)
+	if not is_finite(pixels) or pixels != floorf(pixels):
+		return {"ok": false, "error": "size is a whole number of pixels, and %s is not one." % str(pixels)}
+	if pixels < 1:
 		return {
 			"ok": false,
 			"error":
 			(
 				(
-					"size must be a whole number of pixels, 1 or more, not %s: Godot reads 0 or less as no size "
-					% shown
+					"size must be 1 or more, not %d: the theme would hold it, and Godot reads a size of 0 or "
+					+ "less as unset and draws the default size instead."
 				)
-				+ "and uses the theme's default instead."
+				% int(pixels)
 			)
 		}
 	theme.set_font_size(font_size_name, control_type, int(pixels))
@@ -812,4 +901,16 @@ func _noting_variation(answer: Dictionary) -> Dictionary:
 		)
 		% [type, type]
 	)
+	# A variation is any name, so a misspelt class is written all the same, and the classes nearest
+	# it are what tells a caller which one was meant.
+	var themed: PackedStringArray = []
+	for known: String in ClassDB.get_class_list():
+		if ClassDB.is_parent_class(known, "Control") or ClassDB.is_parent_class(known, "Window"):
+			var _added: bool = themed.append(known)
+	var close: PackedStringArray = GdhRead.nearest(type, themed)
+	if not close.is_empty():
+		answer["note"] += (
+			" If a class was meant, the nearest %s %s."
+			% ["is" if close.size() == 1 else "are", ", ".join(close)]
+		)
 	return answer

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

@@ -4,9 +4,9 @@ extends RefCounted
 ## The two ways a scene keeps its own values for nodes another scene makes: by inheriting that scene,
 ## or by instancing it with its children editable.
 
-const FileReads = preload("../file_reads.gd")
-const Paths = preload("scene_paths.gd")
-const SceneFile = preload("../scene_file.gd")
+const GdhFileReads = preload("../file_reads.gd")
+const GdhPaths = preload("scene_paths.gd")
+const GdhSceneFile = preload("../scene_file.gd")
 
 
 ## Why a create at [param scene_path] is refused when a file is there already, which saving over
@@ -45,7 +45,7 @@ static func inherited(
 		script = load(script_path) as Script
 		if script == null:
 			return {"ok": false, "error": "No script loads from " + script_path}
-		var uncompiled: String = SceneFile.uncompiled(script, script_path)
+		var uncompiled: String = GdhSceneFile.uncompiled(script, script_path)
 		if not uncompiled.is_empty():
 			return {"ok": false, "error": uncompiled}
 	return inherit(scene_path, base_path, str(args.get("rootNodeName", "")), script)
@@ -59,12 +59,12 @@ static func inherited(
 ## the base: a headless engine making that instance runs every script in the base, and the pack would
 ## keep what they set as this scene's own values.
 static func inherit(scene_path: String, base_path: String, root_name: String, script: Script) -> Dictionary:
-	var base: Dictionary = FileReads.scene_node(base_path, ".")
+	var base: Dictionary = GdhFileReads.scene_node(base_path, ".")
 	if not base.get("ok", false):
 		return {"ok": false, "error": "inherits: " + str(base.get("error", "%s holds no nodes" % base_path))}
 	var root_type: String = str(base["type"])
 	var name: String = str(base["name"]) if root_name.is_empty() else root_name
-	var unfit: String = SceneFile.unfit_name(name)
+	var unfit: String = GdhSceneFile.unfit_name(name)
 	if not unfit.is_empty():
 		return {"ok": false, "error": unfit}
 	if script != null:
@@ -78,7 +78,7 @@ static func inherit(scene_path: String, base_path: String, root_name: String, sc
 					% [script.resource_path, extended, root_type, base_path]
 				)
 			}
-	var folder: String = SceneFile.make_folder_for(scene_path)
+	var folder: String = GdhSceneFile.make_folder_for(scene_path)
 	if not folder.is_empty():
 		return {"ok": false, "error": folder}
 
@@ -87,14 +87,14 @@ static func inherit(scene_path: String, base_path: String, root_name: String, sc
 		"",
 		(
 			'[ext_resource type="PackedScene"%s path="%s" id="1_base"]'
-			% [SceneFile.reference_uid(base_path), base_path]
+			% [GdhSceneFile.reference_uid(base_path), base_path]
 		),
 	]
 	if script != null:
 		var _resourced: bool = lines.append(
 			(
 				'[ext_resource type="Script"%s path="%s" id="2_script"]'
-				% [SceneFile.reference_uid(script.resource_path), script.resource_path]
+				% [GdhSceneFile.reference_uid(script.resource_path), script.resource_path]
 			)
 		)
 	lines.append_array(["", '[node name="%s" instance=ExtResource("1_base")]' % name])
@@ -117,7 +117,7 @@ static func inherit(scene_path: String, base_path: String, root_name: String, sc
 			"error":
 			"%s did not load back as a scene inheriting %s, so it was removed." % [scene_path, base_path]
 		}
-	SceneFile.refresh(scene_path)
+	GdhSceneFile.refresh(scene_path)
 	return {
 		"ok": true,
 		"scenePath": scene_path,
@@ -130,8 +130,8 @@ static func inherit(scene_path: String, base_path: String, root_name: String, sc
 ## Makes the children of [param node], an instance in [param scene], editable or not, answering why
 ## it cannot or "". With them editable the scene keeps its own values for them, as the editor's
 ## Editable Children does; made not editable again, the values it kept for them are dropped. The
-## caller has had [method SceneFile.foreign] refuse a node inside an instance that is not editable.
-static func set_editable(scene: SceneFile, node: Node, editable: bool) -> String:
+## caller has had [method GdhSceneFile.foreign] refuse a node inside an instance that is not editable.
+static func set_editable(scene: GdhSceneFile, node: Node, editable: bool) -> String:
 	if node.owner == null or node.scene_file_path.is_empty():
 		return (
 			"editableChildren is a setting of an instance in this scene, and %s is not one."
@@ -152,7 +152,7 @@ static func set_editable(scene: SceneFile, node: Node, editable: bool) -> String
 ## for a node deleted, they are only named. Answers followed, the scenes rewritten, and
 ## notFollowed, each one left as it was with why, each only when it names any, with what
 ## [param carried] gives.
-static func follow(changed: String, old_path: String, new_path: String, carried: Paths) -> Dictionary:
+static func follow(changed: String, old_path: String, new_path: String, carried: GdhPaths) -> Dictionary:
 	var texts: Dictionary = {}
 	_read_scenes("res://", texts)
 	var kin: Array[String] = [changed]
@@ -176,14 +176,14 @@ static func follow(changed: String, old_path: String, new_path: String, carried:
 		var moves: Dictionary = {}
 		if _inherits(scene_path, changed, texts):
 			moves[old_path] = new_path
-		var read: Dictionary = FileReads.scene_tree(scene_path, -1, false)
+		var read: Dictionary = GdhFileReads.scene_tree(scene_path, -1, false)
 		if not read.get("ok", false):
 			not_followed.append({"scenePath": scene_path, "reason": str(read.get("error", ""))})
 			continue
 		var tree: Dictionary = read["tree"]
 		_instances_of(tree, changed, old_path, new_path, moves)
 		var text: String = texts[scene_path]
-		var unsaved: String = SceneFile.unsaved_in_editor(scene_path)
+		var unsaved: String = GdhSceneFile.unsaved_in_editor(scene_path)
 		var rewritten: String = text
 		if not new_path.is_empty():
 			rewritten = _rewritten(text, moves, old_path.get_base_dir() != new_path.get_base_dir())
@@ -198,7 +198,7 @@ static func follow(changed: String, old_path: String, new_path: String, carried:
 				)
 				continue
 			file.close()
-			SceneFile.refresh(scene_path)
+			GdhSceneFile.refresh(scene_path)
 			followed.append(scene_path)
 		if moves.is_empty() or not text.contains("NodePath("):
 			continue
@@ -335,7 +335,7 @@ static func _attribute_moved(
 	var found: RegExMatch = RegEx.create_from_string(' %s="([^"]*)"' % attribute).search(line)
 	if found == null:
 		return line
-	var moved: String = Paths.moved(found.get_string(1), moves)
+	var moved: String = GdhPaths.moved(found.get_string(1), moves)
 	if moved == found.get_string(1):
 		return line
 	var placed: String = _attribute_set(line, attribute, moved)