gdharness 1.3.41 → 1.3.43

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

@@ -1,5 +1,4 @@
 extends RefCounted
-
 ## Godot values as JSON can carry them, and JSON back into the values the engine wants.
 ##
 ## This file is the one beside the operations, and `bun run sync:gd` copies it into each addon,
@@ -10,17 +9,14 @@ extends RefCounted
 
 const GdhRead = preload("reading.gd")
 const GdhShapes = preload("value_shapes.gd")
-
 # What the engine carries from one to another without complaint, which is what a value written to a
 # property or handed to a parameter may arrive as. Numbers include bool because the engine counts it
 # as one, and the three text types are one string wearing three hats.
 const NUMBERS: Array[int] = [TYPE_BOOL, TYPE_INT, TYPE_FLOAT]
 const TEXTS: Array[int] = [TYPE_STRING, TYPE_STRING_NAME, TYPE_NODE_PATH]
-
 # 2^53. A JSON number is a double, and every whole number below this one in size has a double of
 # its own; from here on two or more share each double, so one arriving tells nobody which was sent.
-const EXACT: int = 9007199254740992
-
+const EXACT: int = 9_007_199_254_740_992
 # The types that cross as a plain JSON list and have to be built back into themselves. A list is
 # what a caller can write by hand and what the serialiser answers with, and the parameter or
 # property being written is the only thing that knows which of these it wanted.
@@ -35,7 +31,6 @@ const LIST_TYPES: Array[int] = [
 	TYPE_PACKED_VECTOR4_ARRAY,
 	TYPE_PACKED_COLOR_ARRAY,
 ]
-
 # What each Godot type becomes on the wire, as one table you can read rather than an order you
 # have to trust. Keyed on typeof() rather than written as a chain of `is` tests, because the
 # order mattered: Resource had to be tested before Object or every resource came back as a bare
@@ -92,7 +87,6 @@ const SERIALISERS: Dictionary = {
 	TYPE_PACKED_VECTOR4_ARRAY: "_serialize_vector4s",
 	TYPE_PACKED_COLOR_ARRAY: "_serialize_colors",
 }
-
 # What each tag builds back into. The other half of the table above, and separate from it because
 # they are keyed differently: one by the type of a value in hand, the other by the name in a
 # dictionary that arrived from somewhere else.
@@ -144,7 +138,11 @@ func serialize_value(value: Variant) -> Variant:
 	# The fixed shapes carry their components as bare floats, so an infinite one in a Vector2 is
 	# 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))
+	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
@@ -172,7 +170,10 @@ func _finite(carried: Variant, single: bool = false) -> Variant:
 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")}
+	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.
@@ -400,8 +401,9 @@ func fitted(value: Variant, type: int) -> Variant:
 	var simple: Array[int] = [TYPE_BOOL, TYPE_INT, TYPE_FLOAT, TYPE_STRING]
 	if not simple.has(type) or not simple.has(typeof(rebuilt)):
 		return rebuilt
-	# A number or a truth value stays as sent where text is wanted, for the refusal to name. Converted,
-	# 1 arrived as the double it is in JSON and was saved as "1.0", which is not the text anyone sends.
+	# A number or a truth value stays as sent where text is wanted, for the refusal to name.
+	# Converted, 1 arrived as the double it is in JSON and was saved as "1.0", which is not the text
+	# anyone sends.
 	if type == TYPE_STRING and not rebuilt is String:
 		return rebuilt
 
@@ -426,9 +428,10 @@ func fitted(value: Variant, type: int) -> Variant:
 
 
 ## Why [param given], meant for an int, may not be the number that was sent, or "" when it is. A
-## JSON number is a double wherever it is read, so a whole number from 2^53 on arrives as the nearest
-## double to the one written: 9007199254740993 sent as a number arrives as 9007199254740992, and a
-## seed written that way would be stored as its neighbour with the answer saying it was written.
+## JSON number is a double wherever it is read, so a whole number from 2^53 on arrives as the
+## nearest double to the one written: 9007199254740993 sent as a number arrives as 9007199254740992,
+## and a seed written that way would be stored as its neighbour with the answer saying it was
+## written.
 static func inexact(given: Variant, type: int) -> String:
 	if type != TYPE_INT or (typeof(given) != TYPE_FLOAT and typeof(given) != TYPE_INT):
 		return ""
