gdharness 1.3.8 → 1.3.10

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

@@ -31,25 +31,20 @@ 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 = ""
+## What the last write saved, for its answer to read what the file now stores.
+var written_pack: PackedScene = null
 ## The path of each node a scene this one inherits gives, with the file that makes it.
 var _base_paths: Dictionary = {}
 var _state: SceneState = null
@@ -67,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.
@@ -91,26 +90,16 @@ func open(scene_path: String, for_writing: bool) -> Dictionary:
 	if root == null:
 		return {"ok": false, "error": "Failed to instantiate " + path}
 	_state = packed.get_state()
-	var base: SceneState = _state.get_base_scene_state()
-	# Each node a base gives, with the file that makes it: the deepest base listing it as more than
-	# values set on a node from further down.
-	while base != null:
-		for index: int in base.get_node_count():
-			var given: String = _relative(str(base.get_node_path(index)))
-			var made: bool = (
-				base.get_node_instance(index) != null or not str(base.get_node_type(index)).is_empty()
-			)
-			if made or not _base_paths.has(given):
-				_base_paths[given] = base.get_path()
-		base = base.get_base_scene_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)
@@ -179,20 +168,6 @@ func refuse(error: String) -> Dictionary:
 	return {"ok": false, "error": error}
 
 
-## Each bit set in [param flags], a connection's, by name, and whatever bits are 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.
@@ -350,13 +325,20 @@ func _closed_around(node: Node) -> PackedStringArray:
 func fixed(node: Node, deleting: bool = false) -> String:
 	if node == root:
 		return "The root of %s cannot be moved, renamed, copied or deleted." % path
+	if node.owner == null:
+		return foreign(node)
 	if node.owner != root:
-		var why: String = foreign(node)
-		if why.is_empty():
-			why = "%s is inside an instanced scene, which creates it again on load." % path_of(node)
-			if deleting:
-				why += _deleted_elsewhere(node, node.owner.scene_file_path)
-		return why
+		# Editable children keep values here and no more; the scene instanced may have the node from
+		# a scene it inherits, which is the one to edit.
+		var instanced: String = node.owner.scene_file_path
+		var packed: PackedScene = load(instanced) as PackedScene
+		var made_by: Dictionary = makers(packed.get_state()) if packed != null else {}
+		var maker: String = str(made_by.get(str(node.owner.get_path_to(node)), instanced))
+		var inside: String = (
+			"%s is inside the scene instanced at %s (%s), which creates it again on load."
+			% [path_of(node), path_of(node.owner), instanced]
+		)
+		return inside + (_deleted_elsewhere(node, maker) if deleting else " Edit %s instead." % maker)
 	var at: String = path_of(node)
 	if _base_paths.has(at):
 		var maker: String = str(_base_paths[at])
@@ -367,6 +349,23 @@ func fixed(node: Node, deleting: bool = false) -> String:
 	return ""
 
 
+## Each node the scenes [param state] inherits give it, by path, with the deepest file making it more
+## than values; a node [param state] makes itself is not in it.
+static func makers(state: SceneState) -> Dictionary:
+	var made_by: Dictionary = {}
+	var at: SceneState = state.get_base_scene_state()
+	while at != null:
+		for index: int in at.get_node_count():
+			var given: String = _relative(str(at.get_node_path(index)))
+			var made: bool = (
+				at.get_node_instance(index) != null or not str(at.get_node_type(index)).is_empty()
+			)
+			if made or not made_by.has(given):
+				made_by[given] = at.get_path()
+		at = at.get_base_scene_state()
+	return made_by
+
+
 ## What a caller can do with [param node], made by [param maker], instead of deleting it here.
 static func _deleted_elsewhere(node: Node, maker: String) -> String:
 	var hidden: String = (
@@ -504,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))
 
@@ -531,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
@@ -583,19 +582,12 @@ func write(check: Callable = Callable()) -> Dictionary:
 			return refuse("Nothing was written: " + str(settled[1]))
 		packed = settled[0]
 		if not path.ends_with(".tscn") and _holds_scripted_embedded():
-			return refuse(
-				(
-					(
-						(
-							"Nothing was written: %s is a binary scene holding an embedded resource with a script "
-							+ "that is not a tool, and what that script changed when a headless engine loaded it "
-							+ "cannot be told apart from the file here. "
-						)
-						% path
-					)
-					+ GdhHeadlessCheck.REMEDY
-				)
+			var binary: String = (
+				"Nothing was written: %s is a binary scene holding an embedded resource with a script "
+				+ "that is not a tool, and what that script changed when a headless engine loaded it "
+				+ "cannot be told apart from the file here. "
 			)
+			return refuse(binary % path + GdhHeadlessCheck.REMEDY)
 	if check.is_valid():
 		var saved: Node = packed.instantiate(PackedScene.GEN_EDIT_STATE_MAIN)
 		if saved == null:
@@ -604,27 +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)
-	var written: Dictionary = save_packed(packed, path)
-	if not written.is_empty() or not headless or not path.ends_with(".tscn"):
-		return written
+	written_pack = packed
 	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]
@@ -644,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:
@@ -824,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()]
@@ -894,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
 
@@ -988,7 +933,5 @@ static func _stored_at(state: SceneState, index: int) -> Dictionary:
 	return stored
 
 
-func _relative(node_path: String) -> String:
-	if node_path == ".":
-		return node_path
+static func _relative(node_path: String) -> String:
 	return node_path.trim_prefix("./")

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

@@ -142,28 +142,29 @@ func serialize_value(value: Variant) -> Variant:
 		return value
 	var carried: Variant = call(serialiser, value)
 	# The fixed shapes carry their components as bare floats, so an infinite one in a Vector2 is
-	# tagged here; containers reach their members through this function already.
-	return carried if typeof(value) in [TYPE_ARRAY, TYPE_DICTIONARY] else _finite(carried)
+	# tagged here, and a 32-bit one shortened; containers reach their members through this already.
+	var type: int = typeof(value)
+	return carried if type in [TYPE_ARRAY, TYPE_DICTIONARY] else _finite(carried, GdhRead.holds_singles(type))
 
 
 # [param carried] with every non-finite float in it tagged. JSON has no spelling for infinity or
 # NaN: the engine writes 1e99999 and null, and the server, reading 1e99999 as Infinity, writes it
 # back out as null, so a property holding INF was answered as holding nothing.
-func _finite(carried: Variant) -> Variant:
+func _finite(carried: Variant, single: bool = false) -> Variant:
 	if carried is float:
 		var number: float = carried
-		return _serialize_float(number)
+		return _serialize_float(GdhRead.single(number) if single else number)
 	if carried is Dictionary:
 		var fields: Dictionary = carried
 		var tagged: Dictionary = {}
 		for key: Variant in fields:
-			tagged[key] = _finite(fields[key])
+			tagged[key] = _finite(fields[key], single)
 		return tagged
 	if carried is Array:
 		var items: Array = carried
 		var tagged_items: Array = []
 		for item: Variant in items:
-			tagged_items.append(_finite(item))
+			tagged_items.append(_finite(item, single))
 		return tagged_items
 	return carried
 
@@ -189,7 +190,7 @@ func _serialize_floats(value: Variant) -> Variant:
 			for each: float in numbers:
 				items.append(_serialize_float(each))
 			return items
-	return value
+	return numbers if value is PackedFloat32Array else value
 
 
 # Rebuilds a Godot value from the shape serialize_value gave it.
@@ -222,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
@@ -276,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:
@@ -404,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.
@@ -704,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)