gdharness 1.3.0 → 1.3.2

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

@@ -8,7 +8,7 @@ signal connected
 signal disconnected
 signal tool_requested(request_id: String, tool_name: String, args: Dictionary)
 
-const Read = preload("reading.gd")
+const GdhRead = preload("reading.gd")
 
 const DEFAULT_URL: String = "ws://127.0.0.1:6505/godot"
 ## Written beside the addon by the install, so it names the version this copy came from.
@@ -256,15 +256,15 @@ func announced_url() -> String:
 	var file: FileAccess = FileAccess.open(ANNOUNCEMENT, FileAccess.READ)
 	if file == null:
 		return ""
-	var said: Variant = Read.json_or_null(file.get_as_text())
+	var said: Variant = GdhRead.json_or_null(file.get_as_text())
 	file.close()
 	if not said is Dictionary:
 		return ""
 
 	var announcement: Dictionary = said
-	if Read.as_int(announcement.get("protocol", 0)) != ANNOUNCE_PROTOCOL:
+	if GdhRead.as_int(announcement.get("protocol", 0)) != ANNOUNCE_PROTOCOL:
 		return ""
-	var port: int = Read.as_int(announcement.get("port", 0))
+	var port: int = GdhRead.as_int(announcement.get("port", 0))
 	if port < 1 or port > 65535:
 		return ""
 	var host: String = str(announcement.get("host", "127.0.0.1"))
@@ -382,7 +382,7 @@ func _keep_breakpoints_through_sessions() -> void:
 	var settings: EditorSettings = EditorInterface.get_editor_settings()
 	if settings == null or not settings.has_setting(SYNC_BREAKPOINTS_SETTING):
 		return
-	if Read.as_bool(settings.get_setting(SYNC_BREAKPOINTS_SETTING)):
+	if GdhRead.as_bool(settings.get_setting(SYNC_BREAKPOINTS_SETTING)):
 		return
 	settings.set_setting(SYNC_BREAKPOINTS_SETTING, true)
 	# Stored is not the same as noticed. The adapter reads this setting again on the editor-wide
@@ -406,7 +406,7 @@ func _syncs_breakpoints() -> bool:
 	var settings: EditorSettings = EditorInterface.get_editor_settings()
 	if settings == null or not settings.has_setting(SYNC_BREAKPOINTS_SETTING):
 		return false
-	return Read.as_bool(settings.get_setting(SYNC_BREAKPOINTS_SETTING))
+	return GdhRead.as_bool(settings.get_setting(SYNC_BREAKPOINTS_SETTING))
 
 
 ## What the settings say this editor serves on, or 0 when there is nothing to ask.
@@ -416,7 +416,7 @@ func _serving(setting: String) -> int:
 	var settings: EditorSettings = EditorInterface.get_editor_settings()
 	if settings == null or not settings.has_setting(setting):
 		return 0
-	return Read.as_int(settings.get_setting(setting))
+	return GdhRead.as_int(settings.get_setting(setting))
 
 
 ## The version marker beside this addon, or "" when the copy was not installed by gdharness.
@@ -497,7 +497,7 @@ func _on_reconnect_timer() -> void:
 
 
 func _handle_message(json_string: String) -> void:
-	var parsed: Variant = Read.json_or_null(json_string)
+	var parsed: Variant = GdhRead.json_or_null(json_string)
 	if not parsed is Dictionary:
 		push_error("[gdharness] The server sent something that is not a message: %s" % json_string)
 		return

package/build/godot/addons/gdharness_editor/declared_values.gd