@@ -437,9 +440,9 @@ static func inexact(given: Variant, type: int) -> String:
 		return ""
 	return (
 		(
-			"%s is 2^53 or more, where a JSON number holds a whole number only to the nearest double,"
-			+ ' so it may not be the number sent: send the digits as {"_type": "int", "value": "..."}'
-			+ ", the form a read answers with"
+			"%s is 2^53 or more, where a JSON number holds a whole number only to the nearest "
+			+ 'double, so it may not be the number sent: send the digits as {"_type": "int", '
+			+ '"value": "..."}, the form a read answers with'
 		)
 		% String.num(number, 0)
 	)
@@ -450,51 +453,59 @@ func _serialize_nil(_value: Variant) -> Variant:
 
 
 func _serialize_vector2(value: Vector2) -> Dictionary:
-	return {"x": value.x, "y": value.y, "_type": "Vector2"}
+	return { "x": value.x, "y": value.y, "_type": "Vector2" }
 
 
 func _serialize_vector2i(value: Vector2i) -> Dictionary:
-	return {"x": value.x, "y": value.y, "_type": "Vector2i"}
+	return { "x": value.x, "y": value.y, "_type": "Vector2i" }
 
 
 func _serialize_vector3(value: Vector3) -> Dictionary:
-	return {"x": value.x, "y": value.y, "z": value.z, "_type": "Vector3"}
+	return { "x": value.x, "y": value.y, "z": value.z, "_type": "Vector3" }
 
 
 func _serialize_vector3i(value: Vector3i) -> Dictionary:
-	return {"x": value.x, "y": value.y, "z": value.z, "_type": "Vector3i"}
+	return { "x": value.x, "y": value.y, "z": value.z, "_type": "Vector3i" }
 
 
 func _serialize_vector4(value: Vector4) -> Dictionary:
-	return {"x": value.x, "y": value.y, "z": value.z, "w": value.w, "_type": "Vector4"}
+	return { "x": value.x, "y": value.y, "z": value.z, "w": value.w, "_type": "Vector4" }
 
 
 func _serialize_vector4i(value: Vector4i) -> Dictionary:
-	return {"x": value.x, "y": value.y, "z": value.z, "w": value.w, "_type": "Vector4i"}
+	return { "x": value.x, "y": value.y, "z": value.z, "w": value.w, "_type": "Vector4i" }
 
 
 func _serialize_rect2(value: Rect2) -> Dictionary:
 	return {
-		"position": serialize_value(value.position), "size": serialize_value(value.size), "_type": "Rect2"
+		"position": serialize_value(value.position),
+		"size": serialize_value(value.size),
+		"_type": "Rect2",
 	}
 
 
 func _serialize_rect2i(value: Rect2i) -> Dictionary:
 	return {
-		"position": serialize_value(value.position), "size": serialize_value(value.size), "_type": "Rect2i"
+		"position": serialize_value(value.position),
+		"size": serialize_value(value.size),
+		"_type": "Rect2i",
 	}
 
 
 func _serialize_plane(value: Plane) -> Dictionary:
-	return {"normal": serialize_value(value.normal), "d": value.d, "_type": "Plane"}
+	return { "normal": serialize_value(value.normal), "d": value.d, "_type": "Plane" }
 
 
 func _serialize_quaternion(value: Quaternion) -> Dictionary:
-	return {"x": value.x, "y": value.y, "z": value.z, "w": value.w, "_type": "Quaternion"}
+	return { "x": value.x, "y": value.y, "z": value.z, "w": value.w, "_type": "Quaternion" }
 
 
 func _serialize_aabb(value: AABB) -> Dictionary:
-	return {"position": serialize_value(value.position), "size": serialize_value(value.size), "_type": "AABB"}
+	return {
+		"position": serialize_value(value.position),
+		"size": serialize_value(value.size),
+		"_type": "AABB",
+	}
 
 
 func _serialize_basis(value: Basis) -> Dictionary:
@@ -502,7 +513,7 @@ func _serialize_basis(value: Basis) -> Dictionary:
 		"x": serialize_value(value.x),
 		"y": serialize_value(value.y),
 		"z": serialize_value(value.z),
-		"_type": "Basis"
+		"_type": "Basis",
 	}
 
 
@@ -511,13 +522,15 @@ func _serialize_transform2d(value: Transform2D) -> Dictionary:
 		"origin": serialize_value(value.origin),
 		"x": serialize_value(value.x),
 		"y": serialize_value(value.y),
-		"_type": "Transform2D"
+		"_type": "Transform2D",
 	}
 
 
 func _serialize_transform3d(value: Transform3D) -> Dictionary:
 	return {
-		"origin": serialize_value(value.origin), "basis": serialize_value(value.basis), "_type": "Transform3D"
+		"origin": serialize_value(value.origin),
+		"basis": serialize_value(value.basis),
+		"_type": "Transform3D",
 	}
 
 
@@ -527,22 +540,22 @@ func _serialize_projection(value: Projection) -> Dictionary:
 		"y": serialize_value(value.y),
 		"z": serialize_value(value.z),
 		"w": serialize_value(value.w),
-		"_type": "Projection"
+		"_type": "Projection",
 	}
 
 
 func _serialize_color(value: Color) -> Dictionary:
-	return {"r": value.r, "g": value.g, "b": value.b, "a": value.a, "_type": "Color"}
+	return { "r": value.r, "g": value.g, "b": value.b, "a": value.a, "_type": "Color" }
 
 
 func _serialize_node_path(value: NodePath) -> Dictionary:
-	return {"path": str(value), "_type": "NodePath"}
+	return { "path": str(value), "_type": "NodePath" }
 
 
 # By its id, which is all an RID is from outside the server holding it, and which builds it back:
 # a viewport's RID read off one call is what RenderingServer's render timing takes in the next.
 func _serialize_rid(value: RID) -> Dictionary:
-	return {"id": _serialize_int(value.get_id()), "_type": "RID"}
+	return { "id": _serialize_int(value.get_id()), "_type": "RID" }
 
 
 # A whole number from 2^53 on as its digits, because JSON numbers are doubles on the server's side
@@ -552,7 +565,7 @@ func _serialize_rid(value: RID) -> Dictionary:
 func _serialize_int(value: int) -> Variant:
 	if value > -EXACT and value < EXACT:
 		return value
-	return {"_type": "int", "value": str(value)}
+	return { "_type": "int", "value": str(value) }
 
 
 # A packed list of 64-bit numbers stays the JSON list it is unless something in it is too large for
@@ -570,7 +583,7 @@ func _serialize_ints(value: PackedInt64Array) -> Variant:
 # A bound method, said in the terms a caller could act on: what it is on, and what it is called.
 # It cannot be rebuilt from here, and saying so is the answer rather than a silent null.
 func _serialize_callable(value: Callable) -> Dictionary:
-	var described: Dictionary = {"method": str(value.get_method()), "_type": "Callable"}
+	var described: Dictionary = { "method": str(value.get_method()), "_type": "Callable" }
 	var holder: Object = value.get_object()
 	if holder != null:
 		described["object"] = _describe_object(holder)
@@ -578,7 +591,7 @@ func _serialize_callable(value: Callable) -> Dictionary:
 
 
 func _serialize_signal(value: Signal) -> Dictionary:
-	var described: Dictionary = {"name": str(value.get_name()), "_type": "Signal"}
+	var described: Dictionary = { "name": str(value.get_name()), "_type": "Signal" }
 	var holder: Object = value.get_object()
 	if holder != null:
 		described["object"] = _describe_object(holder)
@@ -589,12 +602,14 @@ func _serialize_signal(value: Signal) -> Dictionary:
 ## 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)
