gdharness 1.1.21 → 1.1.23

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

@@ -94,12 +94,17 @@ func parameter_class(object: Object, method: String, index: int) -> String:
 
 
 ## What the slot [param named] on [param holder] declares it holds, as `{"type": int, "class":
-## String}`: a property's declaration, or the element type of a typed list or the value type of a
-## typed map. TYPE_NIL when nothing is declared.
+## String, "script": Script or null}`: a property's declaration, or the element type of a typed list
+## or the value type of a typed map. TYPE_NIL when nothing is declared, which is also what a
+## property declared as Variant or left untyped reads as: either way it takes anything.
 ##
 ## Asked rather than read off the value in the slot, because an object slot can be empty: a
 ## property typed `Gear` holding null reads as TYPE_NIL, and anything written into it passed the
 ## check and was then dropped by the engine, which answered with the slot still null.
+##
+## The script only for a typed container, the one place the engine hands it over. A property typed
+## as a script class with no `class_name` is declared under the engine class the script extends,
+## measured on 4.7.2: `var quarrel: Walker` with Walker a preloaded Node3D script lists as Node3D.
 static func slot_declared(holder: Variant, named: String) -> Dictionary:
 	if holder is Array:
 		var items: Array = holder
@@ -107,6 +112,7 @@ static func slot_declared(holder: Variant, named: String) -> Dictionary:
 			return {
 				"type": items.get_typed_builtin(),
 				"class": _typed_class(items.get_typed_script(), items.get_typed_class_name()),
+				"script": _script_or_null(items.get_typed_script()),
 			}
 	elif holder is Dictionary:
 		var map: Dictionary = holder
@@ -114,6 +120,7 @@ static func slot_declared(holder: Variant, named: String) -> Dictionary:
 			return {
 				"type": map.get_typed_value_builtin(),
 				"class": _typed_class(map.get_typed_value_script(), map.get_typed_value_class_name()),
+				"script": _script_or_null(map.get_typed_value_script()),
 			}
 	elif holder is Object:
 		var object: Object = holder
@@ -122,8 +129,13 @@ static func slot_declared(holder: Variant, named: String) -> Dictionary:
 				return {
 					"type": Read.as_int(entry.get("type", TYPE_NIL), TYPE_NIL),
 					"class": str(entry.get("class_name", "")),
+					"script": null,
 				}
-	return {"type": TYPE_NIL, "class": ""}
+	return {"type": TYPE_NIL, "class": "", "script": null}
+
+
+static func _script_or_null(typed: Variant) -> Script:
+	return typed if typed is Script else null
 
 
 ## The class a typed container names: its script's global name where it has one, since the engine
@@ -138,7 +150,20 @@ static func _typed_class(script: Variant, engine_class: StringName) -> String:
 
 ## Whether [param object] is a [param declared]: an engine class, or a script class by its global
 ## name anywhere along the script's inheritance.
-static func is_a(object: Object, declared: String) -> bool:
+##
+## Against [param declared_script] itself when there is one. A script with no global name is named by
+## the engine class it extends, so an object of that class with another script, or none, passes the
+## name, and a typed list built with it drops the element: measured on 4.7.2, an Array[Walker] given
+## a plain Node3D comes out empty, the engine's errors going to the game's output alone.
+static func is_a(object: Object, declared: String, declared_script: Script = null) -> bool:
+	if declared_script != null:
+		var own: Variant = object.get_script()
+		while own is Script:
+			if own == declared_script:
+				return true
+			var along: Script = own
+			own = along.get_base_script()
+		return false
 	if object.is_class(declared):
 		return true
 	var script: Variant = object.get_script()
@@ -150,16 +175,41 @@ static func is_a(object: Object, declared: String) -> bool:
 	return false
 
 
-## What [param object] is, by its script class where it has one.
+## What became of [param node] once an input it was given has run: still in the tree, taken out of
+## it, or freed. Untyped, because a freed reference handed to a typed parameter is itself the engine
+## error this is here to avoid.
+static func afterwards(node: Variant) -> String:
+	if not is_instance_valid(node):
+		return "freed"
+	if not node is Node:
+		return "removed"
+	var placed: Node = node
+	return "in_tree" if placed.is_inside_tree() else "removed"
+
+
+## What [param object] is, by its script class where it has one, and by its script's file where
+## that has no global name, since the engine class alone is what a refusal about the script has
+## just said it matched.
 static func class_of(object: Object) -> String:
 	var script: Variant = object.get_script()
 	if script is Script:
 		var current: Script = script
 		if not current.get_global_name().is_empty():
 			return str(current.get_global_name())