@@ -0,0 +1,116 @@
+@tool
+extends RefCounted
+
+## What a property declares beyond its type: the values of its enum and the range it is exported
+## with, for taking a value by name and for saying when a value written lies outside them.
+
+const GdhRead = preload("reading.gd")
+
+
+## The values an enum hint names, by name, from its hint string: "SWORD:0,SHIELD:1" as a script
+## declares one, or "Add,Subtract" as an engine property does, each name then taking the number
+## after the one before it.
+static func enum_values(hint_string: String) -> Dictionary:
+	var values: Dictionary = {}
+	var next: int = 0
+	for entry: String in hint_string.split(",", false):
+		var name: String = entry.get_slice(":", 0).strip_edges()
+		var number: String = entry.get_slice(":", 1).strip_edges() if ":" in entry else ""
+		var value: int = number.to_int() if number.is_valid_int() else next
+		values[name] = value
+		next = value + 1
+	return values
+
+
+## The values of the enum [param declared] declares, by name, spelt as the script of [param target]
+## spells them when it declares that enum. The engine's hint capitalises each name, "SWORD" as
+## "Sword", and a refusal listing those named values the script never spells.
+static func enum_of(target: Object, declared: Dictionary) -> Dictionary:
+	var hinted: Dictionary = enum_values(str(declared.get("hint_string", "")))
+	var attached: Variant = target.get_script()
+	if not attached is Script:
+		return hinted
+	var script: Script = attached
+	for constant: Variant in script.get_script_constant_map().values():
+		if not constant is Dictionary:
+			continue
+		var values: Dictionary = constant
+		if values.size() != hinted.size():
+			continue
+		var spelt: Dictionary = {}
+		for name: Variant in values:
+			if hinted.get(str(name).capitalize()) == values[name]:
+				spelt[str(name)] = values[name]
+		if spelt.size() == hinted.size():
+			return spelt
+	return hinted
+
+
+## The number [param word] names among [param choices], matched as written and then ignoring case,
+## or null when it names none.
+static func enum_named(choices: Dictionary, word: String) -> Variant:
+	var wanted: String = word.strip_edges()
+	if choices.has(wanted):
+		return choices[wanted]
+	for name: String in choices:
+		if name.to_lower() == wanted.to_lower():
+			return choices[name]
+	return null
+
+
+static func enum_refusal(holder: String, property: String, word: String, choices: Dictionary) -> String:
+	var said: String = (
+		"%s.%s is an enum, and %s is none of its values: send %s by name or by number"
+		% [holder, property, word, _listed(choices)]
+	)
+	var close: PackedStringArray = GdhRead.nearest(word, PackedStringArray(choices.keys()))
+	if close.is_empty():
+		return said + "."
+	return said + ". The nearest %s %s." % ["is" if close.size() == 1 else "are", ", ".join(close)]
+
+
+## Why [param value], shown as [param shown], lies outside what [param declared] allows, an export
+## range or an enum's values, or "" when it does not. A range marked or_greater or or_less is open
+## on that side.
+static func outside(target: Object, declared: Dictionary, value: Variant, shown: String) -> String:
+	var hint: int = GdhRead.as_int(declared.get("hint", PROPERTY_HINT_NONE))
+	var hint_string: String = str(declared.get("hint_string", ""))
+	var property: String = str(declared.get("name", ""))
+	if typeof(value) != TYPE_INT and typeof(value) != TYPE_FLOAT:
+		return ""
+	var number: float = GdhRead.as_float(value)
+	if hint == PROPERTY_HINT_ENUM and typeof(value) == TYPE_INT:
+		var choices: Dictionary = enum_of(target, declared)
+		if choices.is_empty() or choices.values().has(value):
+			return ""
+		return "%d is none of the values %s declares: %s." % [value, property, _listed(choices)]
+	if hint != PROPERTY_HINT_RANGE:
+		return ""
+	var parts: PackedStringArray = []
+	for part: String in hint_string.split(","):
+		var _added: bool = parts.append(part.strip_edges())
+	if parts.size() < 2 or not parts[0].is_valid_float() or not parts[1].is_valid_float():
+		return ""
+	var low: float = parts[0].to_float()
+	var high: float = parts[1].to_float()
+	if (number <= high or parts.has("or_greater")) and (number >= low or parts.has("or_less")):
+		return ""
+	return (
+		(
+			"%s is outside the range %s declares, %s to %s, which the inspector holds it to; the "
+			+ "engine stores it as given."
+		)
+		% [shown, property, _bound(low), _bound(high)]
+	)
+
+
+static func _listed(choices: Dictionary) -> String:
+	var listed: PackedStringArray = []
+	for name: String in choices:
+		var _added: bool = listed.append("%s (%d)" % [name, choices[name]])
+	return ", ".join(listed)
+
+
+## A range's end as the script wrote it: the engine's hint gives @export_range(0, 10) as 0.0 and 10.0.
+static func _bound(end: float) -> String:
+	return str(int(end)) if end == floorf(end) and absf(end) < 1e15 else str(end)

package/build/godot/addons/gdharness_editor/declared_values.gd.uid

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

package/build/godot/addons/gdharness_editor/file_reads.gd

@@ -10,9 +10,9 @@ extends RefCounted
 ## without making a node. Loading the file still does what loading does in the game: static
 ## initialisers run, and a resource with a script is made with it.
 
-const PropertyValues = preload("property_values.gd")
-const Read = preload("reading.gd")
-const Serialisation = preload("serialisation.gd")
+const GdhPropertyValues = preload("property_values.gd")
+const GdhRead = preload("reading.gd")
+const GdhSerialisation = preload("serialisation.gd")
 
 
 ## The nodes of [param scene_path] as {name, type, path, children}, with instanceOf and
@@ -42,13 +42,43 @@ static func scene_node(scene_path: String, node_path: String) -> Dictionary:
 	return {"ok": true, "name": found["name"], "type": found["type"], "properties": found["properties"]}
 
 
-## [param said], the refusal for [param node_path], which [param scene_path] does not have, with
-## where the path leaves the scene as [method Read.missing_below] says it.
-static func missing_from(said: String, scene_path: String, node_path: String) -> String:
+## The node at [param node_path] in [param scene_path] as [method scene_node] answers it, when it is
+## a [param kind]; otherwise a refusal saying what the scene has there and where its nodes of that
+## kind are, so the caller has the path to pass. The file is read once, because every load prints
+## the engine's warnings about it again.
+static func scene_node_of_kind(scene_path: String, node_path: String, kind: String) -> Dictionary:
 	var laid: Dictionary = _laid(scene_path)
 	if not laid.get("ok", false):
-		return said
+		return laid
 	var nodes: Dictionary = laid["nodes"]
+	var path: String = _joined(".", node_path)
+	var said: String = "%s not found at: %s" % [kind, node_path]
+	var found: String = ""
+	if nodes.has(path):
+		found = str(nodes[path]["type"])
+		if ClassDB.class_exists(found) and ClassDB.is_parent_class(found, kind):
+			return {
+				"ok": true,
+				"name": nodes[path]["name"],
+				"type": found,
+				"properties": nodes[path]["properties"]
+			}
+	else:
+		var hinted: String = said
+		if not nodes.has(_joined(".", node_path.get_slice("/", 0))):
+			hinted = GdhRead.from_the_root(said, node_path, str(nodes["."]["name"]))
+		said = hinted if hinted != said else _missing_in(nodes, said, node_path)
+	var held: PackedStringArray = []
+	for at: Variant in nodes:
+		var type: String = str(nodes[at]["type"])
+		if ClassDB.class_exists(type) and ClassDB.is_parent_class(type, kind):
+			var _held: bool = held.append(str(at))
+	return {"ok": false, "error": GdhRead.not_of_kind(said, node_path, found, kind, held)}
+
+
+## [param said], the refusal for [param node_path], which the scene laid as [param nodes] does not
+## have, with where the path leaves the scene as [method GdhRead.missing_below] says it.
+static func _missing_in(nodes: Dictionary, said: String, node_path: String) -> String:
 	var parts: PackedStringArray = node_path.trim_prefix("./").split("/", false)
 	var at: String = "."
 	var reached: PackedStringArray = []
@@ -64,7 +94,7 @@ static func missing_from(said: String, scene_path: String, node_path: String) ->
 	var children: Array[String] = nodes[at]["children"]
 	for child: String in children:
 		var _named: bool = names.append(str(nodes[child]["name"]))
-	return Read.missing_below(said, str(nodes["."]["name"]), reached, parts[reached.size()], names)
+	return GdhRead.missing_below(said, str(nodes["."]["name"]), reached, parts[reached.size()], names)
 
 
 ## Every node of [param scene_path] as {ok, nodes}, keyed by path, or a refusal.
@@ -77,15 +107,14 @@ static func _laid(scene_path: String) -> Dictionary:
 	if loaded == null:
 		return {"ok": false, "error": "Failed to load %s as a scene" % scene_path}
 	if not loaded is PackedScene:
-		var kind: String = loaded.get_class()
-		var sort: String = ("an " if kind.left(1).to_upper() in ["A", "E", "I", "O", "U"] else "a ") + kind
+		var sort: String = GdhRead.with_article(loaded.get_class())
 		return {
 			"ok": false,
 			"error": "%s is %s, not a scene: resource_edit read reads its properties." % [scene_path, sort]
 		}
 	var packed: PackedScene = loaded
 	var nodes: Dictionary = {}
-	var refused: String = _lay(packed.get_state(), ".", nodes, [scene_path])
+	var refused: String = _lay(packed.get_state(), ".", nodes, [scene_path], packed)
 	if not refused.is_empty():
 		return {"ok": false, "error": refused}
 	if not nodes.has("."):
@@ -99,8 +128,11 @@ static func _laid(scene_path: String) -> Dictionary:
 ##
 ## [param within] is the files being laid, outermost first, so a scene that instances one of them
 ## is refused rather than laid forever; the engine refuses to load such a scene, so this is only
-## reached through a state built some other way.
-static func _lay(state: SceneState, prefix: String, nodes: Dictionary, within: Array) -> String:
+## reached through a state built some other way. [param loaded] is the scene [param state] is read
+## from, when the caller has it loaded already.
+static func _lay(
+	state: SceneState, prefix: String, nodes: Dictionary, within: Array, loaded: PackedScene = null
+) -> String:
 	var base: SceneState = state.get_base_scene_state()
 	if base != null and not nodes.has(prefix):
 		var refused: String = _lay(base, prefix, nodes, within)