+	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}
+		return { "_type": "Dictionary", "entries": entries }
 	var serialised: Dictionary = {}
 	for key: Variant in value:
 		serialised[str(key)] = serialize_value(value[key])
@@ -612,7 +627,7 @@ func _serialize_array(value: Array) -> Array:
 # TileMapLayer with nothing painted yet, so a read of one carried an engine error in its answer.
 func _serialize_bytes(value: PackedByteArray) -> Dictionary:
 	var text: String = "" if value.is_empty() else Marshalls.raw_to_base64(value)
-	return {"base64": text, "size": value.size(), "_type": "PackedByteArray"}
+	return { "base64": text, "size": value.size(), "_type": "PackedByteArray" }
 
 
 # The packed vector and colour arrays, each element serialised the way one of them on its own is.
@@ -660,7 +675,7 @@ func _serialize_object(value: Object) -> Variant:
 		if resource.resource_path.is_empty() or resource.resource_path.contains("::"):
 			return _describe_built_in(resource)
 		var filed: Dictionary = {
-			"path": resource.resource_path, "class": resource.get_class(), "_type": "Resource"
+			"path": resource.resource_path, "class": resource.get_class(), "_type": "Resource",
 		}
 		# The engine class of a resource with a script is the one its script extends, so a Stats
 		# file read as a Resource and nothing said it was a Stats.
@@ -673,7 +688,7 @@ func _serialize_object(value: Object) -> Variant:
 	if value is Node:
 		var node: Node = value
 		if node.is_inside_tree():
-			return {"path": str(node.get_path()), "class": node.get_class(), "_type": "Node"}
+			return { "path": str(node.get_path()), "class": node.get_class(), "_type": "Node" }
 	return _describe_object(value)
 
 
@@ -683,16 +698,16 @@ func _serialize_object(value: Object) -> Variant:
 ## written back.
 func _describe_built_in(resource: Resource) -> Dictionary:
 	if _describing.has(resource):
-		return {"class": resource.get_class(), "_type": "Resource"}
+		return { "class": resource.get_class(), "_type": "Resource" }
 	_describing.append(resource)
-	var described: Dictionary = {"_type": resource.get_class()}
+	var described: Dictionary = { "_type": resource.get_class() }
 	var attached: Variant = resource.get_script()
 	var script: Script = null
 	if attached is Script:
 		script = attached
 		# 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.
+		# 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:
@@ -741,11 +756,17 @@ static func _fresh(script: Script) -> Object:
 ## away from its default. As a bare resource it was its class and nothing else, so an input action
 ## read back from project.godot could not say whether it was bound to Space or to a joypad button.
 func _describe_input_event(event: InputEvent) -> Dictionary:
-	var described: Dictionary = {"class": event.get_class(), "_type": "Resource", "text": event.as_text()}
+	var described: Dictionary = {
+		"class": event.get_class(), "_type": "Resource", "text": event.as_text(),
+	}
 	for property: Dictionary in event.get_property_list():
 		var usage: int = property.get("usage", 0)
 		var name: String = str(property.get("name", ""))
-		if not (usage & PROPERTY_USAGE_STORAGE) or name.begins_with("resource_") or name == "script":
+		if (
+			not (usage & PROPERTY_USAGE_STORAGE)
+			or name.begins_with("resource_")
+			or name == "script"
+		):
 			continue
 		var held: Variant = event.get(name)
 		if held == ClassDB.class_get_property_default_value(event.get_class(), name):
@@ -764,7 +785,7 @@ func _describe_input_event(event: InputEvent) -> Dictionary:
 ## different per object. None of it is invented: every field is left out when there is nothing to
 ## put in it, because a key holding "" is a worse answer than a key that is not there.
 func _describe_object(value: Object) -> Dictionary:
-	var described: Dictionary = {"class": value.get_class(), "_type": "Object"}
+	var described: Dictionary = { "class": value.get_class(), "_type": "Object" }
 	# Asked as a Variant and narrowed, because get_script answers one and an object without a
 	# script answers null: casting that to Script is the unsafe cast the engine refuses to compile.
 	var attached: Variant = value.get_script()