+		return "%s with the script %s" % [object.get_class(), script_named(current)]
 	return object.get_class()
 
 
+## How a refusal names [param script]: its global name, or its file. A class declared inside another
+## script has neither, measured on 4.7.2, so it is called an inner class and no more.
+static func script_named(script: Script) -> String:
+	if not script.get_global_name().is_empty():
+		return str(script.get_global_name())
+	if not script.resource_path.is_empty():
+		return script.resource_path
+	return "an inner class"
+
+
 ## A value from the wire fitted to the type a property or parameter declares.
 func fitted(value: Variant, type: int) -> Variant:
 	return _shared.fitted(value, type)
@@ -224,9 +274,13 @@ static func _element_type(named: String) -> Dictionary:
 ## A typed container refuses a plain one, and the engine says nothing about it: an Array[int]
 ## property written with the list JSON carries kept what it held, and the answer showed the write
 ## as done. Each element is fitted the way a single value is, and an object element is named by
-## its path through [param resolve], which is called with the path and the class declared and
-## answers the way an object argument does. Anything that is not a typed container comes back as
-## it was given.
+## its path through [param resolve], which is called with the path, the class declared and the
+## script declared, and answers the way an object argument does. Anything that is not a typed
+## container comes back as it was given.
+##
+## The container built is counted against what went into it. The engine drops an element it will
+## not take and says so only in the game's output, so a list that came out shorter is refused here
+## rather than written, which would empty the game's own.
 func typed_like(given: Variant, like: Variant, resolve: Callable) -> Dictionary:
 	if like is Array and given is Array:
 		var template: Array = like
@@ -239,20 +293,18 @@ func typed_like(given: Variant, like: Variant, resolve: Callable) -> Dictionary:
 				items[index],
 				template.get_typed_builtin(),
 				_typed_class(template.get_typed_script(), template.get_typed_class_name()),
+				_script_or_null(template.get_typed_script()),
 				resolve
 			)
 			if element.has("message"):
 				return {"message": "element %d %s" % [index, element["message"]]}
 			built.append(element["value"])
-		return {
-			"value":
-			Array(
-				built,
-				template.get_typed_builtin(),
-				template.get_typed_class_name(),
-				template.get_typed_script()
-			)
-		}
+		var typed: Array = Array(
+			built, template.get_typed_builtin(), template.get_typed_class_name(), template.get_typed_script()
+		)
+		if typed.size() != built.size():
+			return {"message": "the engine would not take its elements as what the list holds"}
+		return {"value": typed}
 	if like is Dictionary and given is Dictionary:
 		var map_like: Dictionary = like
 		if not map_like.is_typed():
@@ -264,6 +316,7 @@ func typed_like(given: Variant, like: Variant, resolve: Callable) -> Dictionary:
 				key,
 				map_like.get_typed_key_builtin(),
 				_typed_class(map_like.get_typed_key_script(), map_like.get_typed_key_class_name()),
+				_script_or_null(map_like.get_typed_key_script()),
 				resolve
 			)
 			if key_fitted.has("message"):
@@ -272,33 +325,37 @@ func typed_like(given: Variant, like: Variant, resolve: Callable) -> Dictionary:
 				entries[key],
 				map_like.get_typed_value_builtin(),
 				_typed_class(map_like.get_typed_value_script(), map_like.get_typed_value_class_name()),
+				_script_or_null(map_like.get_typed_value_script()),
 				resolve
 			)
 			if value_fitted.has("message"):
 				return {"message": "the value under %s %s" % [str(key), value_fitted["message"]]}
 			rebuilt[key_fitted["value"]] = value_fitted["value"]
-		return {
-			"value":
-			Dictionary(
-				rebuilt,
-				map_like.get_typed_key_builtin(),
-				map_like.get_typed_key_class_name(),
-				map_like.get_typed_key_script(),
-				map_like.get_typed_value_builtin(),
-				map_like.get_typed_value_class_name(),
-				map_like.get_typed_value_script()
-			)
-		}
+		var typed_map: Dictionary = Dictionary(
+			rebuilt,
+			map_like.get_typed_key_builtin(),
+			map_like.get_typed_key_class_name(),
+			map_like.get_typed_key_script(),
+			map_like.get_typed_value_builtin(),
+			map_like.get_typed_value_class_name(),
+			map_like.get_typed_value_script()
+		)
+		if typed_map.size() != rebuilt.size():
+			return {"message": "the engine would not take its entries as what the map holds"}
+		return {"value": typed_map}
 	return {"value": given}
 
 
 ## One element fitted to a container's element type, as `{"value"}` or `{"message"}` saying what it
 ## was and what goes there. The message is the part after "element N".
-func _element(item: Variant, builtin: int, declared: String, resolve: Callable) -> Dictionary:
+##
+## An object element given as a record goes to [param resolve] as a path would, which says how an
+## object is named, rather than being refused as a map that cannot become the class.
+func _element(item: Variant, builtin: int, declared: String, script: Script, resolve: Callable) -> Dictionary:
 	if builtin == TYPE_NIL:
 		return {"value": item}
-	if builtin == TYPE_OBJECT and item is String:
-		var named: Dictionary = resolve.call(item, declared)
+	if builtin == TYPE_OBJECT and (item is String or item is Dictionary):
+		var named: Dictionary = resolve.call(item, declared, script)
 		if named.has("message"):
 			return {"message": str(named["message"])}
 		return {"value": named["object"]}
@@ -306,6 +363,8 @@ func _element(item: Variant, builtin: int, declared: String, resolve: Callable)
 	if not acceptable(fitted_item, builtin):
 		# The value as it was sent rather than its engine type: JSON numbers arrive as floats, so a 7
 		# the caller wrote was named "float".
-		var wanted: String = declared if builtin == TYPE_OBJECT else type_string(builtin)
+		var wanted: String = type_string(builtin)
+		if builtin == TYPE_OBJECT:
+			wanted = declared if script == null else script_named(script)
 		return {"message": "is %s, which cannot become %s" % [JSON.stringify(serialize(item)), wanted]}
 	return {"value": fitted_item}

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

@@ -3,6 +3,7 @@ extends RefCounted
 ## The commands that take time: they let the game run and answer when what was waited for has
 ## happened, or when the time ran out, so the caller never sleeps for a guessed length.
 
+const Changes = preload("runtime_changes.gd")
 const Paths = preload("runtime_paths.gd")
 const Queries = preload("runtime_queries.gd")
 const Read = preload("reading.gd")
@@ -68,7 +69,6 @@ func wait_signal(params: Dictionary) -> Dictionary:
 		return {"type": "error", "message": "%s has no signal %s" % [node_path, signal_name]}
 
 	var catcher: SignalCatcher = SignalCatcher.new()
-	catcher.arity = _signal_arity(node, signal_name)
 	var callable: Callable = catcher._on_fired
 	var listening: Error = node.connect(signal_name, callable, CONNECT_ONE_SHOT)
 	if listening != OK:
@@ -149,9 +149,11 @@ func wait_until(params: Dictionary) -> Dictionary:
 	# two ops would disagree about one property, and the wait would run out on the text null.
 	var untyped_object: bool = declared == TYPE_NIL and (current == null or typeof(current) == TYPE_OBJECT)
 	var holds_objects: bool = declared == TYPE_OBJECT or untyped_object
-	if holds_objects and wanted is String and str(wanted).strip_edges() == "null":
+	if holds_objects and Changes.names_no_object(wanted):
 		wanted = null
 	var refused: String = _not_comparable(current, wanted, node_path, property)
+	if refused.is_empty():
+		refused = _cut_to_fit(params["value"], typeof(current), node_path, property)
 	var never_held: bool = typeof(wanted) != TYPE_NIL and typeof(wanted) != TYPE_OBJECT
 	if refused.is_empty() and declared == TYPE_OBJECT and never_held:
 		refused = (
@@ -168,9 +170,12 @@ func wait_until(params: Dictionary) -> Dictionary:
 	var frames: int = 0
 	# The type is checked every time round, not only at the top: a property that holds an object a
 	# frame later is the same error arriving late.
+	# At the precision the property keeps, as set compares: a float arrives as 64 bits and most
+	# engine properties keep 32, so h_offset waited on as -1.1 read -1.10000002384186 every frame and
+	# the wait ran out on a value the game had reached.
 	while (
 		Values.comparable(current, wanted)
-		and current != wanted
+		and not Changes.held_already(wanted, current)
 		and Time.get_ticks_msec() - started < timeout_ms
 	):
 		await _host.get_tree().process_frame
@@ -186,13 +191,42 @@ func wait_until(params: Dictionary) -> Dictionary:
 		"type": "condition",
 		"path": node_path,
 		"property": property,
-		"met": Values.comparable(current, wanted) and current == wanted,
+		"met": Changes.held_already(wanted, current),
 		"value": _values.serialize(current),
 		"elapsed_ms": Time.get_ticks_msec() - started,
 		"frames": frames,
 	}
 
 
+## Why [param given] would have to be cut to be waited on a whole number or a truth, or "" when not.
+##
+## A number arrives from JSON as a float, so one is converted to what the property holds, and the
+## conversion truncates: 3.5 waited on an int became 3 and 0.2 on a bool became true, and a property
+## already holding that answered met at once, about a state nobody asked for.
+static func _cut_to_fit(given: Variant, type: int, node_path: String, property: String) -> String:
+	if type != TYPE_INT and type != TYPE_BOOL:
+		return ""
+	var number: Variant = given
+	if given is String:
+		var text: String = given
+		number = Read.json_or_null(text)
+	if typeof(number) != TYPE_FLOAT and typeof(number) != TYPE_INT:
+		return ""
+	var value: float = Read.as_float(number)
+	var whole: bool = value == floorf(value)
+	if type == TYPE_INT and whole:
+		return ""
+	if type == TYPE_BOOL and whole and (value == 0.0 or value == 1.0):
+		return ""
+	return (
+		(
+			"%s.%s holds %s and the value to wait for is %s, which it would have to be cut to fit:"
+			+ " waiting on it would answer about a state nobody asked for."
+		)
+		% [node_path, property, type_string(type), str(given)]
+	)
+
+
 ## Why [param wanted] cannot be waited for against [param current], or "" when it can.
 ##
 ## Refused before anything is evaluated, because the evaluation is what does the damage: an object
@@ -208,6 +242,17 @@ static func _not_comparable(current: Variant, wanted: Variant, node_path: String
 	var types: Array[String] = [
 		node_path, property, type_string(typeof(current)), type_string(typeof(wanted))
 	]
+	# A value that cannot become what the property holds is said as that, which names the remedy,
+	# before the comparison it would also fail; an object on either side is said as the comparison.
+	var objects: bool = typeof(current) == TYPE_OBJECT or typeof(wanted) == TYPE_OBJECT
+	if not objects and not Values.acceptable(wanted, typeof(current)):
+		return (
+			(
+				"%s.%s holds %s and the value to wait for is %s, which cannot become one:"
+				+ " waiting on it would answer about a state nobody asked for."
+			)
+			% types
+		)
 	if not Values.comparable(current, wanted):
 		return (
 			(
@@ -247,16 +292,15 @@ static func _watched(node: Node, node_path: String, property: String) -> Diction
 	return {"value": Paths.read_under(holder, named), "declared": _declared_type(holder, named)}
 
 
-## The type [param named] is declared with on [param holder], or TYPE_NIL for anything that declares
-## none: an untyped property, a step into a list or map, or a call.
+## The type [param named] is declared with on [param holder], read the way a set reads it, so the two
+## refuse the same values: a property's declaration, or a typed list's or map's element type. Read
+## off properties alone, an element of an Array[Node] holding null declares nothing, and a wait for 5
+## on it runs out the timeout while a set of 5 on it is refused at once. TYPE_NIL for anything
+## declaring none, and for a call, whose answer nothing declares.
 static func _declared_type(holder: Variant, named: String) -> int:
-	if typeof(holder) != TYPE_OBJECT or not Paths.method_of(named).is_empty():
+	if not Paths.method_of(named).is_empty():
 		return TYPE_NIL
-	var object: Object = holder
-	for entry: Dictionary in object.get_property_list():
-		if str(entry.get("name", "")) == named:
-			return Read.as_int(entry.get("type", TYPE_NIL), TYPE_NIL)
-	return TYPE_NIL
+	return Values.slot_declared(holder, named)["type"]
 
 
 ## Waits until something under [param node_path] has [param said] written on it.
@@ -331,26 +375,15 @@ func _anything_says(node_path: String, said: String, include_hidden: bool) -> bo
 	return false
 
 
-func _signal_arity(node: Node, signal_name: String) -> int:
-	for entry: Dictionary in node.get_signal_list():
-		if entry.get("name", "") == signal_name:
-			var declared: Array = entry.get("args", [])
-			return declared.size()
-	return 0
-
-
 ## Remembers that a signal fired and what it carried, for a wait that polls rather than
-## awaits the signal directly, so the wait can also give up. The handler accepts up to five
-## arguments, which covers every signal the engine declares, and records as many as the signal
-## has.
+## awaits the signal directly, so the wait can also give up. Takes any number of arguments: a
+## handler of five fixed ones covered the engine's signals, and a game's own signal with six was
+## never delivered to it, so the wait ran out and said the signal had not fired.
 class SignalCatcher:
 	extends RefCounted
 	var fired: bool = false
-	var arity: int = 0
 	var args: Array = []
 
-	func _on_fired(
-		a: Variant = null, b: Variant = null, c: Variant = null, d: Variant = null, e: Variant = null
-	) -> void:
+	func _on_fired(...carried: Array) -> void:
 		fired = true
-		args = [a, b, c, d, e].slice(0, mini(arity, 5))
+		args = carried

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

@@ -53,6 +53,9 @@ const LIST_TYPES: Array[int] = [
 # type it wanted.
 const SERIALISERS: Dictionary = {
 	TYPE_NIL: "_serialize_nil",
+	TYPE_FLOAT: "_serialize_float",
+	TYPE_PACKED_FLOAT32_ARRAY: "_serialize_floats",
+	TYPE_PACKED_FLOAT64_ARRAY: "_serialize_floats",
 	TYPE_VECTOR2: "_serialize_vector2",
 	TYPE_VECTOR2I: "_serialize_vector2i",
 	TYPE_VECTOR3: "_serialize_vector3",
@@ -105,6 +108,8 @@ const BUILDERS: Dictionary = {
 	"Color": "_build_color",
 	"NodePath": "_build_node_path",
 	"PackedByteArray": "_build_bytes",
+	"float": "_build_float",
+	"Dictionary": "_build_dictionary",
 }
 
 # What each tag has to carry before it is built. A tag naming a type whose keys are not there is a
@@ -130,6 +135,8 @@ const REQUIRED: Dictionary = {
 	"Color": [["r", "g", "b"]],
 	"NodePath": [["path"]],
 	"PackedByteArray": [["base64"]],
+	"float": [["value"]],
+	"Dictionary": [["entries"]],
 }
 
 
@@ -145,7 +152,58 @@ func serialize_value(value: Variant) -> Variant:
 	if typeof(value) == TYPE_OBJECT and not is_instance_valid(value):
 		return null
 	var serialiser: String = SERIALISERS.get(typeof(value), "")
-	return call(serialiser, value) if not serialiser.is_empty() else value
+	if serialiser.is_empty():
+		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)
+
+
+# [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:
+	if carried is float:
+		var number: float = carried
+		return _serialize_float(number)
+	if carried is Dictionary:
+		var fields: Dictionary = carried
+		var tagged: Dictionary = {}
+		for key: Variant in fields:
+			tagged[key] = _finite(fields[key])
+		return tagged
+	if carried is Array:
+		var items: Array = carried
+		var tagged_items: Array = []
+		for item: Variant in items:
+			tagged_items.append(_finite(item))
+		return tagged_items
+	return carried
+
+
+func _serialize_float(value: float) -> Variant:
+	if is_finite(value):
+		return value
+	return {"_type": "float", "value": "nan" if is_nan(value) else ("inf" if value > 0 else "-inf")}
+
+
+# A packed float array stays the JSON list it is unless something in it has no JSON spelling.
+func _serialize_floats(value: Variant) -> Variant:
+	var numbers: Array = []
+	if value is PackedFloat32Array:
+		var single: PackedFloat32Array = value
+		numbers = Array(single)
+	else:
+		var double: PackedFloat64Array = value
+		numbers = Array(double)
+	for number: float in numbers:
+		if not is_finite(number):
+			var items: Array = []
+			for each: float in numbers:
+				items.append(_serialize_float(each))
+			return items
+	return value
 
 
 # Rebuilds a Godot value from the shape serialize_value gave it.
@@ -181,9 +239,27 @@ func deserialize_value(value: Variant) -> Variant:
 	var needed: Array = REQUIRED.get(tag, [])
 	if builder.is_empty() or not _carries(fields, needed):
 		return fields
+	if tag == "float" and str(fields["value"]) not in ["inf", "-inf", "nan"]:
+		return fields
+	if tag == "Dictionary" and not pairs(fields["entries"]):
+		return fields
 	return call(builder, fields)
 
 
+## Whether [param entries] is a list of [key, value] pairs, as a Dictionary tag carries them.
+static func pairs(entries: Variant) -> bool:
+	if not entries is Array:
+		return false
+	var listed: Array = entries
+	for entry: Variant in listed:
+		if not entry is Array:
+			return false
+		var pair: Array = entry
+		if pair.size() != 2:
+			return false
+	return true
+
+
 ## Whether two values can be compared without the comparison itself failing.
 ##
 ## GDScript's `==` is not total. An Object against a String is a hard error rather than false, and
@@ -193,16 +269,19 @@ func deserialize_value(value: Variant) -> Variant:
 ## nothing anywhere naming the argument that did it. A wrong argument costs a refusal, never the
 ## session's game.
 ##
-## Only an object is special. Every other pair the engine answers, false where they differ, and
-## refusing those would refuse calls that work: an int against a float is the same number to a
-## caller waiting for 1 on a property holding 1.0.
+## Measured on 4.7.2 over every pair of built-in types: two values of different types compare only
+## as an int against a float, a String against a StringName, or anything against null. Every other
+## pair is that error, a word against a number as much as an object against a word, and so is a bool
+## against an int and a NodePath against a String. An int against a float is kept because it is the
+## same number to a caller waiting for 1 on a property holding 1.0.
 static func comparable(one: Variant, other: Variant) -> bool:
 	var left: int = typeof(one)
 	var right: int = typeof(other)
-	if left != TYPE_OBJECT and right != TYPE_OBJECT:
+	if left == right or left == TYPE_NIL or right == TYPE_NIL:
 		return true
-	# An object compares with another object and with null. Anything else is the error above.
-	return (left == TYPE_OBJECT or left == TYPE_NIL) and (right == TYPE_OBJECT or right == TYPE_NIL)
+	var numbers: Array[int] = [TYPE_INT, TYPE_FLOAT]
+	var texts: Array[int] = [TYPE_STRING, TYPE_STRING_NAME]
+	return (left in numbers and right in numbers) or (left in texts and right in texts)
 
 
 ## Whether [param value] can be given to something declared as [param type] without damage.
@@ -400,7 +479,16 @@ func _serialize_signal(value: Signal) -> Dictionary:
 	return described
 
 
+## A dictionary keyed by text as itself, and any other as its entries. JSON keys are text, so an
+## int or Vector2 key was answered as its text, and a dictionary read and written back had its keys
+## replaced by words: `{1: "a"}` came back as `{"1": "a"}`.
 func _serialize_dictionary(value: Dictionary) -> Dictionary:
+	var texts: bool = value.keys().all(func(key: Variant) -> bool: return key is String or key is StringName)
+	if not texts:
+		var entries: Array = []
+		for key: Variant in value:
+			entries.append([serialize_value(key), serialize_value(value[key])])
+		return {"_type": "Dictionary", "entries": entries}
 	var serialised: Dictionary = {}
 	for key: Variant in value:
 		serialised[str(key)] = serialize_value(value[key])
@@ -621,6 +709,27 @@ func _build_bytes(fields: Dictionary) -> PackedByteArray:
 	return Marshalls.base64_to_raw(str(fields.get("base64", "")))
 
 
+func _build_float(fields: Dictionary) -> float:
+	return Read.as_float(fields)
+
+
+## The entries of a dictionary whose keys are not all text. JSON carries every number as a float,
+## and a dictionary keys 1.0 apart from 1, so a whole-number key is built as an int: the key a
+## game uses far more often, and one JSON cannot tell from the float.
+func _build_dictionary(fields: Dictionary) -> Dictionary:
+	var built: Dictionary = {}
+	var entries: Array = fields["entries"]
+	for entry: Variant in entries:
+		var pair: Array = entry
+		var key: Variant = deserialize_value(pair[0])
+		if key is float:
+			var number: float = key
+			if is_finite(number) and number == floorf(number):
+				key = int(number)
+		built[key] = deserialize_value(pair[1])
+	return built
+
+
 ## One component of a compound value, as the type its constructor wants.
 ##
 ## Their own functions because a constructor refuses a Variant under `unsafe_call_argument`, and

package/build/godot/operations/audio_buses.gd

@@ -20,17 +20,28 @@ func create_audio_bus(params: Dictionary) -> Dictionary:
 	var parent_idx: int = Read.as_int(params.get("parent_bus_index", 0))
 	if parent_idx < 0 or parent_idx >= AudioServer.bus_count:
 		return _log.failure("No bus at index " + str(parent_idx))
-
-	AudioServer.add_bus(parent_idx + 1)
-	var new_idx: int = AudioServer.bus_count - 1
+	# Sends are by name, so a second bus with one would leave every send to it meaning either.
+	var existing: int = AudioServer.get_bus_index(bus_name)
+	if existing != -1:
+		return _log.failure("A bus named " + bus_name + " already exists, at index " + str(existing))
+
+	# Right after the bus it sends to, because a bus can only send to one before it. The engine
+	# inserts there and moves every later bus down one, so the new bus is at that index: taking the
+	# last index named and rewired whichever bus had been last, and answered with it.
+	var new_idx: int = parent_idx + 1
+	AudioServer.add_bus(new_idx)
 	AudioServer.set_bus_name(new_idx, bus_name)
-	if parent_idx > 0:
-		AudioServer.set_bus_send(new_idx, AudioServer.get_bus_name(parent_idx))
+	AudioServer.set_bus_send(new_idx, AudioServer.get_bus_name(parent_idx))
 
 	var layout: String = _save_layout()
 	if layout.is_empty():
 		return {}
-	return {"bus": _bus(new_idx), "layout": layout}
+	# Every bus, because the ones after the new one have moved and a caller holding their old
+	# indices would address the wrong bus next.
+	var buses: Array[Dictionary] = []
+	for i: int in range(AudioServer.bus_count):
+		buses.append(_bus(i))
+	return {"bus": _bus(new_idx), "buses": buses, "layout": layout}
 
 
 func get_audio_buses(_params: Dictionary) -> Dictionary:
@@ -52,17 +63,42 @@ func set_audio_bus_effect(params: Dictionary) -> Dictionary:
 	if effect == null:
 		return _log.failure("Unknown effect type: " + effect_type)
 
-	# The slot has to exist before an effect can be placed at that index.
-	while AudioServer.get_bus_effect_count(bus_idx) <= effect_idx:
-		AudioServer.add_bus_effect(bus_idx, AudioEffectAmplify.new())
-
+	# The slot holds this effect afterwards: the one there is replaced, and one past the last is
+	# added. The engine's add inserts, so the effect in the slot was pushed along rather than
+	# replaced, and a slot past the end was reached by padding the bus with Amplify effects nobody
+	# asked for.
+	var count: int = AudioServer.get_bus_effect_count(bus_idx)
+	if effect_idx < 0 or effect_idx > count:
+		return _log.failure(
+			(
+				"Bus "
+				+ str(bus_idx)
+				+ " has "
+				+ str(count)
+				+ (" effect" if count == 1 else " effects")
+				+ ", so effect_index can be 0 to "
+				+ str(count)
+				+ ", where "
+				+ str(count)
+				+ " adds one after the last"
+			)
+		)
+	var replaced: String = ""
+	if effect_idx < count:
+		replaced = AudioServer.get_bus_effect(bus_idx, effect_idx).get_class()
+		AudioServer.remove_bus_effect(bus_idx, effect_idx)
 	AudioServer.add_bus_effect(bus_idx, effect, effect_idx)
 	AudioServer.set_bus_effect_enabled(bus_idx, effect_idx, enabled)
 
 	var layout: String = _save_layout()
 	if layout.is_empty():
 		return {}
-	return {"bus": _bus(bus_idx), "effect_index": effect_idx, "effect_type": effect_type, "layout": layout}
+	var answer: Dictionary = {
+		"bus": _bus(bus_idx), "effect_index": effect_idx, "effect_type": effect.get_class(), "layout": layout
+	}
+	if not replaced.is_empty():
+		answer["replaced"] = replaced
+	return answer
 
 
 func set_audio_bus_volume(params: Dictionary) -> Dictionary: