gdharness 1.3.3 → 1.3.5

package/build/godot/operations/property_values.gd

@@ -15,7 +15,9 @@ extends RefCounted
 ## dictionary shaped like a vector or a bare pair of numbers can be read as one.
 
 const GdhDeclared = preload("declared_values.gd")
+const GdhPropertyPaths = preload("property_paths.gd")
 const GdhRead = preload("reading.gd")
+const GdhSame = preload("same_values.gd")
 const GdhSerialisation = preload("serialisation.gd")
 const GdhShapes = preload("value_shapes.gd")
 
@@ -46,23 +48,6 @@ const PACKED_ELEMENTS: Dictionary = {
 	TYPE_PACKED_COLOR_ARRAY: TYPE_COLOR,
 }
 
-# The types made of floats, which a read back compares within float precision: a Vector2 property
-# stores 32-bit components, so 0.1 comes back as 0.100000001.
-const FLOAT_SHAPES: Array[int] = [
-	TYPE_VECTOR2,
-	TYPE_VECTOR3,
-	TYPE_VECTOR4,
-	TYPE_QUATERNION,
-	TYPE_COLOR,
-	TYPE_RECT2,
-	TYPE_TRANSFORM2D,
-	TYPE_BASIS,
-	TYPE_TRANSFORM3D,
-	TYPE_PLANE,
-	TYPE_AABB,
-	TYPE_PROJECTION,
-]
-
 # Entries in a property list that only head a section of the inspector. Object.set ignores their
 # names, so a write to "Visibility" or "Transform" changed nothing and was answered as made.
 const HEADINGS: int = PROPERTY_USAGE_CATEGORY | PROPERTY_USAGE_GROUP | PROPERTY_USAGE_SUBGROUP
@@ -92,7 +77,8 @@ var _outside_declared: Dictionary = {}
 ## declares, or a bare array positional for a vector. Each is its own function; asking all three
 ## in one was twenty-four exits deep and impossible to follow.
 ##
-## [param elements] is what a typed Array or Dictionary holds, as [method elements_of] reads it.
+## [param elements] is what a typed Array or Dictionary holds, as [method GdhDeclared.elements_of]
+## reads it.
 func parse(value: Variant, expected_type: int = TYPE_NIL, elements: Array = []) -> Variant:
 	if value is Dictionary:
 		var fields: Dictionary = value
@@ -195,21 +181,39 @@ func write_all(target: Object, properties: Dictionary) -> String:
 	var unwritten: String = (
 		"" if properties.size() < 2 else " None of the %d properties given was written." % properties.size()
 	)
-	for key: Variant in properties:
+	# The script first, wherever the caller put it, since the properties it declares exist only once
+	# it is attached.
+	var order: Array = properties.keys()
+	if order.has("script"):
+		order.erase("script")
+		order.push_front("script")
+	var home: String = GdhPropertyPaths.home_of(target)
+	for key: Variant in order:
 		var property: String = str(key)
-		var declared: Dictionary = declaration(target, property)
-		if declared.is_empty() and ":" in property:
-			declared = _component_slot(target, property)
+		var place: Array = GdhPropertyPaths.holder_of(target, property, home)
+		var holder: Object = place[0]
+		var name: String = place[1]
+		var declared: Dictionary = declaration(holder, name)
+		if declared.is_empty():
+			var elsewhere: String = GdhPropertyPaths.held_elsewhere(holder, name, home)
+			if not elsewhere.is_empty():
+				return elsewhere + unwritten
+			var ungrown: String = GdhPropertyPaths.grow(holder, name, GdhPropertyPaths.class_called(holder))
+			if not ungrown.is_empty():
+				return ungrown + unwritten
+			declared = declaration(holder, name)
+		if declared.is_empty() and ":" in name:
+			declared = _component_slot(holder, name)
 			if declared.has("refused"):
 				return str(declared["refused"]) + unwritten
-		if declared.is_empty() and target is ShaderMaterial and property.begins_with("shader_parameter/"):
-			return _no_uniform(target as ShaderMaterial, property) + unwritten
+		if declared.is_empty() and holder is ShaderMaterial and name.begins_with("shader_parameter/"):
+			return _no_uniform(holder as ShaderMaterial, name) + unwritten
 		if declared.is_empty():
-			return "%s has no property %s." % [class_called(target), property] + unwritten
-		var value: Array = value_for(target, declared, properties[key])
+			return no_property(holder, name) + unwritten
+		var value: Array = value_for(holder, declared, properties[key])
 		if not value[0]:
 			return str(value[1]) + unwritten
-		var outside: String = GdhDeclared.outside(target, declared, value[1], shown(value[1]))
+		var outside: String = GdhDeclared.outside(holder, declared, value[1], shown(value[1]))
 		if not outside.is_empty():
 			_outside_declared[property] = outside
 		_write(target, property, value[1])
@@ -217,16 +221,16 @@ func write_all(target: Object, properties: Dictionary) -> String:
 		declarations[property] = declared
 
 	for property: String in given:
-		if not same(read_at(target, property), given[property]):
+		if not GdhSame.same(read_at(target, property), given[property]):
 			_write(target, property, given[property])
 	for property: String in given:
 		var held: Variant = read_at(target, property)
-		if not same(held, given[property]):
+		if not GdhSame.same(held, given[property]):
 			var declared: Dictionary = declarations[property]
 			return _not_held(target, property, given[property], held, declared)
 	for property: String in before:
 		var now: Variant = target.get(property)
-		if not same(now, before[property]):
+		if not GdhSame.same(now, before[property]):
 			_also_changed[property] = [before[property], now]
 	return ""
 
@@ -241,7 +245,7 @@ func _not_held(
 ) -> String:
 	var said: String = (
 		"%s.%s was given %s and holds %s after it was set"
-		% [target.get_class(), property, shown(value), shown(held)]
+		% [GdhPropertyPaths.class_called(target), property, shown(value), shown(held)]
 	)
 	var type: int = GdhRead.as_int(declared.get("type", TYPE_NIL))
 	var hint: int = GdhRead.as_int(declared.get("hint", PROPERTY_HINT_NONE))
@@ -354,18 +358,24 @@ func _stored(target: Object, leave: Dictionary) -> Dictionary:
 
 ## What [param target] holds under [param key], a property or a colon path into one's components.
 func read_at(target: Object, key: String) -> Variant:
-	if ":" in key and declaration(target, key).is_empty():
-		return target.get_indexed(NodePath(key))
-	return target.get(key)
+	var place: Array = GdhPropertyPaths.holder_of(target, key)
+	var holder: Object = place[0]
+	var name: String = place[1]
+	if ":" in name and declaration(holder, name).is_empty():
+		return holder.get_indexed(NodePath(name))
+	return holder.get(name)
 
 
 ## Writes [param value] under [param key], putting a changed component back into the property it
 ## was read out of, and that one into the one above it.
 func _write(target: Object, key: String, value: Variant) -> void:
-	if ":" in key and declaration(target, key).is_empty():
-		target.set_indexed(NodePath(key), value)
+	var place: Array = GdhPropertyPaths.holder_of(target, key)
+	var holder: Object = place[0]
+	var name: String = place[1]
+	if ":" in name and declaration(holder, name).is_empty():
+		holder.set_indexed(NodePath(name), value)
 	else:
-		target.set(key, value)
+		holder.set(name, value)
 
 
 ## The declaration the last step of [param path] would have, typed as the component it reaches, so
@@ -373,9 +383,9 @@ func _write(target: Object, key: String, value: Variant) -> void:
 ## {"refused": why} for the first step that is not there.
 func _component_slot(target: Object, path: String) -> Dictionary:
 	var steps: PackedStringArray = path.split(":")
-	var owner: String = target.get_class()
+	var owner: String = GdhPropertyPaths.class_called(target)
 	if declaration(target, steps[0]).is_empty():
-		return {"refused": "%s has no property %s" % [owner, steps[0]]}
+		return {"refused": no_property(target, steps[0])}
 	var value: Variant = target.get(steps[0])
 	var walked: String = steps[0]
 	for index: int in range(1, steps.size()):
@@ -396,7 +406,7 @@ func _component_slot(target: Object, path: String) -> Dictionary:
 		if not step in has:
 			return {
 				"refused":
-				"%s.%s is %s, so it has no %s; it has %s" % [owner, walked, sort, step, ", ".join(has)]
+				"%s.%s is %s, so it has no %s; it has %s." % [owner, walked, sort, step, ", ".join(has)]
 			}
 		value = value[step]
 		walked += ":" + step
@@ -410,18 +420,12 @@ func value_for(target: Object, declared: Dictionary, raw: Variant) -> Array:
 	var hint: int = GdhRead.as_int(declared.get("hint", PROPERTY_HINT_NONE))
 	if expected_type == TYPE_OBJECT and hint == PROPERTY_HINT_NODE_TYPE:
 		return _node_reference(target, property, raw)
-	# An enum is written by the name of a value as well as its number, since the name is what the
-	# script and the inspector show and the number is only where the value happens to sit.
 	if expected_type == TYPE_INT and hint == PROPERTY_HINT_ENUM and typeof(raw) == TYPE_STRING:
-		var choices: Dictionary = GdhDeclared.enum_of(target, declared)
-		var chosen: Variant = GdhDeclared.enum_named(choices, str(raw))
-		if chosen == null:
-			var hinted: Dictionary = GdhDeclared.enum_values(str(declared.get("hint_string", "")))
-			chosen = GdhDeclared.enum_named(hinted, str(raw))
-		if chosen != null:
-			return [true, chosen]
-		if not str(raw).strip_edges().is_valid_int():
-			return [false, GdhDeclared.enum_refusal(class_called(target), property, str(raw), choices)]
+		var by_name: Array = GdhDeclared.enum_by_name(
+			target, declared, str(raw), GdhPropertyPaths.class_called(target)
+		)
+		if by_name[0] or not str(by_name[1]).is_empty():
+			return by_name
 
 	# A resource-valued property takes the path of one, which is how a caller names a TileSet,
 	# a material or a theme: there is no other way to hand a tool a Resource.
@@ -432,17 +436,28 @@ func value_for(target: Object, declared: Dictionary, raw: Variant) -> Array:
 			return found
 		value = found[1]
 	else:
-		var elements: Array = elements_of(declared)
+		var elements: Array = GdhDeclared.elements_of(declared)
 		if _fraction(raw, expected_type, elements):
 			return [false, _fraction_refusal(target, property, raw)]
 		var rounded: String = GdhSerialisation.inexact(raw, expected_type)
 		if not rounded.is_empty():
-			return [false, "%s.%s holds int: %s." % [class_called(target), property, rounded]]
+			return [
+				false, "%s.%s holds int: %s." % [GdhPropertyPaths.class_called(target), property, rounded]
+			]
 		_refused = ""
 		value = parse(raw, expected_type, elements)
 		if not _refused.is_empty():
 			return [false, _refused]
-		var refusal: String = cannot_hold(class_called(target), property, value, expected_type, elements)
+		if expected_type == TYPE_ARRAY and elements == [TYPE_OBJECT] and value is Array:
+			var listed: Array = value
+			return _object_list(target, declared, listed)
+		if expected_type == TYPE_DICTIONARY and elements.size() == 2 and value is Dictionary:
+			if GdhRead.as_int(elements[1], TYPE_NIL) == TYPE_OBJECT:
+				var mapped: Dictionary = value
+				return _object_entries(target, declared, mapped)
+		var refusal: String = cannot_hold(
+			GdhPropertyPaths.class_called(target), property, value, expected_type, elements
+		)
 		if not refusal.is_empty():
 			return [false, refusal]
 	if value is Object:
@@ -497,60 +512,102 @@ func _wrong_class(value: Object, declared: Dictionary) -> String:
 		return ""
 	var names: PackedStringArray = wanted.split(",", false)
 	for name: String in names:
-		if value.is_class(name.strip_edges()):
+		if GdhDeclared.is_a(value, name.strip_edges()):
 			return ""
-		var script: Script = value.get_script()
-		while script != null:
-			if str(script.get_global_name()) == name.strip_edges():
-				return ""
-			script = script.get_base_script()
 	return (
 		"%s holds %s, and the value given is a %s."
 		% [str(declared.get("name", "")), " or ".join(names), value.get_class()]
 	)
 
 
-## The element types a typed Array or Dictionary property declares: [element] for an array,
-## [key, value] for a dictionary, [] when nothing is declared.
-##
-## Read from the declaration because the value cannot say: a script's exported `Array[int]` sits
-## behind a placeholder in the editor, and measured on 4.7.2 that placeholder stores [1.5, 2.0]
-## as given, which the game then fails to load into the typed array.
-static func elements_of(declared: Dictionary) -> Array:
-	var type: int = GdhRead.as_int(declared.get("type", TYPE_NIL), TYPE_NIL)
-	var hint: int = GdhRead.as_int(declared.get("hint", PROPERTY_HINT_NONE))
-	var wanted: String = str(declared.get("hint_string", ""))
-	if wanted.is_empty():
-		return []
-	if hint == PROPERTY_HINT_TYPE_STRING:
-		var parts: PackedStringArray = wanted.split(";")
-		if type == TYPE_ARRAY and parts.size() == 1:
-			return [_type_in_hint(parts[0])]
-		if type == TYPE_DICTIONARY and parts.size() == 2:
-			return [_type_in_hint(parts[0]), _type_in_hint(parts[1])]
-		return []
-	if hint == PROPERTY_HINT_ARRAY_TYPE and type == TYPE_ARRAY:
-		return [_type_named(wanted)]
-	if hint == PROPERTY_HINT_DICTIONARY_TYPE and type == TYPE_DICTIONARY:
-		var parts: PackedStringArray = wanted.split(";")
-		if parts.size() == 2:
-			return [_type_named(parts[0]), _type_named(parts[1])]
-	return []
-
-
-## The type at the front of one entry of a type-string hint, "2:" or "24/17:Texture2D".
-static func _type_in_hint(entry: String) -> int:
-	var number: String = entry.get_slice(":", 0).get_slice("/", 0)
-	return number.to_int() if number.is_valid_int() else TYPE_NIL
-
-
-## The Variant type [param name] names, or TYPE_OBJECT for a class.
-static func _type_named(name: String) -> int:
-	var named: String = name.get_slice(":", 0).strip_edges()
-	for type: int in TYPE_MAX:
-		if type_string(type) == named:
-			return type
-	return TYPE_OBJECT if not named.is_empty() else TYPE_NIL
+## [param value] as the typed list of objects that [param declared] holds on [param target], as
+## [ok, list or why not]. Measured on 4.7.2, a scene's node whose script exports Array[Item] holds []
+## after being given an untyped list of Items, and keeps a list typed as its own is.
+func _object_list(target: Object, declared: Dictionary, value: Array) -> Array:
+	var property: String = str(declared.get("name", ""))
+	var kind: Array = GdhDeclared.object_kind(declared, 0)
+	var holding: String = "%s.%s holds %s" % [GdhPropertyPaths.class_called(target), property, kind[0]]
+	var items: Array = []
+	for index: int in value.size():
+		var place: Array = ["item %d of the list given" % index, "item %d of %s" % [index, property]]
+		var item: Array = _object_item(target, value[index], kind, holding, place)
+		if not item[0]:
+			return item
+		items.append(item[1])
+	var held: Variant = target.get(property)
+	var current: Array = held if held is Array else []
+	if current.is_typed():
+		return [
+			true,
+			Array(
+				items, current.get_typed_builtin(), current.get_typed_class_name(), current.get_typed_script()
+			)
+		]
+	var typing: Array = GdhDeclared.object_typing(str(kind[0]))
+	if typing.is_empty():
+		return [true, items]
+	var base: StringName = typing[0]
+	var script: Script = typing[1]
+	return [true, Array(items, TYPE_OBJECT, base, script)]
+
+
+## [param value] as the typed map to objects that [param declared] holds on [param target], as
+## [ok, map or why not], typed for the same reason as [method _object_list].
+func _object_entries(target: Object, declared: Dictionary, value: Dictionary) -> Array:
+	var property: String = str(declared.get("name", ""))
+	var kind: Array = GdhDeclared.object_kind(declared, 1)
+	var holding: String = "%s.%s holds %s values" % [GdhPropertyPaths.class_called(target), property, kind[0]]
+	var entries: Dictionary = {}
+	for key: Variant in value:
+		var place: Array = ["the one given for %s" % shown(key), "%s[%s]" % [property, shown(key)]]
+		var entry: Array = _object_item(target, value[key], kind, holding, place)
+		if not entry[0]:
+			return entry
+		entries[key] = entry[1]
+	var held: Variant = target.get(property)
+	var current: Dictionary = held if held is Dictionary else {}
+	if current.is_typed():
+		return [
+			true,
+			Dictionary(
+				entries,
+				current.get_typed_key_builtin(),
+				current.get_typed_key_class_name(),
+				current.get_typed_key_script(),
+				current.get_typed_value_builtin(),
+				current.get_typed_value_class_name(),
+				current.get_typed_value_script()
+			)
+		]
+	var typing: Array = GdhDeclared.object_typing(str(kind[0]))
+	var key_type: int = GdhRead.as_int(GdhDeclared.elements_of(declared)[0], TYPE_NIL)
+	if typing.is_empty() or key_type == TYPE_OBJECT:
+		return [true, entries]
+	var base: StringName = typing[0]
+	var script: Script = typing[1]
+	return [true, Dictionary(entries, key_type, &"", null, TYPE_OBJECT, base, script)]
+
+
+## [param given], an object for a typed list or map, as [ok, object or why not]: a resource's
+## res:// path is the resource, and for nodes a path from [param target] is the node there.
+## [param holding] says what the list or map holds, and [param place] is [where the value sits in
+## what was given, what it is called in the property].
+func _object_item(target: Object, given: Variant, kind: Array, holding: String, place: Array) -> Array:
+	var item: Variant = given
+	if typeof(item) == TYPE_STRING:
+		var found: Array = (
+			_node_reference(target, str(place[1]), item)
+			if kind[1]
+			else _resource_at(str(item), str(place[1]))
+		)
+		if not found[0]:
+			return found
+		item = found[1]
+	var object: Object = item if item is Object else null
+	if item == null or (object != null and GdhDeclared.is_a(object, str(kind[0]))):
+		return [true, item]
+	var named: String = object.get_class() if object != null else shown(item)
+	return [false, "%s, and %s is %s." % [holding, place[0], named]]
 
 
 ## Whether [param value] holds a number with a fractional part where an integer is wanted, in a
@@ -587,7 +644,7 @@ func _fraction_refusal(target: Object, property: String, raw: Variant) -> String
 			"%s.%s holds whole numbers, and %s would be cut to fit. Setting it would save a different "
 			+ "value than the one asked for."
 		)
-		% [class_called(target), property, shown(raw)]
+		% [GdhPropertyPaths.class_called(target), property, shown(raw)]
 	)
 
 
@@ -612,16 +669,15 @@ func colour_from(raw: Variant, named: String) -> Array:
 	]
 
 
-## What [param target] is called in a refusal: the class_name its script declares, or else its
-## engine class. A resource made as a project class is a Resource to the engine, and "Resource.kind"
-## named a property no Resource has.
-static func class_called(target: Object) -> String:
-	var attached: Variant = target.get_script()
-	if attached is Script:
-		var script: Script = attached
-		if not str(script.get_global_name()).is_empty():
-			return str(script.get_global_name())
-	return target.get_class()
+## The refusal for [param property], which [param target] does not declare, naming the declared
+## ones nearest it: "StyleBoxFlat has no property shadow_sizee" left the caller nothing to send.
+static func no_property(target: Object, property: String) -> String:
+	return (
+		GdhRead.near_property(
+			"%s has no property %s" % [GdhPropertyPaths.class_called(target), property], target, property
+		)
+		+ "."
+	)
 
 
 ## The resource [param path] names, as [found, resource or why not].
@@ -669,15 +725,10 @@ func _resource_at(path: String, property: String) -> Array:
 ## its name, so without this a typo or a heading saved a file that had not changed and reported it
 ## as one that had.
 func declaration(target: Object, property: String) -> Dictionary:
-	for declared: Dictionary in target.get_property_list():
-		if str(declared.get("name", "")) != property:
-			continue
-		if GdhRead.as_int(declared.get("usage", 0)) & HEADINGS:
-			continue
-		return declared
-	if target is Theme:
+	var declared: Dictionary = GdhPropertyPaths.declared_on(target, property)
+	if declared.is_empty() and target is Theme:
 		return _theme_item(property)
-	return {}
+	return declared
 
 
 ## The entry a Theme would declare for [param property] once it held that item, or {} when the name
@@ -696,107 +747,6 @@ static func _theme_item(property: String) -> Dictionary:
 	return made
 
 
-## Whether [param held] is [param given], as a property read back after a set answers it.
-##
-## Close enough rather than equal for anything made of floats: a Vector2 property stores 32-bit
-## components, so 0.1 comes back as 0.100000001. A packed array read back against the list it was
-## given compares element by element, since `==` between the two is an error rather than false.
-static func same(held: Variant, given: Variant) -> bool:
-	var held_type: int = typeof(held)
-	var given_type: int = typeof(given)
-	# An empty object property reads back as an Object that is null, not as nil, and the two are
-	# the same nothing.
-	var held_none: bool = held_type == TYPE_NIL or (held_type == TYPE_OBJECT and held == null)
-	var given_none: bool = given_type == TYPE_NIL or (given_type == TYPE_OBJECT and given == null)
-	if held_none or given_none:
-		return held_none == given_none
-	if held_type == TYPE_OBJECT or given_type == TYPE_OBJECT:
-		return _same_object(held, given)
-	if GdhSerialisation.NUMBERS.has(held_type) and GdhSerialisation.NUMBERS.has(given_type):
-		if held_type == TYPE_BOOL or given_type == TYPE_BOOL:
-			return held_type == given_type and held == given
-		var held_number: float = GdhRead.as_float(held)
-		var given_number: float = GdhRead.as_float(given)
-		return (is_nan(held_number) and is_nan(given_number)) or is_equal_approx(held_number, given_number)
-	if GdhSerialisation.TEXTS.has(held_type) and GdhSerialisation.TEXTS.has(given_type):
-		return str(held) == str(given)
-	if _listed(held_type) and _listed(given_type):
-		var held_items: Array = type_convert(held, TYPE_ARRAY)
-		var given_items: Array = type_convert(given, TYPE_ARRAY)
-		if held_items.size() != given_items.size():
-			return false
-		for index: int in held_items.size():
-			if not same(held_items[index], given_items[index]):
-				return false
-		return true
-	if held_type == TYPE_DICTIONARY and given_type == TYPE_DICTIONARY:
-		var held_entries: Dictionary = held
-		var given_entries: Dictionary = given
-		return _same_entries(held_entries, given_entries)
-	if held_type != given_type:
-		return false
-	return _same_shape(held, given)
-
-
-static func _same_object(held: Variant, given: Variant) -> bool:
-	if typeof(held) != TYPE_OBJECT or typeof(given) != TYPE_OBJECT:
-		return false
-	if is_same(held, given):
-		return true
-	if not held is Resource or not given is Resource:
-		return false
-	var held_resource: Resource = held
-	var given_resource: Resource = given
-	if not held_resource.resource_path.is_empty():
-		return held_resource.resource_path == given_resource.resource_path
-	# A resource local to the scene is duplicated for every instance, so the copy read back is
-	# another object of the same class.
-	return held_resource.resource_local_to_scene and held_resource.get_class() == given_resource.get_class()
-
-
-static func _same_entries(held: Dictionary, given: Dictionary) -> bool:
-	if held.size() != given.size():
-		return false
-	for key: Variant in given:
-		var found: bool = false
-		for held_key: Variant in held:
-			if same(held_key, key):
-				found = same(held[held_key], given[key])
-				break
-		if not found:
-			return false
-	return true
-
-
-## Two values of one type made of floats, compared component by component through the type's own
-## text form, which lists every component: each type has its own is_equal_approx, and reaching it
-## through a Variant is a call the typed gate refuses.
-static func _same_shape(held: Variant, given: Variant) -> bool:
-	if typeof(held) not in FLOAT_SHAPES:
-		return held == given
-	var held_parts: Array[float] = _components(held)
-	var given_parts: Array[float] = _components(given)
-	if held_parts.size() != given_parts.size():
-		return false
-	for index: int in held_parts.size():
-		if not same(held_parts[index], given_parts[index]):
-			return false
-	return true
-
-
-static func _components(value: Variant) -> Array[float]:
-	var parts: Array[float] = []
-	var text: String = var_to_str(value)
-	var inner: String = text.substr(text.find("(") + 1).trim_suffix(")")
-	for part: String in inner.split(",", false):
-		parts.append(part.strip_edges().to_float())
-	return parts
-
-
-static func _listed(type: int) -> bool:
-	return type == TYPE_ARRAY or PACKED_ELEMENTS.has(type)
-
-
 ## [param value] as a caller would write it, for a refusal to quote.
 func shown(value: Variant) -> String:
 	return JSON.stringify(_values.serialize_value(value), "", false)
@@ -833,18 +783,22 @@ func _parse_resource_tag(value: Dictionary) -> Array:
 			_refused = str(found[1])
 			return [true, null]
 		return [true, found[1]]
-	# What a read answers for a resource built into the scene it was read from: a class and no
+	# What a read answers where a resource built into a scene recurs inside itself: a class and no
 	# path. Taken as nothing, it cleared the property it was written back to.
 	if value.has("class"):
 		_refused = (
 			(
-				"The %s given has no path: it was read from a resource built into a scene, which cannot "
-				+ 'be referred to from elsewhere. Build a new one with "_type" set to its class and its '
-				+ "properties beside it."
+				"The %s given has no path: a read names a resource built into a scene by its class "
+				+ "alone where it recurs inside itself, and nothing elsewhere can refer to it. Build "
+				+ 'a new one with "_type" set to its class and its properties beside it.'
 			)
 			% str(value["class"])
 		)
 		return [true, null]
+	# A plain Resource with a script or values of its own, as a read answers one built into a scene,
+	# is one to build; taken as nothing, writing such a read back cleared the property.
+	if value.size() > 1:
+		return _parse_new_resource("Resource", value)
 	return [true, null]
 
 
@@ -852,15 +806,21 @@ func _parse_resource_tag(value: Dictionary) -> Array:
 ## NavigationRegion2D can arrive with its NavigationPolygon and an AnimationTree with its root
 ## state machine in the same add as any other property.
 func _parse_new_resource(type_tag: String, value: Dictionary) -> Array:
+	var built: Resource = null
 	if (
-		type_tag.is_empty()
-		or not ClassDB.class_exists(type_tag)
-		or not ClassDB.is_parent_class(type_tag, "Resource")
-		or not ClassDB.can_instantiate(type_tag)
+		ClassDB.class_exists(type_tag)
+		and ClassDB.is_parent_class(type_tag, "Resource")
+		and ClassDB.can_instantiate(type_tag)
 	):
+		built = ClassDB.instantiate(type_tag)
+	elif not type_tag.is_empty() and not ClassDB.class_exists(type_tag):
+		# A script's class_name, as a read answers it under scriptClass.
+		var script: Script = GdhDeclared.script_class(type_tag)
+		if script != null and ClassDB.is_parent_class(script.get_instance_base_type(), "Resource"):
+			built = ClassDB.instantiate(script.get_instance_base_type())
+			built.set_script(script)
+	if built == null:
 		return [false, null]
-
-	var built: Resource = ClassDB.instantiate(type_tag)
 	var wanted: Dictionary = {}
 	for key: Variant in value:
 		var property: String = str(key)
@@ -870,6 +830,7 @@ func _parse_new_resource(type_tag: String, value: Dictionary) -> Array:
 	if not refused.is_empty():
 		_refused = refused
 		return [true, null]
+	GdhDeclared.unmade(built, wanted)
 	return [true, built]
 
 

package/build/godot/operations/reading.gd

@@ -189,6 +189,21 @@ static func offered(said: String, word: String, names: Array) -> String:
 	return "%s; the nearest it has %s %s" % [said, "is" if close.size() == 1 else "are", ", ".join(close)]
 
 
+## [param said], the refusal for [param property], which [param target] does not declare, with the
+## names it declares nearest it when any are, as a misspelt one is usually one of them. Unlike
+## [method offered], nothing is listed when none is near, since an object declares a hundred.
+static func near_property(said: String, target: Object, property: String) -> String:
+	var headings: int = PROPERTY_USAGE_CATEGORY | PROPERTY_USAGE_GROUP | PROPERTY_USAGE_SUBGROUP
+	var names: Array[String] = []
+	for declared: Dictionary in target.get_property_list():
+		if not as_int(declared.get("usage", 0)) & headings:
+			names.append(str(declared.get("name", "")))
+	var close: PackedStringArray = nearest(property, PackedStringArray(names))
+	if close.is_empty():
+		return said
+	return "%s; the nearest it has %s %s" % [said, "is" if close.size() == 1 else "are", ", ".join(close)]
+
+
 ## The signals [param object] has that a caller can connect, its own class's first: the engine
 ## lists them from Object down, which puts a Button's pressed after thirty a Control has, and names
 ## starting with an underscore are the engine's own.