@@ -164,7 +196,7 @@ static func _lay(state: SceneState, prefix: String, nodes: Dictionary, within: A
 	# Only the scene being read and the scenes it inherits share its root, the owner whose editable
 	# instances a write here sets; a file instanced below makes its own owner's editable.
 	if prefix == ".":
-		for editable: String in _editable_in(state.get_path()):
+		for editable: String in _editable_in(state.get_path(), loaded):
 			var at: String = _joined(prefix, editable)
 			var marked: Dictionary = nodes.get(at, {})
 			if marked.has("editableChildren"):
@@ -173,10 +205,13 @@ static func _lay(state: SceneState, prefix: String, nodes: Dictionary, within: A
 
 
 ## The paths of the instances [param scene_path] gives editable children, from its root. SceneState
-## does not give them to a script, so they are read off the scene's bundle.
-static func _editable_in(scene_path: String) -> PackedStringArray:
+## does not give them to a script, so they are read off the scene's bundle: [param given_scene]'s,
+## when the caller has the file loaded, since loading it again prints its warnings again.
+static func _editable_in(scene_path: String, given_scene: PackedScene = null) -> PackedStringArray:
 	var found: PackedStringArray = []
-	var loaded: Resource = ResourceLoader.load(scene_path, "", ResourceLoader.CACHE_MODE_IGNORE)
+	var loaded: Resource = given_scene
+	if loaded == null:
+		loaded = ResourceLoader.load(scene_path, "", ResourceLoader.CACHE_MODE_IGNORE)
 	if not loaded is PackedScene:
 		return found
 	var given: Variant = loaded.get("_bundled")
@@ -236,7 +271,7 @@ static func _by_id(nodes: Dictionary, owner: String, id: int) -> String:
 		if path == owner or not (owner == "." or path.begins_with(owner + "/")):
 			continue
 		var entry: Dictionary = nodes[path]
-		if Read.as_int(entry.get("uniqueId", -1), -1) != id:
+		if GdhRead.as_int(entry.get("uniqueId", -1), -1) != id:
 			continue
 		var above: String = "." if not path.contains("/") else path.get_base_dir()
 		if _owner_of(nodes, above, owner) == owner:
@@ -311,7 +346,7 @@ static func _stored(type: String, given: Dictionary) -> Dictionary:
 	if script != null:
 		for declared: Dictionary in script.get_script_property_list():
 			var property: String = str(declared.get("name", ""))
-			if not property.is_empty() and Read.as_int(declared.get("usage", 0)) & PROPERTY_USAGE_STORAGE:
+			if not property.is_empty() and GdhRead.as_int(declared.get("usage", 0)) & PROPERTY_USAGE_STORAGE:
 				scripted[property] = script.get_property_default_value(property)
 	var values: Dictionary = {}
 	if ClassDB.class_exists(type) and ClassDB.can_instantiate(type):
@@ -321,7 +356,7 @@ static func _stored(type: String, given: Dictionary) -> Dictionary:
 				bare.set(str(property), given[property])
 		for declared: Dictionary in bare.get_property_list():
 			var property: String = str(declared.get("name", ""))
-			if not property.is_empty() and Read.as_int(declared.get("usage", 0)) & PROPERTY_USAGE_STORAGE:
+			if not property.is_empty() and GdhRead.as_int(declared.get("usage", 0)) & PROPERTY_USAGE_STORAGE:
 				values[property] = bare.get(property)
 		if bare is Node:
 			bare.free()
@@ -330,7 +365,7 @@ static func _stored(type: String, given: Dictionary) -> Dictionary:
 	# Given last, which keeps what a bare node cannot hold: the script itself, and a path to a node
 	# for a property that holds the node once it is in a tree.
 	values.merge(given, true)
-	var serialiser: Serialisation = Serialisation.new()
+	var serialiser: GdhSerialisation = GdhSerialisation.new()
 	var answered: Dictionary = {}
 	for property: Variant in values:
 		answered[property] = serialiser.serialize_value(values[property])
@@ -369,13 +404,13 @@ static func resource(res_path: String, include_defaults: bool) -> Dictionary:
 	if script != null:
 		for declared: Dictionary in script.get_script_property_list():
 			scripted[str(declared.get("name", ""))] = true
-	var serialiser: Serialisation = Serialisation.new()
+	var serialiser: GdhSerialisation = GdhSerialisation.new()
 	var properties: Dictionary = {}
 	for p: Dictionary in loaded.get_property_list():
 		var property: String = str(p.get("name", ""))
 		if property.is_empty() or property == "script":
 			continue
-		if not (Read.as_int(p.get("usage", 0)) & PROPERTY_USAGE_STORAGE):
+		if not (GdhRead.as_int(p.get("usage", 0)) & PROPERTY_USAGE_STORAGE):
 			continue
 		var value: Variant = loaded.get(property)
 		if not include_defaults:
@@ -384,7 +419,7 @@ static func resource(res_path: String, include_defaults: bool) -> Dictionary:
 				if scripted.has(property)
 				else ClassDB.class_get_property_default_value(loaded.get_class(), property)
 			)
-			if PropertyValues.same(value, default):
+			if GdhPropertyValues.same(value, default):
 				continue
 		properties[property] = serialiser.serialize_value(value)
 	var answer: Dictionary = {
@@ -392,6 +427,11 @@ static func resource(res_path: String, include_defaults: bool) -> Dictionary:
 	}
 	if script != null:
 		answer["script"] = script.resource_path
+		# resourceType is the engine class under the script, which for a class the project declares
+		# is Resource whatever create was given.
+		var declared_class: String = str(script.get_global_name())
+		if not declared_class.is_empty():
+			answer["scriptClass"] = declared_class
 	return answer
 
 
@@ -412,7 +452,7 @@ static func _kept_in(value: Variant, file: String, id: String, seen: Dictionary)
 		if held.resource_scene_unique_id == id:
 			return held
 		for p: Dictionary in held.get_property_list():
-			if Read.as_int(p.get("usage", 0)) & PROPERTY_USAGE_STORAGE:
+			if GdhRead.as_int(p.get("usage", 0)) & PROPERTY_USAGE_STORAGE:
 				var found: Resource = _kept_in(held.get(str(p.get("name", ""))), file, id, seen)
 				if found != null:
 					return found

package/build/godot/addons/gdharness_editor/headless_check.gd

@@ -11,8 +11,8 @@ extends RefCounted
 ## both, so a property a built-in setter derives (a Control's offsets from its size) is left alone
 ## unless a script that is not a tool is involved.
 
-const PropertyValues = preload("property_values.gd")
-const Read = preload("reading.gd")
+const GdhPropertyValues = preload("property_values.gd")
+const GdhRead = preload("reading.gd")
 
 const REMEDY: String = (
 	"Open the project's editor (editor_launch with hidden: true) and ask again: the write then goes "
@@ -25,7 +25,7 @@ const REMEDY: String = (
 static func stored(object: Object) -> Dictionary:
 	var values: Dictionary = {}
 	for declared: Dictionary in object.get_property_list():
-		if not (Read.as_int(declared.get("usage", 0)) & PROPERTY_USAGE_STORAGE):
+		if not (GdhRead.as_int(declared.get("usage", 0)) & PROPERTY_USAGE_STORAGE):
 			continue
 		var name: String = str(declared.get("name", ""))
 		if name.is_empty():
@@ -78,7 +78,7 @@ static func differing(object: Object, before: Dictionary, names: Dictionary) ->
 		if names.has(name):
 			continue
 		var was: Variant = before[name] if before.has(name) else default_of(object, name)
-		if not PropertyValues.same(now[name], was):
+		if not GdhPropertyValues.same(now[name], was):
 			changed.append(name)
 	return changed
 
@@ -93,7 +93,7 @@ static func default_of(object: Object, name: String) -> Variant:
 				var given: Variant = script.get_property_default_value(name)
 				if given != null:
 					return given
-				return _initialised(script, name, Read.as_int(declared.get("type", TYPE_NIL)))
+				return _initialised(script, name, GdhRead.as_int(declared.get("type", TYPE_NIL)))
 	return ClassDB.class_get_property_default_value(object.get_class(), name)
 
 
@@ -122,7 +122,7 @@ static func _initialised(script: Script, name: String, type: int) -> Variant:
 ## nothing a script did: the saver writes a property whose default the engine cannot report whatever
 ## it holds, the editor's save as well.
 static func at_default(object: Object, name: String) -> bool:
-	return PropertyValues.same(object.get(name), default_of(object, name))
+	return GdhPropertyValues.same(object.get(name), default_of(object, name))
 
 
 ## The ids, in the file, of the embedded resources [param property] reaches into on [param object],
@@ -276,7 +276,7 @@ static func reads_the_same(was: Variant, now: Variant, default: Variant) -> bool
 			return false
 		else:
 			values.append(str_to_var(str(text)))
-	return PropertyValues.same(values[0], values[1])
+	return GdhPropertyValues.same(values[0], values[1])
 
 
 static func _main_entries(text: String) -> Dictionary:

package/build/godot/addons/gdharness_editor/plugin.gd

@@ -5,8 +5,8 @@ extends EditorPlugin
 ## that does what the server asks, with a label in the toolbar saying whether the two are
 ## connected.
 
-const BridgeClient = preload("bridge_client.gd")
-const ToolExecutor = preload("tool_executor.gd")
+const GdhBridgeClient = preload("bridge_client.gd")
+const GdhToolExecutor = preload("tool_executor.gd")
 
 ## The tools answered while the editor scans or imports, because none of them saves a file: the
 ## ones a caller waits on a scan with, and the ones that only read or stop a played game.
@@ -19,17 +19,17 @@ const ANSWERED_WHILE_SCANNING: Array[String] = [
 	"profile_read",
 ]
 
-var _client: BridgeClient
-var _tool_executor: ToolExecutor
+var _client: GdhBridgeClient
+var _tool_executor: GdhToolExecutor
 var _status_label: Label
 
 
 func _enter_tree() -> void:
-	_client = BridgeClient.new()
+	_client = GdhBridgeClient.new()
 	_client.name = "GdharnessBridgeClient"
 	add_child(_client)
 
-	_tool_executor = ToolExecutor.new()
+	_tool_executor = GdhToolExecutor.new()
 	_tool_executor.name = "GdharnessToolExecutor"
 	add_child(_tool_executor)
 	_tool_executor.set_editor_plugin(self)