gdharness 1.3.0 → 1.3.1

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

@@ -8,7 +8,8 @@ extends RefCounted
 ## before: the same Vector2 came back three ways depending on which tool was asked, and a caller
 ## reading a property off the editor could not feed it back to the game.
 
-const Read = preload("reading.gd")
+const GdhRead = preload("reading.gd")
+const GdhShapes = preload("value_shapes.gd")
 
 # What the engine carries from one to another without complaint, which is what a value written to a
 # property or handed to a parameter may arrive as. Numbers include bool because the engine counts it
@@ -120,35 +121,6 @@ const BUILDERS: Dictionary = {
 	"Dictionary": "_build_dictionary",
 }
 
-# What each tag has to carry before it is built. A tag naming a type whose keys are not there is a
-# tag somebody wrote by mistake or wrote for a different shape, and building one out of defaults
-# answers with a Transform2D of zeros where the caller meant something else entirely. Unbuilt, it
-# comes back as it arrived, and whoever asked can read it against the type they were expecting.
-const REQUIRED: Dictionary = {
-	"Vector2": [["x", "y"]],
-	"Vector2i": [["x", "y"]],
-	"Vector3": [["x", "y", "z"]],
-	"Vector3i": [["x", "y", "z"]],
-	"Vector4": [["x", "y", "z", "w"]],
-	"Vector4i": [["x", "y", "z", "w"]],
-	"Rect2": [["position", "size"], ["x", "y", "width", "height"]],
-	"Rect2i": [["position", "size"], ["x", "y", "width", "height"]],
-	"Plane": [["normal", "d"]],
-	"Quaternion": [["x", "y", "z", "w"]],
-	"AABB": [["position", "size"]],
-	"Basis": [["x", "y", "z"]],
-	"Transform2D": [["x", "y", "origin"]],
-	"Transform3D": [["basis", "origin"]],
-	"Projection": [["x", "y", "z", "w"]],
-	"Color": [["r", "g", "b"]],
-	"NodePath": [["path"]],
-	"PackedByteArray": [["base64"]],
-	"float": [["value"]],
-	"int": [["value"]],
-	"RID": [["id"]],
-	"Dictionary": [["entries"]],
-}
-
 
 # Converts a Godot value into something JSON can carry. A type with no entry in the table
 # passes through as itself, which is what the JSON-native ones want.
@@ -246,8 +218,8 @@ func deserialize_value(value: Variant) -> Variant:
 	# under the target project's warning levels, so one such project lost every headless call.
 	var tag: String = str(fields["_type"])
 	var builder: String = BUILDERS.get(tag, "")
-	var needed: Array = REQUIRED.get(tag, [])
-	if builder.is_empty() or not _carries(fields, needed):
+	var spare: Array = GdhShapes.spare(fields, tag)
+	if builder.is_empty() or not spare.any(func(left: Array) -> bool: return left.is_empty()):
 		return fields
 	if tag == "float" and str(fields["value"]) not in ["inf", "-inf", "nan"]:
 		return fields
@@ -430,6 +402,11 @@ func fitted(value: Variant, type: int) -> Variant:
 	if rebuilt is Array and LIST_TYPES.has(type):
 		return type_convert(rebuilt, type)
 
+	# The inspector and every colour picker give a colour as its html code. Anything else stays the
+	# text it is, for the refusal to name.
+	if type == TYPE_COLOR and rebuilt is String and Color.html_is_valid(str(rebuilt)):
+		return Color.html(str(rebuilt))
+
 	var simple: Array[int] = [TYPE_BOOL, TYPE_INT, TYPE_FLOAT, TYPE_STRING]
 	if not simple.has(type) or not simple.has(typeof(rebuilt)):
 		return rebuilt
@@ -441,7 +418,7 @@ func fitted(value: Variant, type: int) -> Variant:
 
 	if rebuilt is String and type != TYPE_STRING:
 		var text: String = rebuilt
-		var parsed: Variant = Read.json_or_null(text)
+		var parsed: Variant = GdhRead.json_or_null(text)
 		# A string that does not read as the type wanted is handed back as the string it is, so
 		# whoever asked can refuse it. type_convert answers 0 for "not an index" and true for any
 		# text at all, and a caller who sent a word got back a number they never sent: get_child
@@ -461,7 +438,7 @@ func fitted(value: Variant, type: int) -> Variant:
 static func inexact(given: Variant, type: int) -> String:
 	if type != TYPE_INT or (typeof(given) != TYPE_FLOAT and typeof(given) != TYPE_INT):
 		return ""
-	var number: float = Read.as_float(given)
+	var number: float = GdhRead.as_float(given)
 	if not is_finite(number) or absf(number) < EXACT:
 		return ""
 	return (
@@ -474,34 +451,6 @@ static func inexact(given: Variant, type: int) -> String:
 	)
 
 
-## How a value of [param type] is written to be read as one, for a refusal to name, or empty for a
-## type that is not built from fields. A refusal naming only the two types left a caller to find
-## the shape in the description of another op.
-static func written_as(type: int) -> String:
-	var tag: String = type_string(type)
-	var alternatives: Array = REQUIRED.get(tag, [])
-	if alternatives.is_empty() or tag in ["float", "int", "Dictionary"]:
-		return ""
-	var keys: Array = alternatives[0]
-	var parts: Array[String] = []
-	for key: Variant in keys:
-		parts.append('"%s": ...' % key)
-	return "{%s}" % ", ".join(parts)
-
-
-## Whether [param fields] carries every key of any one of [param alternatives].
-##
-## More than one spelling because a rectangle has two: the two corners it is answered with, and the
-## four numbers the editor's own tools answered with before the serialisers were made one, which a
-## caller may have kept.
-func _carries(fields: Dictionary, alternatives: Array) -> bool:
-	for alternative: Variant in alternatives:
-		var keys: Array = alternative
-		if keys.all(func(key: Variant) -> bool: return fields.has(key)):
-			return true
-	return false
-
-
 func _serialize_nil(_value: Variant) -> Variant:
 	return null
 
@@ -769,42 +718,44 @@ func _describe_object(value: Object) -> Dictionary:
 
 
 func _build_vector2(fields: Dictionary) -> Vector2:
-	return Vector2(Read.as_float(fields.get("x", 0)), Read.as_float(fields.get("y", 0)))
+	return Vector2(GdhRead.as_float(fields.get("x", 0)), GdhRead.as_float(fields.get("y", 0)))
 
 
 func _build_vector2i(fields: Dictionary) -> Vector2i:
-	return Vector2i(Read.as_int(fields.get("x", 0)), Read.as_int(fields.get("y", 0)))
+	return Vector2i(GdhRead.as_int(fields.get("x", 0)), GdhRead.as_int(fields.get("y", 0)))
 
 
 func _build_vector3(fields: Dictionary) -> Vector3:
 	return Vector3(
-		Read.as_float(fields.get("x", 0)),
-		Read.as_float(fields.get("y", 0)),
-		Read.as_float(fields.get("z", 0))
+		GdhRead.as_float(fields.get("x", 0)),
+		GdhRead.as_float(fields.get("y", 0)),
+		GdhRead.as_float(fields.get("z", 0))
 	)
 
 
 func _build_vector3i(fields: Dictionary) -> Vector3i:
 	return Vector3i(
-		Read.as_int(fields.get("x", 0)), Read.as_int(fields.get("y", 0)), Read.as_int(fields.get("z", 0))
+		GdhRead.as_int(fields.get("x", 0)),
+		GdhRead.as_int(fields.get("y", 0)),
+		GdhRead.as_int(fields.get("z", 0))
 	)
 
 
 func _build_vector4(fields: Dictionary) -> Vector4:
 	return Vector4(
-		Read.as_float(fields.get("x", 0)),
-		Read.as_float(fields.get("y", 0)),
-		Read.as_float(fields.get("z", 0)),
-		Read.as_float(fields.get("w", 0))
+		GdhRead.as_float(fields.get("x", 0)),
+		GdhRead.as_float(fields.get("y", 0)),
+		GdhRead.as_float(fields.get("z", 0)),
+		GdhRead.as_float(fields.get("w", 0))
 	)
 
 
 func _build_vector4i(fields: Dictionary) -> Vector4i:
 	return Vector4i(
-		Read.as_int(fields.get("x", 0)),
-		Read.as_int(fields.get("y", 0)),
-		Read.as_int(fields.get("z", 0)),
-		Read.as_int(fields.get("w", 0))
+		GdhRead.as_int(fields.get("x", 0)),
+		GdhRead.as_int(fields.get("y", 0)),
+		GdhRead.as_int(fields.get("z", 0)),
+		GdhRead.as_int(fields.get("w", 0))
 	)
 
 
@@ -813,10 +764,10 @@ func _build_vector4i(fields: Dictionary) -> Vector4i:
 func _build_rect2(fields: Dictionary) -> Rect2:
 	if not fields.has("position"):
 		return Rect2(
-			Read.as_float(fields.get("x", 0)),
-			Read.as_float(fields.get("y", 0)),
-			Read.as_float(fields.get("width", 0)),
-			Read.as_float(fields.get("height", 0))
+			GdhRead.as_float(fields.get("x", 0)),
+			GdhRead.as_float(fields.get("y", 0)),
+			GdhRead.as_float(fields.get("width", 0)),
+			GdhRead.as_float(fields.get("height", 0))
 		)
 	return Rect2(_vector2_at(fields, "position"), _vector2_at(fields, "size"))
 
@@ -824,24 +775,24 @@ func _build_rect2(fields: Dictionary) -> Rect2:
 func _build_rect2i(fields: Dictionary) -> Rect2i:
 	if not fields.has("position"):
 		return Rect2i(
-			Read.as_int(fields.get("x", 0)),
-			Read.as_int(fields.get("y", 0)),
-			Read.as_int(fields.get("width", 0)),
-			Read.as_int(fields.get("height", 0))
+			GdhRead.as_int(fields.get("x", 0)),
+			GdhRead.as_int(fields.get("y", 0)),
+			GdhRead.as_int(fields.get("width", 0)),
+			GdhRead.as_int(fields.get("height", 0))
 		)
 	return Rect2i(_vector2i_at(fields, "position"), _vector2i_at(fields, "size"))
 
 
 func _build_plane(fields: Dictionary) -> Plane:
-	return Plane(_vector3_at(fields, "normal"), Read.as_float(fields.get("d", 0)))
+	return Plane(_vector3_at(fields, "normal"), GdhRead.as_float(fields.get("d", 0)))
 
 
 func _build_quaternion(fields: Dictionary) -> Quaternion:
 	return Quaternion(
-		Read.as_float(fields.get("x", 0)),
-		Read.as_float(fields.get("y", 0)),
-		Read.as_float(fields.get("z", 0)),
-		Read.as_float(fields.get("w", 0))
+		GdhRead.as_float(fields.get("x", 0)),
+		GdhRead.as_float(fields.get("y", 0)),
+		GdhRead.as_float(fields.get("z", 0)),
+		GdhRead.as_float(fields.get("w", 0))
 	)
 
 
@@ -881,10 +832,10 @@ func _build_projection(fields: Dictionary) -> Projection:
 
 func _build_color(fields: Dictionary) -> Color:
 	return Color(
-		Read.as_float(fields.get("r", 0)),
-		Read.as_float(fields.get("g", 0)),
-		Read.as_float(fields.get("b", 0)),
-		Read.as_float(fields.get("a", 1), 1.0)
+		GdhRead.as_float(fields.get("r", 0)),
+		GdhRead.as_float(fields.get("g", 0)),
+		GdhRead.as_float(fields.get("b", 0)),
+		GdhRead.as_float(fields.get("a", 1), 1.0)
 	)
 
 
@@ -897,7 +848,7 @@ func _build_bytes(fields: Dictionary) -> PackedByteArray:
 
 
 func _build_float(fields: Dictionary) -> float:
-	return Read.as_float(fields)
+	return GdhRead.as_float(fields)
 
 
 func _build_int(fields: Dictionary) -> int:

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

@@ -0,0 +1,111 @@
+extends RefCounted
+
+## How each engine type built from fields is written: the fields it needs, the ones it reads when
+## they are there, and what a refusal says about a value that is not one.
+##
+## This file is the one beside the operations, and `bun run sync:gd` copies it into each addon.
+
+# What each tag has to carry before it is built. A tag naming a type whose keys are not there is a
+# tag somebody wrote by mistake or wrote for a different shape, and building one out of defaults
+# answers with a Transform2D of zeros where the caller meant something else entirely. Unbuilt, it
+# comes back as it arrived, and whoever asked can read it against the type they were expecting.
+const REQUIRED: Dictionary = {
+	"Vector2": [["x", "y"]],
+	"Vector2i": [["x", "y"]],
+	"Vector3": [["x", "y", "z"]],
+	"Vector3i": [["x", "y", "z"]],
+	"Vector4": [["x", "y", "z", "w"]],
+	"Vector4i": [["x", "y", "z", "w"]],
+	"Rect2": [["position", "size"], ["x", "y", "width", "height"]],
+	"Rect2i": [["position", "size"], ["x", "y", "width", "height"]],
+	"Plane": [["normal", "d"]],
+	"Quaternion": [["x", "y", "z", "w"]],
+	"AABB": [["position", "size"]],
+	"Basis": [["x", "y", "z"]],
+	"Transform2D": [["x", "y", "origin"]],
+	"Transform3D": [["basis", "origin"]],
+	"Projection": [["x", "y", "z", "w"]],
+	"Color": [["r", "g", "b"]],
+	"NodePath": [["path"]],
+	"PackedByteArray": [["base64"]],
+	"float": [["value"]],
+	"int": [["value"]],
+	"RID": [["id"]],
+	"Dictionary": [["entries"]],
+}
+## The fields a builder reads when they are there and does without when not.
+const OPTIONAL: Dictionary = {
+	"Color": ["a"],
+	"PackedByteArray": ["size"],
+}
+
+
+## How a value of [param type] is written to be read as one, for a refusal to name, or empty for a
+## type that is not built from fields. A refusal naming only the two types leaves a caller to find
+## the shape in the description of another op.
+static func written_as(type: int) -> String:
+	var tag: String = type_string(type)
+	var alternatives: Array = REQUIRED.get(tag, [])
+	if alternatives.is_empty() or tag in ["float", "int", "Dictionary"]:
+		return ""
+	var keys: Array = alternatives[0]
+	var optional: Array = OPTIONAL.get(tag, [])
+	var parts: Array[String] = []
+	for key: Variant in keys + optional:
+		parts.append('"%s": ...' % key)
+	var shape: String = "{%s}" % ", ".join(parts)
+	if type == TYPE_COLOR:
+		return shape + ' or as its html code, "#ff8000"'
+	return shape
+
+
+## The keys of [param fields] that a [param tag] built from them would not read, one list for each
+## spelling of its fields carried whole. A rectangle has two: its corners, and four numbers.
+##
+## A builder drops a key it does not know without a word, so {"x": 1, "y": 2, "z": 3} for a Vector2
+## would be written as (1, 2) and answered as written: a value is built only when a list is empty.
+static func spare(fields: Dictionary, tag: String) -> Array:
+	var optional: Array = OPTIONAL.get(tag, [])
+	var lists: Array = []
+	var alternatives: Array = REQUIRED.get(tag, [])
+	for alternative: Variant in alternatives:
+		var keys: Array = alternative
+		if keys.all(func(key: Variant) -> bool: return fields.has(key)):
+			var over: Callable = func(key: Variant) -> bool:
+				return str(key) != "_type" and not keys.has(key) and not optional.has(key)
+			lists.append(fields.keys().filter(over))
+	return lists
+
+
+## The sentences a refusal of [param value] where a [param type] goes ends with: which of its keys
+## kept it from being read as one, and how one is written. Empty for a type not built from fields.
+##
+## The refusal names only the two types, and the key is what the caller has to take out.
+static func remedy(value: Variant, type: int) -> String:
+	var shape: String = written_as(type)
+	if shape.is_empty():
+		return ""
+	return _unread(value, type) + " A %s is sent as %s." % [type_string(type), shape]
+
+
+static func _unread(value: Variant, type: int) -> String:
+	if not value is Dictionary:
+		return ""
+	var fields: Dictionary = value
+	var tag: String = type_string(type)
+	var lists: Array = spare(fields, tag)
+	var built: bool = lists.any(func(over: Array) -> bool: return over.is_empty())
+	if lists.is_empty() or built or str(fields.get("_type", tag)) != tag:
+		return ""
+	lists.sort_custom(func(a: Array, b: Array) -> bool: return a.size() < b.size())
+	var left: Array = lists[0]
+	var named: PackedStringArray = []
+	for key: Variant in left:
+		var _named: bool = named.append('"%s"' % key)
+	var fields_called: String = "field called" if named.size() == 1 else "fields called"
+	var note: String = (
+		" A %s has no %s %s, so the value is not read as one" % [tag, fields_called, " or ".join(named)]
+	)
+	if left.has("type") and not fields.has("_type"):
+		return note + ': a value names its type under "_type".'
+	return note + "."

package/build/godot/addons/gdharness_runtime/value_shapes.gd.uid

@@ -0,0 +1 @@
+uid://c1s610pw8xorl

package/build/godot/operations/animation_reads.gd

@@ -4,9 +4,8 @@ extends RefCounted
 ## and by a headless engine with none connected from a bare node of the class given what the file
 ## stores, which runs no script of the scene's, so a read answers the same either way.
 
-const FileReads = preload("file_reads.gd")
-const Read = preload("reading.gd")
-const Serialisation = preload("serialisation.gd")
+const GdhFileReads = preload("file_reads.gd")
+const GdhSerialisation = preload("serialisation.gd")
 
 const LOOP_MODE_NAMES: Dictionary[int, String] = {
 	Animation.LOOP_NONE: "none",
@@ -56,21 +55,10 @@ static func scene_states(scene_path: String, tree_path: String, state_machine_pa
 ## A node of the class the file gives the node at [param node_path], holding every property the
 ## files set but its script, as [node, null] or [null, refusal]. The caller frees it.
 static func _bare(scene_path: String, node_path: String, kind: String) -> Array:
-	var read: Dictionary = FileReads.scene_node(scene_path, node_path)
-	if not read.is_empty() and not read.get("ok", false):
+	var read: Dictionary = GdhFileReads.scene_node_of_kind(scene_path, node_path, kind)
+	if not read.get("ok", false):
 		return [null, read]
-	var type: String = str(read.get("type", ""))
-	if not ClassDB.class_exists(type) or not ClassDB.is_parent_class(type, kind):
-		var said: String = "%s not found at: %s" % [kind, node_path]
-		if read.is_empty():
-			var hinted: String = said
-			if FileReads.scene_node(scene_path, node_path.get_slice("/", 0)).is_empty():
-				hinted = Read.from_the_root(
-					said, node_path, str(FileReads.scene_node(scene_path, ".").get("name", ""))
-				)
-			said = hinted if hinted != said else FileReads.missing_from(said, scene_path, node_path)
-		return [null, {"ok": false, "error": said}]
-	var bare: Node = ClassDB.instantiate(type)
+	var bare: Node = ClassDB.instantiate(str(read["type"]))
 	bare.name = str(read["name"])
 	var given: Dictionary = read["properties"]
 	for property: Variant in given:
@@ -107,7 +95,7 @@ static func animations(player: AnimationPlayer, animation_name: String) -> Dicti
 	answer["ok"] = true
 	answer["animationName"] = animation_name
 	var tracks: Array[Dictionary] = []
-	var values: Serialisation = Serialisation.new()
+	var values: GdhSerialisation = GdhSerialisation.new()
 	for track: int in anim.get_track_count():
 		tracks.append(_track(anim, track, values))
 	answer["tracks"] = tracks
@@ -122,7 +110,7 @@ static func _summary(anim: Animation) -> Dictionary:
 	}
 
 
-static func _track(anim: Animation, track: int, values: Serialisation) -> Dictionary:
+static func _track(anim: Animation, track: int, values: GdhSerialisation) -> Dictionary:
 	var kind: int = anim.track_get_type(track)
 	var path: NodePath = anim.track_get_path(track)
 	var shaped: Dictionary = {

package/build/godot/operations/audio_buses.gd

@@ -3,13 +3,13 @@ extends RefCounted
 # The bus layout is a project resource the engine loads at startup and this process holds in
 # memory, so every change is written back to that file or it is gone with the process.
 
-const Read = preload("reading.gd")
-const Log = preload("logger.gd")
+const GdhRead = preload("reading.gd")
+const GdhLog = preload("logger.gd")
 
-var _log: Log
+var _log: GdhLog
 
 
-func _init(p_log: Log) -> void:
+func _init(p_log: GdhLog) -> void:
 	_log = p_log
 
 
@@ -17,7 +17,7 @@ func create_audio_bus(params: Dictionary) -> Dictionary:
 	var bus_name: String = str(params.get("bus_name", ""))
 	if bus_name.is_empty():
 		return _log.failure("bus_name is required")
-	var parent_idx: int = Read.as_int(params.get("parent_bus_index", 0))
+	var parent_idx: int = GdhRead.as_int(params.get("parent_bus_index", 0))
 	if parent_idx < 0 or parent_idx >= AudioServer.bus_count:
 		return _log.failure("No bus at index " + str(parent_idx))
 	# Sends are by name, so a second bus with one would leave every send to it meaning either.
@@ -100,10 +100,10 @@ func get_audio_buses(_params: Dictionary) -> Dictionary:
 
 
 func set_audio_bus_effect(params: Dictionary) -> Dictionary:
-	var bus_idx: int = Read.as_int(params.get("bus_index", 0))
-	var effect_idx: int = Read.as_int(params.get("effect_index", 0))
+	var bus_idx: int = GdhRead.as_int(params.get("bus_index", 0))
+	var effect_idx: int = GdhRead.as_int(params.get("effect_index", 0))
 	var effect_type: String = str(params.get("effect_type", ""))
-	var enabled: bool = Read.as_bool(params.get("enabled", true), true)
+	var enabled: bool = GdhRead.as_bool(params.get("enabled", true), true)
 	if bus_idx < 0 or bus_idx >= AudioServer.bus_count:
 		return _log.failure("No bus at index " + str(bus_idx))
 
@@ -150,8 +150,8 @@ func set_audio_bus_effect(params: Dictionary) -> Dictionary:
 
 
 func set_audio_bus_volume(params: Dictionary) -> Dictionary:
-	var bus_idx: int = Read.as_int(params.get("bus_index", 0))
-	var volume_db: float = Read.as_float(params.get("volume_db", 0.0))
+	var bus_idx: int = GdhRead.as_int(params.get("bus_index", 0))
+	var volume_db: float = GdhRead.as_float(params.get("volume_db", 0.0))
 	if bus_idx < 0 or bus_idx >= AudioServer.bus_count:
 		return _log.failure("No bus at index " + str(bus_idx))
 

package/build/godot/operations/class_cache.gd

@@ -5,18 +5,18 @@ extends RefCounted
 # A game started from a stale editor then cannot resolve any class_name written since, and the
 # engine reads the same file headless, so the list is rebuilt here from the scripts themselves.
 
-const Patterns = preload("patterns.gd")
-const Read = preload("reading.gd")
-const FileWalk = preload("file_walk.gd")
-const Log = preload("logger.gd")
+const GdhPatterns = preload("patterns.gd")
+const GdhRead = preload("reading.gd")
+const GdhFileWalk = preload("file_walk.gd")
+const GdhLog = preload("logger.gd")
 
 const CACHE_PATH: String = "res://.godot/global_script_class_cache.cfg"
 
-var _log: Log
-var _files: FileWalk = FileWalk.new()
+var _log: GdhLog
+var _files: GdhFileWalk = GdhFileWalk.new()
 
 
-func _init(p_log: Log) -> void:
+func _init(p_log: GdhLog) -> void:
 	_log = p_log
 
 
@@ -102,8 +102,8 @@ func _entry_for(path: String, skipped: Array[Dictionary]) -> Dictionary:
 		"base": StringName(str(base)),
 		"class": StringName(declared),
 		"icon": str(header.get("icon", "")),
-		"is_abstract": Read.as_bool(header.get("abstract", false)),
-		"is_tool": Read.as_bool(header.get("tool", false)),
+		"is_abstract": GdhRead.as_bool(header.get("abstract", false)),
+		"is_tool": GdhRead.as_bool(header.get("tool", false)),
 		"language": StringName("GDScript"),
 		"path": path,
 	}
@@ -166,7 +166,7 @@ static func _extends_parts(text: String) -> Dictionary:
 		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 name_at: RegEx = GdhPatterns.compiled("^([A-Za-z_][A-Za-z0-9_]*)")
 	var dotted: bool = not path.is_empty()
 	while true:
 		if dotted:
@@ -195,8 +195,8 @@ static func _as_the_engine_opens(path: String) -> String:
 # 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 class_line: RegEx = GdhPatterns.compiled("^class\\s+([A-Za-z_][A-Za-z0-9_]*)\\s*(.*)$")
+	var inline_extends: RegEx = GdhPatterns.compiled("^extends\\s+(.*)$")
 	var start: int = 0
 	var end: int = lines.size()
 	var depth: int = 0
@@ -255,9 +255,9 @@ func _header_of(path: String) -> Dictionary:
 # which is where the body begins.
 func _header_in(lines: PackedStringArray) -> Dictionary:
 	var header: Dictionary = {}
-	var annotation: RegEx = Patterns.compiled('^@([a-z_]+)(?:\\(\\s*(?:"([^"]*)")?[^)]*\\))?\\s*')
-	var extends_line: RegEx = Patterns.compiled("^extends\\s+(.*)$")
-	var same_line: RegEx = Patterns.compiled("^\\s+extends\\s+(.*)$")
+	var annotation: RegEx = GdhPatterns.compiled('^@([a-z_]+)(?:\\(\\s*(?:"([^"]*)")?[^)]*\\))?\\s*')
+	var extends_line: RegEx = GdhPatterns.compiled("^extends\\s+(.*)$")
+	var same_line: RegEx = GdhPatterns.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`.
@@ -275,7 +275,7 @@ func _header_in(lines: PackedStringArray) -> Dictionary:
 		if rest.is_empty() or rest.begins_with("#"):
 			continue
 		if rest.begins_with("class_name"):
-			var declared: RegExMatch = Patterns.declared_class(rest)
+			var declared: RegExMatch = GdhPatterns.declared_class(rest)
 			if declared != null:
 				header["class_name"] = declared.get_string(1)
 				var after: RegExMatch = same_line.search(rest.substr(declared.get_end(1)))

package/build/godot/operations/classdb_queries.gd

@@ -1,8 +1,8 @@
 extends RefCounted
 
-const Read = preload("reading.gd")
-const Log = preload("logger.gd")
-const Serialisation = preload("serialisation.gd")
+const GdhRead = preload("reading.gd")
+const GdhLog = preload("logger.gd")
+const GdhSerialisation = 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
@@ -33,11 +33,11 @@ const METHOD_FLAG_NAMES: Dictionary[int, String] = {
 	METHOD_FLAG_VIRTUAL_REQUIRED: "virtual_required",
 }
 
-var _log: Log
-var _values: Serialisation = Serialisation.new()
+var _log: GdhLog
+var _values: GdhSerialisation = GdhSerialisation.new()
 
 
-func _init(p_log: Log) -> void:
+func _init(p_log: GdhLog) -> void:
 	_log = p_log
 
 
@@ -53,7 +53,7 @@ static func _under_any(name: String, bases: Array) -> bool:
 func query_classes(params: Dictionary) -> Dictionary:
 	var filter: String = str(params.get("filter", ""))
 	var category: String = str(params.get("category", ""))
-	var instantiable_only: bool = Read.as_bool(params.get("instantiable_only", false))
+	var instantiable_only: bool = GdhRead.as_bool(params.get("instantiable_only", false))
 
 	_log.info(
 		(
@@ -107,7 +107,7 @@ func query_classes(params: Dictionary) -> Dictionary:
 # Query detailed info about a specific class from ClassDB
 func query_class_info(params: Dictionary) -> Dictionary:
 	var class_name_str: String = str(params.get("class_name", ""))
-	var include_inherited: bool = Read.as_bool(params.get("include_inherited", false))
+	var include_inherited: bool = GdhRead.as_bool(params.get("include_inherited", false))
 
 	_log.info(
 		"Querying class info for: " + class_name_str + " (include_inherited: " + str(include_inherited) + ")"
@@ -344,7 +344,7 @@ func _methods_of(class_name_str: String, include_inherited: bool) -> Array[Dicti
 						"class_name": return_info.get("class_name", "")
 					},
 					"flags": m.get("flags", 0),
-					"flag_names": _flag_names(Read.as_int(m.get("flags", 0))),
+					"flag_names": _flag_names(GdhRead.as_int(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", []))
@@ -370,12 +370,12 @@ static func _flag_names(flags: int) -> Array[String]:
 # Nil is a value that can be anything when the usage says so, and [param nil_name] otherwise: void
 # for what a method returns, and Variant for an argument or property with no type.
 static func _type_name(info: Dictionary, nil_name: String) -> String:
-	var type: int = Read.as_int(info.get("type", 0))
+	var type: int = GdhRead.as_int(info.get("type", 0))
 	var named: String = str(info.get("class_name", ""))
 	if type == TYPE_OBJECT and not named.is_empty():
 		return named
 	if type == TYPE_NIL:
-		return "Variant" if Read.as_int(info.get("usage", 0)) & PROPERTY_USAGE_NIL_IS_VARIANT else nil_name
+		return "Variant" if GdhRead.as_int(info.get("usage", 0)) & PROPERTY_USAGE_NIL_IS_VARIANT else nil_name
 	return type_string(type)
 
 
@@ -384,7 +384,7 @@ func _properties_of(class_name_str: String, include_inherited: bool) -> Array[Di
 
 	for p: Dictionary in ClassDB.class_get_property_list(class_name_str, not include_inherited):
 		# A category, group or subgroup is an editor heading rather than a property.
-		var usage: int = Read.as_int(p.get("usage", 0))
+		var usage: int = GdhRead.as_int(p.get("usage", 0))
 		if usage & PROPERTY_USAGE_CATEGORY or usage & PROPERTY_USAGE_GROUP or usage & PROPERTY_USAGE_SUBGROUP:
 			continue
 		properties.append(