gdharness 1.3.9 → 1.3.10

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

@@ -31,22 +31,15 @@ const GdhHeadlessCheck = preload("headless_check.gd")
 const PUTTING_BACK_PASSES: int = 4
 const GdhRead = preload("reading.gd")
 const GdhSame = preload("same_values.gd")
-## The names Object.ConnectFlags gives each bit. The number alone left a reader guessing that 2 is
-## the persistence every connection in a saved scene carries.
-const CONNECT_FLAG_NAMES: Dictionary[int, String] = {
-	Object.CONNECT_DEFERRED: "deferred",
-	Object.CONNECT_PERSIST: "persist",
-	Object.CONNECT_ONE_SHOT: "one_shot",
-	Object.CONNECT_REFERENCE_COUNTED: "reference_counted",
-	Object.CONNECT_APPEND_SOURCE_OBJECT: "append_source_object",
-}
+const GdhSerialisation = preload("serialisation.gd")
+const GdhSceneUids = preload("scene_uids.gd")
 
 ## Whether a scan asked for through [method scan_later] is still to start, which a caller waiting
 ## for the editor's files to settle has to wait through as well.
 static var scan_due: bool = false
-## The files a headless save named by path alone because the uid cache holds no uid for them,
-## gathered for the answer to the call that saved, the one call its engine runs.
-static var by_path: PackedStringArray = []
+## What the saves of a call wrote on nodes it did not ask to change, differently from their file,
+## gathered for that call's answer as [method _also_saved] finds them.
+static var also_saved: Array[Dictionary] = []
 
 var root: Node = null
 var path: String = ""
@@ -69,6 +62,10 @@ var _copied_from: Dictionary = {}
 var _reached: Dictionary = {}
 ## The file as it was opened, to compare its embedded resources with what the write saves.
 var _text: String = ""
+## The engine properties a put back did not take on a node, as "id:name": the engine derives them
+## from where the node is, as it keeps layout_mode at Container under a container, and stores the
+## same from an editor.
+var _engine_kept: Dictionary = {}
 
 
 ## Opens [param scene_path], answering a refusal, or {} with [member root] set.
@@ -95,13 +92,14 @@ func open(scene_path: String, for_writing: bool) -> Dictionary:
 	_state = packed.get_state()
 	_base_paths = makers(_state)
 	# On a read as well, which would otherwise answer what the scripts set as what the file holds.
-	if not Engine.is_editor_hint():
-		if for_writing:
-			_text = FileAccess.get_file_as_string(path)
+	if for_writing or not Engine.is_editor_hint():
 		for index: int in _state.get_node_count():
 			var node: Node = _node_at(str(_state.get_node_path(index)))
 			if node != null:
 				_filed[node.get_instance_id()] = _stored_at(_state, index)
+	if not Engine.is_editor_hint():
+		if for_writing:
+			_text = FileAccess.get_file_as_string(path)
 		var unsettled: String = settle()
 		if not unsettled.is_empty():
 			return refuse(("Nothing was written: " if for_writing else "Not read: ") + unsettled)
@@ -170,19 +168,6 @@ func refuse(error: String) -> Dictionary:
 	return {"ok": false, "error": error}
 
 
-## Each bit set in [param flags], a connection's, by name, and any bits left unnamed as one number.
-static func flag_names(flags: int) -> Array[String]:
-	var names: Array[String] = []
-	var rest: int = flags
-	for bit: int in CONNECT_FLAG_NAMES:
-		if flags & bit:
-			names.append(CONNECT_FLAG_NAMES[bit])
-			rest &= ~bit
-	if rest != 0:
-		names.append(str(rest))
-	return names
-
-
 ## [param said], the refusal for [param node_path] found nowhere in this scene, with how a path is
 ## read when it starts with the root's own name, and otherwise with the last node of the path the
 ## scene has and what is under it, as after a node was moved or renamed.
@@ -518,7 +503,7 @@ func unusable_name(parent: Node, child_name: String, moving: Node = null) -> Str
 	return ""
 
 
-## The names of the properties this scene's own file sets on [param node], whatever their values.
+## The properties this scene's own file sets on [param node], each with the value the file gives it.
 func set_here(node: Node) -> Dictionary:
 	return set_at(path_of(node))
 
@@ -545,17 +530,17 @@ func groups_at(at: String) -> PackedStringArray:
 	return named
 
 
-## The names of the properties this scene's own file sets on the node at [param at].
+## The properties this scene's own file sets on the node at [param at], with the values it gives.
 func set_at(at: String) -> Dictionary:
-	var names: Dictionary = {}
+	var held: Dictionary = {}
 	if _state == null:
-		return names
+		return held
 	for index: int in _state.get_node_count():
 		if _relative(str(_state.get_node_path(index))) != at:
 			continue
-		for property: int in _state.get_node_property_count(index):
-			names[str(_state.get_node_property_name(index, property))] = true
-	return names
+		for p: int in _state.get_node_property_count(index):
+			held[str(_state.get_node_property_name(index, p))] = _state.get_node_property_value(index, p)
+	return held
 
 
 ## Whether [param loaded], read off [param saved] (a copy instantiated from the pack), is
@@ -611,28 +596,73 @@ func write(check: Callable = Callable()) -> Dictionary:
 		saved.free()
 		if not missing.is_empty():
 			return refuse("Nothing was written: " + missing)
+	var also: Array[Dictionary] = _also_saved(packed.get_state())
 	close()
 	var previous: Variant = null
 	if FileAccess.file_exists(path):
 		previous = FileAccess.get_file_as_bytes(path)
 	written_pack = packed
-	var written: Dictionary = save_packed(packed, path)
-	if not written.is_empty() or not headless or not path.ends_with(".tscn"):
-		return written
 	var state: SceneState = packed.get_state()
 	var values: Array = []
 	for index: int in state.get_node_count():
 		values.append_array(_stored_at(state, index).values())
+	var carried: Dictionary = GdhHeadlessCheck.embedded_in(values, {})
+	var written: Dictionary = save_packed(packed, path)
+	if not written.is_empty() or not headless or not path.ends_with(".tscn"):
+		if written.is_empty():
+			also_saved.append_array(also)
+		return written
 	var unkept: String = GdhHeadlessCheck.settle_saved(
-		path, _text, values, null, {}, _reached, func() -> Error: return save_keeping_uid(packed, path)
+		path,
+		_text,
+		values,
+		null,
+		{},
+		_reached,
+		carried,
+		func() -> Error: return GdhSceneUids.save_keeping_uid(packed, path)
 	)
 	if unkept.is_empty():
+		also_saved.append_array(also)
 		return {}
 	return {
 		"ok": false, "error": "Nothing was written: " + unkept + GdhHeadlessCheck.put_back(path, previous)
 	}
 
 
+## Each property [param state] stores differently from the file, on a node the file held and the call
+## did not ask to change, as {node, property, was, saved}: was left out where the file did not set it,
+## saved where the write does not. The engine writes a node as it holds it once the file has loaded,
+## and one property can set others as it loads, as anchors_preset gives a centred Control both grow
+## directions, so a file not written by the editor gains lines on nodes nobody named.
+func _also_saved(state: SceneState) -> Array[Dictionary]:
+	var noted: Array[Dictionary] = []
+	var values: GdhSerialisation = GdhSerialisation.new()
+	for index: int in state.get_node_count():
+		var node: Node = _node_at(str(state.get_node_path(index)))
+		if node == null:
+			continue
+		var id: int = node.get_instance_id()
+		if _asked.has(id) or not _filed.has(id):
+			continue
+		var filed: Dictionary = _filed[id]
+		var stored: Dictionary = _stored_at(state, index)
+		var names: Dictionary = filed.duplicate()
+		names.merge(stored)
+		for key: Variant in names:
+			var name: String = str(key)
+			var held: bool = filed.has(name)
+			if held == stored.has(name) and (not held or GdhSame.same(stored[name], filed[name])):
+				continue
+			var entry: Dictionary = {"node": path_of(node), "property": name}
+			if held:
+				entry["was"] = values.serialize_value(filed[name])
+			if stored.has(name):
+				entry["saved"] = values.serialize_value(stored[name])
+			noted.append(entry)
+	return noted
+
+
 func _holds_scripted_embedded() -> bool:
 	var seen: Dictionary = {}
 	var nodes: Array[Node] = [root]
@@ -652,112 +682,13 @@ static func save_packed(packed: PackedScene, scene_path: String) -> Dictionary:
 		var made: Error = DirAccess.make_dir_recursive_absolute(directory)
 		if made != OK:
 			return {"ok": false, "error": "Could not create %s: %s" % [directory, error_string(made)]}
-	var saving: Error = save_keeping_uid(packed, scene_path)
+	var saving: Error = GdhSceneUids.save_keeping_uid(packed, scene_path)
 	if saving != OK:
 		return {"ok": false, "error": "Failed to save %s: %s" % [scene_path, error_string(saving)]}
 	refresh(scene_path)
 	return {}
 
 
-## Saves [param resource] at [param file_path], keeping the uid the file already has.
-##
-## The editor saves through its uid cache, which knows every file's. A headless engine that has not
-## imported the project has none, and a resave dropped the uid from the header, so every reference
-## made through it stopped resolving. Read from the file itself, since the loader does not answer it
-## for a text scene there, and a new file is given one as the editor gives it.
-static func save_keeping_uid(resource: Resource, file_path: String) -> Error:
-	if Engine.is_editor_hint():
-		return ResourceSaver.save(resource, file_path)
-	var uid: int = uid_in(file_path)
-	var saving: Error = ResourceSaver.save(resource, file_path)
-	if saving != OK:
-		return saving
-	if uid == ResourceUID.INVALID_ID:
-		uid = ResourceUID.create_id()
-	var marked: Error = ResourceSaver.set_uid(file_path, uid)
-	if marked != OK:
-		return marked
-	return _with_external_uids(file_path)
-
-
-## Puts back the uid on each external resource the text file at [param file_path] names. Only the
-## editor's file system tells the saver a path's uid, so a headless save writes every reference by
-## path alone, and each breaks when the file it names is moved.
-static func _with_external_uids(file_path: String) -> Error:
-	if not (file_path.ends_with(".tscn") or file_path.ends_with(".tres")):
-		return OK
-	var lines: PackedStringArray = FileAccess.get_file_as_string(file_path).split("\n")
-	var pattern: RegEx = RegEx.create_from_string(' path="([^"]+)"')
-	var changed: bool = false
-	for at: int in lines.size():
-		var line: String = lines[at]
-		if not line.begins_with("[ext_resource ") or line.contains(' uid="'):
-			continue
-		var named: RegExMatch = pattern.search(line)
-		if named == null:
-			continue
-		var uid: String = reference_uid(named.get_string(1))
-		if not uid.is_empty():
-			lines[at] = line.replace(' path="', uid + ' path="')
-			changed = true
-	if not changed:
-		return OK
-	var file: FileAccess = FileAccess.open(file_path, FileAccess.WRITE)
-	if file == null:
-		return FileAccess.get_open_error()
-	if not file.store_string("\n".join(lines)):
-		return ERR_FILE_CANT_WRITE
-	file.close()
-	return OK
-
-
-## [method uid_attribute] for a reference about to be written, noting [param named] under
-## [member by_path] when it is left to be named by path.
-static func reference_uid(named: String) -> String:
-	var uid: String = uid_attribute(named)
-	if uid.is_empty():
-		note_by_path(named)
-	return uid
-
-
-## Notes [param named], a reference just written by path alone, under [member by_path] when the uid
-## cache holds nothing for it: a file made since the project was last scanned, whose uid the cache
-## learns from the next scan. Not a file whose uid the cache gives to another, which a scan leaves.
-static func note_by_path(named: String) -> void:
-	if Engine.is_editor_hint() or not FileAccess.file_exists(named) or by_path.has(named):
-		return
-	var own: int = uid_in(named)
-	if own == ResourceUID.INVALID_ID and FileAccess.file_exists(named + ".uid"):
-		own = ResourceUID.text_to_id(FileAccess.get_file_as_string(named + ".uid").strip_edges())
-	if own == ResourceUID.INVALID_ID or not ResourceUID.has_id(own):
-		var _noted: bool = by_path.append(named)
-
-
-## The uid attribute a reference to [param named] is written with, as ' uid="uid://..."', or "".
-##
-## Only a uid the uid cache gives that path, which is what the loader resolves it by. A uid the cache
-## does not know (a file made with no editor since the last scan) is answered with a warning on every
-## load, and one it gives another file (a scene copied whole keeps its original's) loads that file.
-static func uid_attribute(named: String) -> String:
-	var id: int = ResourceLoader.get_resource_uid(named)
-	if id == ResourceUID.INVALID_ID or not ResourceUID.has_id(id) or ResourceUID.get_id_path(id) != named:
-		return ""
-	return ' uid="%s"' % ResourceUID.id_to_text(id)
-
-
-## The uid the file at [param file_path] declares, or [constant ResourceUID.INVALID_ID].
-static func uid_in(file_path: String) -> int:
-	if not FileAccess.file_exists(file_path):
-		return ResourceUID.INVALID_ID
-	var file: FileAccess = FileAccess.open(file_path, FileAccess.READ)
-	if file != null:
-		var header: RegExMatch = RegEx.create_from_string('uid="(uid://[a-z0-9]+)"').search(file.get_line())
-		file.close()
-		if header != null:
-			return ResourceUID.text_to_id(header.get_string(1))
-	return ResourceLoader.get_resource_uid(file_path)
-
-
 ## Brings the editor up to date with a scene file written under it: the cached copy anything holds,
 ## the editor's file list, and the tab showing it, whether current or not.
 static func refresh(scene_path: String) -> void:
@@ -832,7 +763,11 @@ func _settled(packed: PackedScene) -> Array:
 		for found: Array in stray:
 			var node: Node = found[0]
 			var name: String = found[1]
-			node.set(name, found[3] if found[2] else _unset_value(node, name))
+			var wanted: Variant = found[3] if found[2] else _unset_value(node, name)
+			var held: Variant = node.get(name)
+			node.set(name, wanted)
+			if GdhHeadlessCheck.kept_by_engine(node, name, wanted, held):
+				_engine_kept["%d:%s" % [node.get_instance_id(), name]] = true
 		for found: Array in moved:
 			var node: Node = found[0]
 			var before: Dictionary = _before[node.get_instance_id()]
@@ -902,6 +837,8 @@ func _strays(state: SceneState) -> Array[Array]:
 				continue
 			if not held and GdhHeadlessCheck.at_default(node, name):
 				continue
+			if _engine_kept.has("%d:%s" % [id, name]):
+				continue
 			stray.append([node, name, held, filed.get(name)])
 	return stray
 

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

@@ -0,0 +1,107 @@
+@tool
+extends RefCounted
+
+## How a scene or resource a tool saves keeps naming files by uid, as the editor's saves do.
+
+## The files a headless save named by path alone because the uid cache holds no uid for them,
+## gathered for the answer to the call that saved, the one call its engine runs.
+static var by_path: PackedStringArray = []
+
+
+## Saves [param resource] at [param file_path], keeping the uid the file already has.
+##
+## The editor saves through its uid cache, which knows every file's. A headless engine that has not
+## imported the project has none, and a resave dropped the uid from the header, so every reference
+## made through it stopped resolving. Read from the file itself, since the loader does not answer it
+## for a text scene there, and a new file is given one as the editor gives it.
+static func save_keeping_uid(resource: Resource, file_path: String) -> Error:
+	if Engine.is_editor_hint():
+		return ResourceSaver.save(resource, file_path)
+	var uid: int = uid_in(file_path)
+	var saving: Error = ResourceSaver.save(resource, file_path)
+	if saving != OK:
+		return saving
+	if uid == ResourceUID.INVALID_ID:
+		uid = ResourceUID.create_id()
+	var marked: Error = ResourceSaver.set_uid(file_path, uid)
+	if marked != OK:
+		return marked
+	return _with_external_uids(file_path)
+
+
+## Puts back the uid on each external resource the text file at [param file_path] names. Only the
+## editor's file system tells the saver a path's uid, so a headless save writes every reference by
+## path alone, and each breaks when the file it names is moved.
+static func _with_external_uids(file_path: String) -> Error:
+	if not (file_path.ends_with(".tscn") or file_path.ends_with(".tres")):
+		return OK
+	var lines: PackedStringArray = FileAccess.get_file_as_string(file_path).split("\n")
+	var pattern: RegEx = RegEx.create_from_string(' path="([^"]+)"')
+	var changed: bool = false
+	for at: int in lines.size():
+		var line: String = lines[at]
+		if not line.begins_with("[ext_resource ") or line.contains(' uid="'):
+			continue
+		var named: RegExMatch = pattern.search(line)
+		if named == null:
+			continue
+		var uid: String = reference_uid(named.get_string(1))
+		if not uid.is_empty():
+			lines[at] = line.replace(' path="', uid + ' path="')
+			changed = true
+	if not changed:
+		return OK
+	var file: FileAccess = FileAccess.open(file_path, FileAccess.WRITE)
+	if file == null:
+		return FileAccess.get_open_error()
+	if not file.store_string("\n".join(lines)):
+		return ERR_FILE_CANT_WRITE
+	file.close()
+	return OK
+
+
+## [method uid_attribute] for a reference about to be written, noting [param named] under
+## [member by_path] when it is left to be named by path.
+static func reference_uid(named: String) -> String:
+	var uid: String = uid_attribute(named)
+	if uid.is_empty():
+		note_by_path(named)
+	return uid
+
+
+## Notes [param named], a reference just written by path alone, under [member by_path] when the uid
+## cache holds nothing for it: a file made since the project was last scanned, whose uid the cache
+## learns from the next scan. Not a file whose uid the cache gives to another, which a scan leaves.
+static func note_by_path(named: String) -> void:
+	if Engine.is_editor_hint() or not FileAccess.file_exists(named) or by_path.has(named):
+		return
+	var own: int = uid_in(named)
+	if own == ResourceUID.INVALID_ID and FileAccess.file_exists(named + ".uid"):
+		own = ResourceUID.text_to_id(FileAccess.get_file_as_string(named + ".uid").strip_edges())
+	if own == ResourceUID.INVALID_ID or not ResourceUID.has_id(own):
+		var _noted: bool = by_path.append(named)
+
+
+## The uid attribute a reference to [param named] is written with, as ' uid="uid://..."', or "".
+##
+## Only a uid the uid cache gives that path, which is what the loader resolves it by. A uid the cache
+## does not know (a file made with no editor since the last scan) is answered with a warning on every
+## load, and one it gives another file (a scene copied whole keeps its original's) loads that file.
+static func uid_attribute(named: String) -> String:
+	var id: int = ResourceLoader.get_resource_uid(named)
+	if id == ResourceUID.INVALID_ID or not ResourceUID.has_id(id) or ResourceUID.get_id_path(id) != named:
+		return ""
+	return ' uid="%s"' % ResourceUID.id_to_text(id)
+
+
+## The uid the file at [param file_path] declares, or [constant ResourceUID.INVALID_ID].
+static func uid_in(file_path: String) -> int:
+	if not FileAccess.file_exists(file_path):
+		return ResourceUID.INVALID_ID
+	var file: FileAccess = FileAccess.open(file_path, FileAccess.READ)
+	if file != null:
+		var header: RegExMatch = RegEx.create_from_string('uid="(uid://[a-z0-9]+)"').search(file.get_line())
+		file.close()
+		if header != null:
+			return ResourceUID.text_to_id(header.get_string(1))
+	return ResourceLoader.get_resource_uid(file_path)

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

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

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

@@ -223,8 +223,7 @@ 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 spare: Array = GdhShapes.spare(fields, tag)
-	if builder.is_empty() or not spare.any(func(left: Array) -> bool: return left.is_empty()):
+	if builder.is_empty() or not GdhShapes.buildable(fields, tag):
 		return fields
 	if tag == "float" and str(fields["value"]) not in ["inf", "-inf", "nan"]:
 		return fields
@@ -277,24 +276,7 @@ static func components_of(value: Variant) -> PackedStringArray:
 		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"
-				]
-			)
+			return "r g b a r8 g8 b8 a8 h s v ok_hsl_h ok_hsl_s ok_hsl_l".split(" ")
 		TYPE_RECT2, TYPE_RECT2I, TYPE_AABB:
 			return PackedStringArray(["position", "size", "end"])
 		TYPE_PLANE:
@@ -405,7 +387,8 @@ func fitted(value: Variant, type: int) -> Variant:
 				return built
 
 	if rebuilt is Array and LIST_TYPES.has(type):
-		return type_convert(rebuilt, type)
+		var items: Array = value if value is Array else rebuilt
+		return GdhShapes.packed_from(items, type, fitted)
 
 	# 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.
@@ -705,7 +688,13 @@ func _describe_built_in(resource: Resource) -> Dictionary:
 	var script: Script = null
 	if attached is Script:
 		script = attached
-		described["script"] = serialize_value(script)
+		# By the class its script declares, which a write takes as the _type and which says what it
+		# is: as Resource with the script beside it, one answer named a Shop's built-in item that way
+		# and the file item beside it as an Item.
+		if script.get_global_name().is_empty():
+			described["script"] = serialize_value(script)
+		else:
+			described["_type"] = str(script.get_global_name())
 	var fresh: Object = _fresh(script)
 	for property: Dictionary in resource.get_property_list():
 		var usage: int = property.get("usage", 0)

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

@@ -0,0 +1,121 @@
+extends RefCounted
+
+## Project settings read the same way headless and from the open editor, because the two are one
+## question asked of two places: a field one of them left out read as the editor and the file
+## disagreeing about something they agree about.
+
+const GdhRead = preload("reading.gd")
+const GdhSerialisation = preload("serialisation.gd")
+
+
+## One setting: whether the engine knows it, its value, whether that is the engine's default, and
+## the feature overrides that replace it in some builds.
+static func one(setting_path: String, values: GdhSerialisation) -> Dictionary:
+	var result: Dictionary = {
+		"setting_path": setting_path, "exists": ProjectSettings.has_setting(setting_path)
+	}
+
+	if result["exists"]:
+		var value: Variant = ProjectSettings.get_setting(setting_path)
+		result["value"] = values.serialize_value(value)
+		# A setting the engine registers exists whether or not the project sets it, so exists did
+		# not say whether project.godot has a line for it. At its default it has none: the engine
+		# drops such a key when it saves.
+		var default_value: Variant = ProjectSettings.property_get_revert(setting_path)
+		if default_value != null:
+			result["at_default"] = value == default_value
+	else:
+		result["value"] = null
+		result["message"] = "Setting does not exist"
+
+	# An override exists only while project.godot sets it, so one the file does not set read as a
+	# setting nobody had heard of, when a build with that feature reads its base setting instead.
+	var base: String = override_base(setting_path)
+	if not base.is_empty():
+		result["override_of"] = base
+		if not result["exists"] and ProjectSettings.has_setting(base):
+			result["holds"] = values.serialize_value(ProjectSettings.get_setting(base))
+			result["message"] = overridden_by_none(setting_path, values)
+
+	# The value under this name is not the one every build reads: `name.windows` replaces it on
+	# Windows, `name.editor` in the editor. Read alone, a caller saw the plain value and not the one
+	# their game showed.
+	var overrides: Dictionary = overrides_of(setting_path, values)
+	if not overrides.is_empty():
+		result["overrides"] = overrides
+
+	return result
+
+
+## Every setting whose name starts with [param prefix], with the type the engine registers for
+## each.
+##
+## The type is here because it is the half a name hides. A setting sitting among a family of levels
+## can be a bool, and a caller that assumes otherwise writes a level over it and sees nothing go
+## wrong: 2 is as true as true is.
+static func under(prefix: String, values: GdhSerialisation) -> Dictionary:
+	var found: Array[Dictionary] = []
+	for property: Dictionary in ProjectSettings.get_property_list():
+		var name: String = str(property.get("name", ""))
+		if not name.begins_with(prefix):
+			continue
+		var kind: int = GdhRead.as_int(property.get("type", TYPE_NIL), TYPE_NIL)
+		var value: Variant = ProjectSettings.get_setting(name)
+		var described: Dictionary = {
+			"setting": name,
+			"type": type_string(kind),
+			"value": values.serialize_value(value),
+		}
+		# As a single get says it, so a family read can be told apart into what the project sets
+		# and the engine's defaults: "input/" is ninety actions the engine ships and the project's few.
+		var default_value: Variant = ProjectSettings.property_get_revert(name)
+		if default_value != null:
+			described["at_default"] = value == default_value
+		var base: String = override_base(name)
+		if not base.is_empty():
+			described["override_of"] = base
+		found.append(described)
+
+	found.sort_custom(func(a: Dictionary, b: Dictionary) -> bool: return a["setting"] < b["setting"])
+	return {"prefix": prefix, "count": found.size(), "settings": found}
+
+
+## The setting [param setting_path] overrides for builds with one feature, as
+## `application/run/max_fps.mobile` does `application/run/max_fps`, or "" for a plain setting.
+static func override_base(setting_path: String) -> String:
+	var dot: int = setting_path.find(".", setting_path.rfind("/") + 1)
+	return "" if dot == -1 else setting_path.substr(0, dot)
+
+
+## The overrides project.godot sets for [param setting_path], by feature.
+static func overrides_of(setting_path: String, values: GdhSerialisation) -> Dictionary:
+	var overrides: Dictionary = {}
+	for info: Dictionary in ProjectSettings.get_property_list():
+		var name: String = str(info.get("name", ""))
+		if name.begins_with(setting_path + "."):
+			overrides[name.substr(setting_path.length() + 1)] = values.serialize_value(
+				ProjectSettings.get_setting(name)
+			)
+	return overrides
+
+
+## What a build with the feature of [param setting_path], an override project.godot does not set,
+## reads in its place.
+static func overridden_by_none(setting_path: String, values: GdhSerialisation) -> String:
+	var base: String = override_base(setting_path)
+	var feature: String = setting_path.substr(base.length() + 1)
+	var said: String = (
+		(
+			"project.godot sets no %s override of %s, so a build with the %s feature reads %s, "
+			+ "the value under holds"
+		)
+		% [feature, base, feature, base]
+	)
+	var others: Array[String] = []
+	for name: String in overrides_of(base, values).keys():
+		if name != feature:
+			others.append(name)
+	if others.is_empty():
+		return said + "."
+	others.sort()
+	return said + (", unless it also has a feature with an override: %s." % ", ".join(others))

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

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