@@ -892,7 +913,10 @@ func _build_transform3d(fields: Dictionary) -> Transform3D:
 
 func _build_projection(fields: Dictionary) -> Projection:
 	return Projection(
-		_vector4_at(fields, "x"), _vector4_at(fields, "y"), _vector4_at(fields, "z"), _vector4_at(fields, "w")
+		_vector4_at(fields, "x"),
+		_vector4_at(fields, "y"),
+		_vector4_at(fields, "z"),
+		_vector4_at(fields, "w")
 	)
 
 

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

@@ -1,12 +1,10 @@
 extends RefCounted
-
 ## How each engine type built from fields is written: the fields it needs, the ones it reads when
 ## they are there, and what a refusal says about a value that is not one.
 ##
 ## This file is the one beside the operations, and `bun run sync:gd` copies it into each addon.
 
 const GdhRead = preload("reading.gd")
-
 ## The classes that store what the inspector shows, and a write takes, under other names: a Curve
 ## keeps its points as _data, numbers and modes in one list, and its range as _limits, where the
 ## inspector and resource_edit modify have point_count, point_0/position and min_value. A read
@@ -17,7 +15,6 @@ const STORED_APART: Dictionary[String, Array] = {
 	"Curve3D": ["_data"],
 }
 const HEADINGS: int = PROPERTY_USAGE_CATEGORY | PROPERTY_USAGE_GROUP | PROPERTY_USAGE_SUBGROUP
-
 ## What each packed array holds, one value of which every element is fitted to.
 const PACKED_ELEMENTS: Dictionary = {
 	TYPE_PACKED_BYTE_ARRAY: TYPE_INT,
@@ -43,7 +40,6 @@ const LIST_TAGS: Dictionary = {
 	"PackedVector4Array": TYPE_PACKED_VECTOR4_ARRAY,
 	"PackedColorArray": TYPE_PACKED_COLOR_ARRAY,
 }
-
 # What each tag has to carry before it is built. A tag naming a type whose keys are not there is a
 # tag somebody wrote by mistake or wrote for a different shape, and building one out of defaults
 # answers with a Transform2D of zeros where the caller meant something else entirely. Unbuilt, it
@@ -254,7 +250,9 @@ static func remedy(value: Variant, type: int) -> String:
 	if shape.is_empty():
 		return ""
 	return (
-		_unread(value, type) + _no_number(value, type) + " A %s is sent as %s." % [type_string(type), shape]
+		_unread(value, type)
+		+ _no_number(value, type)
+		+ " A %s is sent as %s." % [type_string(type), shape]
 	)
 
 
@@ -288,7 +286,8 @@ static func _unread(value: Variant, type: int) -> String:
 		var _named: bool = named.append('"%s"' % key)
 	var fields_called: String = "field called" if named.size() == 1 else "fields called"
 	var note: String = (
-		" A %s has no %s %s, so the value is not read as one" % [tag, fields_called, " or ".join(named)]
+		" A %s has no %s %s, so the value is not read as one"
+		% [tag, fields_called, " or ".join(named)]
 	)
 	if left.has("type") and not fields.has("_type"):
 		return note + ': a value names its type under "_type".'

package/build/godot/addons/gdharness_tests/bench.gd

@@ -1,6 +1,5 @@
 class_name GdhBench
 extends RefCounted
-
 ## Work played a step a frame, for the script profiler. The engine sends the profiler what each
 ## frame called and holds names for only so many functions a frame, so work played inside one frame
 ## comes back with most of its functions unnamed; spread over frames, every step is named.
@@ -11,9 +10,9 @@ extends RefCounted
 ##         get_tree().quit()
 
 
-## Calls [param step] once a frame, up to [param most] times, and stops early when it returns
-## false. Answers how many steps ran under "steps", and under "ms_each" the wall-clock milliseconds a
-## step took on average, the step alone and not the frame around it.
+## Calls [param step] once a frame, up to [param most] times, and stops early when it returns false.
+## Answers how many steps ran under "steps", and under "ms_each" the wall-clock milliseconds a step
+## took on average, the step alone and not the frame around it.
 static func each_frame(tree: SceneTree, most: int, step: Callable) -> Dictionary:
 	var steps: int = 0
 	var spent_usec: int = 0
@@ -25,4 +24,4 @@ static func each_frame(tree: SceneTree, most: int, step: Callable) -> Dictionary
 		steps += 1
 		if going is bool and going == false:
 			break
-	return {"steps": steps, "ms_each": spent_usec / 1000.0 / maxf(1.0, float(steps))}
+	return { "steps": steps, "ms_each": spent_usec / 1000.0 / maxf(1.0, float(steps)) }

package/build/godot/addons/gdharness_tests/event.gd

@@ -34,7 +34,9 @@ static func wheel(at: Vector2, up: bool = true) -> InputEventMouseButton:
 
 ## The mouse moved to [param at] by [param moved], holding [param held], a mask of buttons such
 ## as MOUSE_BUTTON_MASK_LEFT for a drag.
-static func motion(at: Vector2, moved: Vector2 = Vector2.ZERO, held: int = 0) -> InputEventMouseMotion:
+static func motion(
+	at: Vector2, moved: Vector2 = Vector2.ZERO, held: int = 0
+) -> InputEventMouseMotion:
 	var made: InputEventMouseMotion = InputEventMouseMotion.new()
 	made.position = at
 	made.global_position = at
@@ -43,8 +45,8 @@ static func motion(at: Vector2, moved: Vector2 = Vector2.ZERO, held: int = 0) ->
 	return made
 
 
-## [param key_pressed] pressed, or released when [param pressed] is false. The key is set as both the
-## keycode and the physical keycode, so a binding to either matches it.
+## [param key_pressed] pressed, or released when [param pressed] is false. The key is set as both
+## the keycode and the physical keycode, so a binding to either matches it.
 static func key(key_pressed: Key, pressed: bool = true) -> InputEventKey:
 	var made: InputEventKey = InputEventKey.new()
 	made.keycode = key_pressed
@@ -72,8 +74,11 @@ static func axis(axis_moved: JoyAxis, value: float, device: int = 0) -> InputEve
 	return made
 
 
-## The action [param action_named] pressed at [param strength], or released when [param pressed] is false.
-static func action(action_named: StringName, pressed: bool = true, strength: float = 1.0) -> InputEventAction:
+## The action [param action_named] pressed at [param strength], or released when [param pressed] is
+## false.
+static func action(
+	action_named: StringName, pressed: bool = true, strength: float = 1.0
+) -> InputEventAction:
 	var made: InputEventAction = InputEventAction.new()
 	made.action = action_named
 	made.pressed = pressed

package/build/godot/addons/gdharness_tests/share.gd

@@ -6,10 +6,11 @@ extends RefCounted
 ## A bench whose run `i` depends on `i` alone (its seed worked out from the index, nothing carried
 ## from one run to the next) calls [method outcomes] for each arm with the number of runs and a
 ## callable playing run `i`. Run on its own, the scene plays every run here, as it always did. Under
-## `gdharness spread`, each worker engine plays every Nth run from its own index and leaves what each
-## run answered; then one more engine runs the scene to gather, and there [method outcomes] plays
-## nothing and answers every run's outcome, read back as the type it went in as. The bench folds them
-## in run order either way, so a spread table is the same table to the last digit, floats included.
+## `gdharness spread`, each worker engine plays every Nth run from its own index and leaves what
+## each run answered; then one more engine runs the scene to gather, and there [method outcomes]
+## plays nothing and answers every run's outcome, read back as the type it went in as. The bench
+## folds them in run order either way, so a spread table is the same table to the last digit, floats
+## included.
 ##
 ## An outcome is a plain value: a number, a string, a vector, or an array or dictionary of them. An
 ## object cannot be handed from one engine to another, so one is refused with an error.
@@ -18,7 +19,8 @@ extends RefCounted
 const SHARE: String = "--gdh-share="
 ## What it tells the engine gathering: how many workers left outcomes.
 const GATHER: String = "--gdh-share-gather="
-## Where the workers leave their outcomes, an absolute path, since each engine has its own `user://`.
+## Where the workers leave their outcomes, an absolute path, since each engine has its own
+## `user://`.
 const INTO: String = "--gdh-share-dir="
 ## What a worker prints as it goes, which `gdharness spread` reads to say how far each has got.
 const PROGRESS: String = "gdharness share: %s %d of %d runs"
@@ -67,7 +69,9 @@ static func dealt(runs: int) -> PackedInt32Array:
 static func outcomes(arm: String, runs: int, play: Callable) -> Array:
 	_learn()
 	if _arms.has(arm):
-		push_error("GdhShare: the arm %s was played twice in one run; give each arm its own name" % arm)
+		push_error(
+			"GdhShare: the arm %s was played twice in one run; give each arm its own name" % arm
+		)
 		return []
 	_arms[arm] = true
 	if gathering():
@@ -83,7 +87,10 @@ static func outcomes(arm: String, runs: int, play: Callable) -> Array:
 		if not wrong.is_empty():
 			push_error(
 				(
-					"GdhShare: run %d of %s answered %s, which cannot be handed from one engine to another"
+					(
+						"GdhShare: run %d of %s answered %s, which cannot be handed from one "
+						+ "engine to another"
+					)
 					% [run, arm, wrong]
 				)
 			)
@@ -109,7 +116,9 @@ static func added(
 	var total: Dictionary[String, int] = {}
 	for outcome: Variant in counted:
 		if not outcome is Dictionary:
-			push_error("GdhShare.added: an outcome is %s, not a dictionary" % type_string(typeof(outcome)))
+			push_error(
+				"GdhShare.added: an outcome is %s, not a dictionary" % type_string(typeof(outcome))
+			)
 			continue
 		var counts: Dictionary = outcome
 		for key: Variant in counts:
@@ -117,7 +126,10 @@ static func added(
 			var count: Variant = counts[key]
 			if not count is int:
 				push_error(
-					"GdhShare.added: %s is %s, not a whole number" % [named, type_string(typeof(count))]
+					(
+						"GdhShare.added: %s is %s, not a whole number"
+						% [named, type_string(typeof(count))]
+					)
 				)
 				continue
 			var now: int = count
@@ -133,10 +145,12 @@ static func added(
 ## Leaves one arm's outcomes, then the line saying so, which `gdharness spread` checks the share
 ## against; the outcomes first, so a line is never there without them.
 static func _leave(arm: String, runs: int, by_index: Dictionary[int, Variant]) -> void:
-	var left: Dictionary = {"arm": arm, "runs": runs, "outcomes": by_index}
-	if not _appended("worker-%d.bin" % _index, func(file: FileAccess) -> bool: return file.store_var(left)):
+	var left: Dictionary = { "arm": arm, "runs": runs, "outcomes": by_index }
+	if not _appended(
+		"worker-%d.bin" % _index, func(file: FileAccess) -> bool: return file.store_var(left)
+	):
 		return
-	var said: String = JSON.stringify({"arm": arm, "runs": runs, "played": by_index.size()})
+	var said: String = JSON.stringify({ "arm": arm, "runs": runs, "played": by_index.size() })
 	var _noted: bool = _appended(
 		"worker-%d.arms" % _index, func(file: FileAccess) -> bool: return file.store_line(said)
 	)
@@ -149,7 +163,9 @@ static func _appended(name: String, write: Callable) -> bool:
 		path, FileAccess.READ_WRITE if FileAccess.file_exists(path) else FileAccess.WRITE
 	)
 	if file == null:
-		push_error("GdhShare: cannot write %s: %s" % [path, error_string(FileAccess.get_open_error())])
+		push_error(
+			"GdhShare: cannot write %s: %s" % [path, error_string(FileAccess.get_open_error())]
+		)
 		return false
 	file.seek_end()
 	var wrote: bool = write.call(file)
@@ -168,8 +184,8 @@ static func _gathered(arm: String, runs: int) -> Array:
 		push_error(
 			(
 				(
-					"GdhShare: no worker played the arm %s, so this run went another way than theirs; "
-					+ "which arms a bench plays must depend on its command line alone"
+					"GdhShare: no worker played the arm %s, so this run went another way than "
+					+ "theirs; which arms a bench plays must depend on its command line alone"
 				)
 				% arm
 			)
@@ -190,7 +206,7 @@ static func _gathered(arm: String, runs: int) -> Array:
 			push_error("GdhShare: no worker played run %d of %s" % [run, arm])
 			return []
 		ordered.append(held[run])
-	var said: String = JSON.stringify({"arm": arm, "runs": runs, "played": runs})
+	var said: String = JSON.stringify({ "arm": arm, "runs": runs, "played": runs })
 	var _noted: bool = _appended(
 		"gathered.arms", func(file: FileAccess) -> bool: return file.store_line(said)
 	)
@@ -205,7 +221,9 @@ static func _read_workers() -> void:
 		var path: String = _directory.path_join("worker-%d.bin" % worker)
 		var file: FileAccess = FileAccess.open(path, FileAccess.READ)
 		if file == null:
-			_unread = "GdhShare: cannot read %s: %s" % [path, error_string(FileAccess.get_open_error())]
+			_unread = (
+				"GdhShare: cannot read %s: %s" % [path, error_string(FileAccess.get_open_error())]
+			)
 			return
 		while file.get_position() < file.get_length():
 			_unread = _took(file.get_var(), path)
@@ -260,7 +278,9 @@ static func _learn() -> void:
 		elif given.begins_with(INTO):
 			_directory = given.trim_prefix(INTO)
 	if (_index >= 0 or _gathering > 0) and _directory.is_empty():
-		push_error("GdhShare: a spread engine was given no %s<directory> to share outcomes in" % INTO)
+		push_error(
+			"GdhShare: a spread engine was given no %s<directory> to share outcomes in" % INTO
+		)
 
 
 ## What in [param value] cannot be written by one engine and read by another, or empty.

package/build/godot/addons/gdharness_tests/suites.gd

@@ -1,5 +1,4 @@
 extends Node
-
 ## gdUnit4 suites run inside a played scene, which the engine's script profiler sees and a script
 ## run with `-s` never does. `editor_run start` given `suites` plays this scene with
 ## [constant RUNNER] naming the runner `gdharness test` uses, where the server ships it, followed by
@@ -20,8 +19,9 @@ func _ready() -> void:
 		push_error(
 			(
 				(
-					"gdharness suites: no runner at '%s'. This scene is played by editor_run start with suites,"
-					+ " which names the runner after %s; it does nothing played any other way."
+					"gdharness suites: no runner at '%s'. This scene is played by editor_run start "
+					+ "with suites, which names the runner after %s; it does nothing played any "
+					+ "other way."
 				)
 				% [path, RUNNER]
 			)

package/build/godot/addons/gdharness_tests/wait.gd

@@ -10,7 +10,6 @@ extends RefCounted
 
 ## How long [method until] and [method still] wait by default, in milliseconds.
 const MOST_MS: int = 30000
-
 ## Frames in a row with no tween running before [method still] counts the tree as still. A layout
 ## often starts its slide a frame after the change that asks for it, so the frame straight after
 ## had no tween yet and passed for still.
@@ -28,7 +27,9 @@ static func until(tree: SceneTree, done: Callable, most_ms: int = MOST_MS) -> bo
 
 
 ## Whether the tree ran no tween for [param quiet_frames] frames in a row within [param most_ms].
-static func still(tree: SceneTree, quiet_frames: int = QUIET_FRAMES, most_ms: int = MOST_MS) -> bool:
+static func still(
+	tree: SceneTree, quiet_frames: int = QUIET_FRAMES, most_ms: int = MOST_MS
+) -> bool:
 	var began: int = Time.get_ticks_msec()
 	var quiet: int = 0
 	while quiet < quiet_frames: