gdharness 1.2.36 → 1.2.38

package/build/godot/addons/gdharness_editor/tools/resource_tools.gd

@@ -4,6 +4,7 @@ extends Node
 ## Resource files, shaders, tilesets and themes, written through the open editor.
 
 const FileReads = preload("../file_reads.gd")
+const HeadlessCheck = preload("../headless_check.gd")
 const PropertyValues = preload("../property_values.gd")
 const Read = preload("../reading.gd")
 const SceneFile = preload("../scene_file.gd")
@@ -118,9 +119,12 @@ func _load_theme(theme_path: String) -> Theme:
 ## Read back because a property can be set and still not be saved: one without storage, a
 ## script variable that is not exported. Both were answered as changed.
 func _save_checked(resource: Resource, path: String, names: Array, previous: Variant) -> String:
-	var saving: Error = ResourceSaver.save(resource, path)
+	var saving: Error = SceneFile.save_keeping_uid(resource, path)
 	if saving != OK:
 		return "Failed to save %s: %s" % [path, error_string(saving)]
+	var unkept: String = _unkept_headless(resource, path, names, previous)
+	if not unkept.is_empty():
+		return "Nothing was written: " + unkept + HeadlessCheck.put_back(path, previous)
 	var loaded: Resource = ResourceLoader.load(path, "", ResourceLoader.CACHE_MODE_IGNORE)
 	var lost: String = ""
 	if loaded == null:
@@ -141,36 +145,85 @@ func _save_checked(resource: Resource, path: String, names: Array, previous: Var
 	if lost.is_empty():
 		_written(path)
 		return ""
+	return lost + HeadlessCheck.put_back(path, previous)
+
+
+## Outside the editor, puts back in the file just saved at [param path] what a script that is not a
+## tool changed and the call did not ask for, [param names] being what it asked for, and answers ""
+## or why that did not hold. See [HeadlessCheck].
+func _unkept_headless(resource: Resource, path: String, names: Array, previous: Variant) -> String:
+	if Engine.is_editor_hint():
+		return ""
+	var script: Script = resource.get_script()
+	var scripted: bool = script != null and not script.is_tool()
+	if not path.ends_with(".tres"):
+		if scripted or HeadlessCheck.holds_scripted_embedded(resource, {}):
+			return (
+				(
+					(
+						"%s is a binary 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
+				)
+				+ HeadlessCheck.REMEDY
+			)
+		return ""
+	var before: String = ""
 	if previous is PackedByteArray:
 		var bytes: PackedByteArray = previous
-		var file: FileAccess = FileAccess.open(path, FileAccess.WRITE)
-		if file == null or not file.store_buffer(bytes):
-			return lost + " Putting the file back as it was failed too."
-	elif DirAccess.remove_absolute(ProjectSettings.globalize_path(path)) != OK:
-		return lost + " Removing the file it wrote failed too."
-	return lost
+		before = bytes.get_string_from_utf8()
+	var asked: Dictionary = {"script": true}
+	var reached: Dictionary = {}
+	for key: Variant in names:
+		var property: String = str(key)
+		asked[property] = true
+		asked[property.get_slice(":", 0)] = true
+		reached.merge(HeadlessCheck.reached(resource, property))
+	return HeadlessCheck.settle_saved(
+		path,
+		before,
+		HeadlessCheck.stored(resource).values(),
+		resource if scripted else null,
+		asked,
+		reached,
+		func() -> Error: return SceneFile.save_keeping_uid(resource, path)
+	)
 
 
 func create_resource(args: Dictionary) -> Dictionary:
 	var res_path: String = _ensure_res_path(str(args.get("resourcePath", "")))
 	var resource_type: String = str(args.get("resourceType", "Resource"))
+	var asked_type: String = resource_type
 	if res_path == "res://":
 		return {"ok": false, "error": "resourcePath is required"}
 	var taken: String = _taken(res_path, "resource_edit op=create")
 	if not taken.is_empty():
 		return {"ok": false, "error": taken}
 
-	if (
-		not ClassDB.class_exists(resource_type)
-		or not ClassDB.is_parent_class(resource_type, "Resource")
-		or not ClassDB.can_instantiate(resource_type)
-	):
+	var script_path: String = str(args.get("script", ""))
+	var made: Dictionary = SceneFile.made_as(
+		resource_type, "" if script_path == "" else _ensure_res_path(script_path), "Resource", "resourceType"
+	)
+	if made.has("error"):
+		return {"ok": false, "error": made["error"]}
+	resource_type = str(made["type"])
+	script_path = str(made["script"])
+	if not ClassDB.class_exists(resource_type):
+		return {
+			"ok": false,
+			"error":
+			(
+				"%s is neither an engine class nor a class_name a script in this project declares."
+				% resource_type
+			)
+		}
+	if not ClassDB.is_parent_class(resource_type, "Resource") or not ClassDB.can_instantiate(resource_type):
 		return {"ok": false, "error": "%s is not a resource class that can be created." % resource_type}
 	var resource: Resource = ClassDB.instantiate(resource_type)
 
 	# A script that did not load was skipped, and a plain resource was saved in place of the custom
 	# one asked for.
-	var script_path: String = str(args.get("script", ""))
 	if script_path != "":
 		var script_file: String = _ensure_res_path(script_path)
 		var script: Script = load(script_file) as Script
@@ -198,7 +251,7 @@ func create_resource(args: Dictionary) -> Dictionary:
 	var failed: String = _save_checked(resource, res_path, properties.keys(), null)
 	if not failed.is_empty():
 		return {"ok": false, "error": failed}
-	return {"ok": true, "resourcePath": res_path, "resourceType": resource.get_class()}
+	return {"ok": true, "resourcePath": res_path, "resourceType": asked_type}
 
 
 func modify_resource(args: Dictionary) -> Dictionary:
@@ -321,7 +374,7 @@ func create_tileset(args: Dictionary) -> Dictionary:
 	var folder: String = SceneFile.make_folder_for(tileset_path)
 	if not folder.is_empty():
 		return {"ok": false, "error": folder}
-	var saving: Error = ResourceSaver.save(tileset, tileset_path)
+	var saving: Error = SceneFile.save_keeping_uid(tileset, tileset_path)
 	if saving != OK:
 		return {"ok": false, "error": "Failed to save %s: %s" % [tileset_path, error_string(saving)]}
 
@@ -443,6 +496,7 @@ func set_tilemap_cells(args: Dictionary) -> Dictionary:
 	# reports placing tiles and a scene that shows none.
 	var tile_set: TileSet = layered.tile_set if layered != null else single.tile_set
 
+	scene.asked(node, ["layer_%d/tile_data" % layer if layered != null else "tile_map_data"])
 	var wanted: Array = []
 	for index: int in placed.size():
 		var cell: Array = _cell(placed[index], index, tile_set)
@@ -621,6 +675,19 @@ func _cell_at(node: Node, layer: int, at: Vector2i) -> Array:
 	return []
 
 
+## Saves [param theme] over [param theme_path] with [param item] changed, answering "" or why not.
+func _save_theme(theme: Theme, theme_path: String, item: String) -> String:
+	var previous: PackedByteArray = FileAccess.get_file_as_bytes(theme_path)
+	var saving: Error = SceneFile.save_keeping_uid(theme, theme_path)
+	if saving != OK:
+		return "Failed to save %s: %s" % [theme_path, error_string(saving)]
+	var unkept: String = _unkept_headless(theme, theme_path, [item], previous)
+	if not unkept.is_empty():
+		return "Nothing was written: " + unkept + HeadlessCheck.put_back(theme_path, previous)
+	_written(theme_path)
+	return ""
+
+
 func set_theme_color(args: Dictionary) -> Dictionary:
 	var theme_path: String = _ensure_res_path(str(args.get("themePath", "")))
 	if theme_path == "res://":
@@ -644,11 +711,9 @@ func set_theme_color(args: Dictionary) -> Dictionary:
 	)
 	theme.set_color(color_name, control_type, color)
 
-	var save_result: Error = ResourceSaver.save(theme, theme_path)
-	if save_result != OK:
-		return {"ok": false, "error": "Failed to save %s: %s" % [theme_path, error_string(save_result)]}
-
-	_written(theme_path)
+	var unsaved: String = _save_theme(theme, theme_path, "%s/colors/%s" % [control_type, color_name])
+	if not unsaved.is_empty():
+		return {"ok": false, "error": unsaved}
 
 	var saved: Theme = _load_theme(theme_path)
 	if saved == null or not saved.has_color(color_name, control_type):
@@ -680,11 +745,9 @@ func set_theme_font_size(args: Dictionary) -> Dictionary:
 
 	theme.set_font_size(font_size_name, control_type, Read.as_int(args.get("size", 0)))
 
-	var save_result: Error = ResourceSaver.save(theme, theme_path)
-	if save_result != OK:
-		return {"ok": false, "error": "Failed to save %s: %s" % [theme_path, error_string(save_result)]}
-
-	_written(theme_path)
+	var unsaved: String = _save_theme(theme, theme_path, "%s/font_sizes/%s" % [control_type, font_size_name])
+	if not unsaved.is_empty():
+		return {"ok": false, "error": unsaved}
 
 	var saved: Theme = _load_theme(theme_path)
 	if saved == null or not saved.has_font_size(font_size_name, control_type):

package/build/godot/addons/gdharness_editor/tools/scene_tools.gd

@@ -90,7 +90,7 @@ func _missing_on(node: Node, missing: String) -> String:
 	if probe.reload() == OK:
 		return missing
 	return (
-		"%s. Its script, %s, does not compile, so the editor knows none of what it declares."
+		"%s. Its script, %s, does not compile, so none of what it declares is known here."
 		% [missing, script.resource_path]
 	)
 
@@ -186,6 +186,17 @@ func create_scene(args: Dictionary) -> Dictionary:
 		return {"ok": false, "error": "Missing scenePath"}
 	if not scene_path.ends_with(".tscn"):
 		scene_path += ".tscn"
+	var asked_type: String = root_node_type
+	var made: Dictionary = SceneFile.made_as(
+		root_node_type,
+		"" if script_path.is_empty() else _to_scene_res_path(project_path, script_path),
+		"Node",
+		"rootNodeType"
+	)
+	if made.has("error"):
+		return {"ok": false, "error": made["error"]}
+	root_node_type = str(made["type"])
+	script_path = str(made["script"])
 	# A class that is not a node went into a Node variable, which is a runtime error the caller
 	# heard about only as "Invalid tool result".
 	if not ClassDB.class_exists(root_node_type) or not ClassDB.is_parent_class(root_node_type, "Node"):
@@ -213,6 +224,10 @@ func create_scene(args: Dictionary) -> Dictionary:
 
 	var root: Node = ClassDB.instantiate(root_node_type)
 	root.name = root_node_name
+	var scene: SceneFile = SceneFile.new()
+	scene.root = root
+	scene.path = scene_path
+	scene.asked(root, ["script"])
 
 	if not script_path.is_empty():
 		var full_script_path: String = _to_scene_res_path(project_path, script_path)
@@ -233,21 +248,19 @@ func create_scene(args: Dictionary) -> Dictionary:
 				"%s extends %s, so it cannot be on a %s root." % [full_script_path, base, root_node_type]
 			}
 		root.set_script(script)
+		# Named again, since a headless engine runs the script's _init as it is attached, and a node's
+		# name is no property the write compares.
+		root.name = root_node_name
 
 	var folder: String = SceneFile.make_folder_for(scene_path)
 	if not folder.is_empty():
 		root.free()
 		return {"ok": false, "error": folder}
-	var scene: SceneFile = SceneFile.new()
-	scene.root = root
-	scene.path = scene_path
 	var written: Dictionary = scene.write()
 	if not written.is_empty():
 		return written
 
-	return {
-		"ok": true, "scenePath": scene_path, "rootNodeType": root_node_type, "rootNodeName": root_node_name
-	}
+	return {"ok": true, "scenePath": scene_path, "rootNodeType": asked_type, "rootNodeName": root_node_name}
 
 
 func list_scene_nodes(args: Dictionary) -> Dictionary:
@@ -275,6 +288,16 @@ func add_node(args: Dictionary) -> Dictionary:
 
 	if node_name.is_empty():
 		return {"ok": false, "error": "Missing nodeName"}
+	var asked_type: String = node_type
+	var class_script: Script = null
+	if not node_type.is_empty() and not ClassDB.class_exists(node_type):
+		var declared: Dictionary = SceneFile.script_class(node_type, "Node")
+		if declared.has("error"):
+			return {"ok": false, "error": declared["error"]}
+		var held: Variant = declared.get("script")
+		if held is Script:
+			class_script = held
+			node_type = str(declared["base"])
 	var making: Array = Placing.what_to_add(node_type, instance_path, scene_path)
 	var packed: PackedScene = making[0]
 	if not str(making[1]).is_empty():
@@ -303,10 +326,17 @@ func add_node(args: Dictionary) -> Dictionary:
 
 	# In the tree before its properties, so a property holding a node can find it by path.
 	var new_node: Node = Placing.made(packed, node_type)
+	if class_script != null:
+		scene.asked(new_node, ["script"])
+		new_node.set_script(class_script)
 	new_node.name = node_name
 	parent.add_child(new_node)
 	Placing.place(new_node, place)
 	Placing.own(new_node, root)
+	var unsettled: String = scene.settle()
+	if not unsettled.is_empty():
+		return scene.refuse("Nothing was written: " + unsettled)
+	scene.asked(new_node, properties.keys())
 	var refused_property: String = _properties.write_all(new_node, properties)
 	if not refused_property.is_empty():
 		return scene.refuse(refused_property)
@@ -316,12 +346,15 @@ func add_node(args: Dictionary) -> Dictionary:
 	var answer: Dictionary = {
 		"ok": true,
 		"nodeName": node_name,
-		"nodeType": new_node.get_class(),
+		"nodeType": asked_type if class_script != null else new_node.get_class(),
 		"nodePath": new_path,
 		"index": new_node.get_index(),
 	}
 	var written: Dictionary = scene.write(
-		func(saved: Node) -> String: return _kept(scene, saved, new_node, properties.keys())
+		func(saved: Node) -> String:
+			return _kept(
+				scene, saved, new_node, properties.keys() + (["script"] if class_script != null else [])
+			)
 	)
 	if not written.is_empty():
 		return written
@@ -337,7 +370,14 @@ func delete_node(args: Dictionary) -> Dictionary:
 	var node_path: String = str(args.get("nodePath", ""))
 
 	if node_path.is_empty() or node_path == ".":
-		return {"ok": false, "error": "Cannot delete root node"}
+		return {
+			"ok": false,
+			"error":
+			(
+				"The root cannot be deleted, since a scene has exactly one. Delete the nodes under it, or "
+				+ "make a scene with another root with scene_create."
+			)
+		}
 
 	var opened: Array = _open(scene_path, true)
 	var scene: SceneFile = opened[0]
@@ -415,6 +455,7 @@ func duplicate_node(args: Dictionary) -> Dictionary:
 	target_parent.add_child(duplicated_node)
 	Placing.own(duplicated_node, root)
 	Placing.reconnect(copies, source)
+	scene.copied(copies)
 
 	var new_path: String = scene.path_of(duplicated_node)
 	var written: Dictionary = scene.write(
@@ -474,6 +515,9 @@ func reparent_node(args: Dictionary) -> Dictionary:
 		return scene.refuse(unplaceable)
 
 	var old_path: String = scene.path_of(node)
+	# Unowned while it moves: a node taken out of the tree keeps its owner, and adding it under the new
+	# parent warned that the owner was not above it. Node.reparent warns the same way.
+	node.owner = null
 	node.get_parent().remove_child(node)
 	new_parent.add_child(node)
 	Placing.place(node, place)
@@ -530,6 +574,7 @@ func set_node_properties(args: Dictionary) -> Dictionary:
 		if not unusable.is_empty():
 			return scene.refuse(unusable)
 
+	scene.asked(node, properties.keys())
 	var refused_property: String = _properties.write_all(node, properties)
 	if not refused_property.is_empty():
 		return scene.refuse(_missing_on(node, refused_property))
@@ -570,12 +615,10 @@ func get_node_properties(args: Dictionary) -> Dictionary:
 	var props: Dictionary = _properties_of(node, include_defaults, scene.set_here(node))
 	var cells: Dictionary = ResourceTools.cells_of(node)
 	scene.close()
-	var answer: Dictionary = {
-		"ok": true,
-		"nodePath": node_path,
-		"properties": props,
-		"unsavedInEditor": SceneFile.unsaved(scene_path)
-	}
+	var answer: Dictionary = {"ok": true, "nodePath": node_path, "properties": props}
+	# Only an editor holds anything unsaved; a headless engine answering false would say it looked.
+	if Engine.is_editor_hint():
+		answer["unsavedInEditor"] = SceneFile.unsaved(scene_path)
 	answer.merge(cells)
 	# An empty answer read as a node with nothing on it, rather than one with nothing changed.
 	if props.is_empty() and not include_defaults:
@@ -600,7 +643,10 @@ func save_scene(args: Dictionary) -> Dictionary:
 			return {"ok": false, "error": unsaved}
 
 	var open_root: Node = null
-	for open: Node in EditorInterface.get_open_scene_roots():
+	var open_roots: Array[Node] = []
+	if Engine.is_editor_hint():
+		open_roots = EditorInterface.get_open_scene_roots()
+	for open: Node in open_roots:
 		if open.scene_file_path == scene_path:
 			open_root = open
 	if open_root != null and target_path == scene_path:
@@ -618,7 +664,7 @@ func save_scene(args: Dictionary) -> Dictionary:
 		written = SceneFile.save_packed(packed, target_path)
 	else:
 		var scene: SceneFile = SceneFile.new()
-		var refused: Dictionary = scene.open(scene_path, false)
+		var refused: Dictionary = scene.open(scene_path, true)
 		if not refused.is_empty():
 			return refused
 		scene.path = target_path
@@ -897,4 +943,7 @@ func list_connections(args: Dictionary) -> Dictionary:
 				)
 
 	scene.close()
-	return {"ok": true, "connections": connections, "unsavedInEditor": SceneFile.unsaved(scene_path)}
+	var listed: Dictionary = {"ok": true, "connections": connections}
+	if Engine.is_editor_hint():
+		listed["unsavedInEditor"] = SceneFile.unsaved(scene_path)
+	return listed

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

@@ -168,6 +168,12 @@ func _argument_for(
 				% [called, named, type_string(wants), index + 1, JSON.stringify(sent)]
 			)
 		}
+	var rounded: String = Values.inexact(sent, wants)
+	if not rounded.is_empty():
+		return {
+			"type": "error",
+			"message": "%s.%s takes int as argument %d: %s." % [called, named, index + 1, rounded]
+		}
 	var given: Variant = _values.fitted(sent, wants)
 	if not Values.acceptable(given, wants):
 		return {
@@ -242,6 +248,9 @@ func _value_for(
 				"message": "%s.%s holds an object: %s" % [called, named, named_object["message"]]
 			}
 		return {"value": named_object["object"]}
+	var rounded: String = Values.inexact(value, wanted)
+	if not rounded.is_empty():
+		return {"type": "error", "message": "%s.%s holds int: %s." % [called, named, rounded]}
 	var as_sent: Variant = _values.fitted(value, TYPE_NIL)
 	var cut: bool = Values.cuts(value, wanted)
 	var given: Variant = as_sent

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

@@ -156,6 +156,11 @@ static func cuts(given: Variant, type: int) -> bool:
 	return not (whole and (value == 0.0 or value == 1.0))
 
 
+## Why [param given] may not be the whole number sent, or "": see [method Serialisation.inexact].
+static func inexact(given: Variant, type: int) -> String:
+	return Serialisation.inexact(given, type)
+
+
 ## How a value of [param type] is written to be read as one, or empty when it is not built from fields.
 static func written_as(type: int) -> String:
 	return Serialisation.written_as(type)

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

@@ -255,6 +255,9 @@ func wait_until(params: Dictionary) -> Dictionary:
 	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 rounded: String = Values.inexact(params["value"], typeof(current))
+	if refused.is_empty() and not rounded.is_empty():
+		refused = "%s.%s holds int: %s." % [node_path, property, rounded]
 	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 = (

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

@@ -16,6 +16,10 @@ const Read = preload("reading.gd")
 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
+
 # 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.
@@ -53,6 +57,8 @@ const LIST_TYPES: Array[int] = [
 # type it wanted.
 const SERIALISERS: Dictionary = {
 	TYPE_NIL: "_serialize_nil",
+	TYPE_INT: "_serialize_int",
+	TYPE_PACKED_INT64_ARRAY: "_serialize_ints",
 	TYPE_FLOAT: "_serialize_float",
 	TYPE_PACKED_FLOAT32_ARRAY: "_serialize_floats",
 	TYPE_PACKED_FLOAT64_ARRAY: "_serialize_floats",
@@ -109,6 +115,8 @@ const BUILDERS: Dictionary = {
 	"NodePath": "_build_node_path",
 	"PackedByteArray": "_build_bytes",
 	"float": "_build_float",
+	"int": "_build_int",
+	"RID": "_build_rid",
 	"Dictionary": "_build_dictionary",
 }
 
@@ -136,6 +144,8 @@ const REQUIRED: Dictionary = {
 	"NodePath": [["path"]],
 	"PackedByteArray": [["base64"]],
 	"float": [["value"]],
+	"int": [["value"]],
+	"RID": [["id"]],
 	"Dictionary": [["entries"]],
 }
 
@@ -243,9 +253,40 @@ func deserialize_value(value: Variant) -> Variant:
 		return fields
 	if tag == "Dictionary" and not pairs(fields["entries"]):
 		return fields
+	# Digits only: the tag is there to carry what a number cannot, and {"value": 5} meant for some
+	# other shape is not to be read as 5.
+	if tag == "int" and not (fields["value"] is String and _exact_int(fields["value"]) != null):
+		return fields
+	if tag == "RID" and _exact_int(fields["id"]) == null:
+		return fields
 	return call(builder, fields)
 
 
+## [param held] as the whole number it spells exactly, or null: an int, a JSON number that is whole
+## and no larger than a double holds exactly, the digits of one, or the int tag carrying them. A
+## fraction, or a number past 2^53 that arrived as a number and so may already be a neighbour of the
+## one meant, is no id.
+func _exact_int(held: Variant) -> Variant:
+	if held is int:
+		return held
+	if held is float:
+		var number: float = held
+		if is_finite(number) and number == floorf(number) and absf(number) < EXACT:
+			return int(number)
+		return null
+	if held is String:
+		var digits: String = held
+		var parsed: int = digits.to_int()
+		if digits.is_valid_int() and str(parsed) == digits:
+			return parsed
+		return null
+	if held is Dictionary:
+		var tagged: Dictionary = held
+		if str(tagged.get("_type", "")) == "int" and tagged.has("value"):
+			return _exact_int(tagged["value"])
+	return null
+
+
 ## The components a path reads off [param value], by the names GDScript gives them, or none for a
 ## value that has none: a vector's axes, a colour's channels, a rectangle's corners and size, a
 ## transform's basis and origin. A value of one of these is a copy wherever it is read, so a write
@@ -393,6 +434,11 @@ func fitted(value: Variant, type: int) -> Variant:
 	if not simple.has(type) or not simple.has(typeof(rebuilt)):
 		return rebuilt
 
+	# Digits are read as digits, since read as JSON they become a double and one past 2^53 a
+	# neighbour of the number written.
+	if rebuilt is String and type == TYPE_INT and _exact_int(rebuilt) != null:
+		return _exact_int(rebuilt)
+
 	if rebuilt is String and type != TYPE_STRING:
 		var text: String = rebuilt
 		var parsed: Variant = Read.json_or_null(text)
@@ -408,13 +454,33 @@ func fitted(value: Variant, type: int) -> Variant:
 	return type_convert(rebuilt, type)
 
 
+## 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.
+static func inexact(given: Variant, type: int) -> String:
+	if type != TYPE_INT or (typeof(given) != TYPE_FLOAT and typeof(given) != TYPE_INT):
+		return ""
+	var number: float = Read.as_float(given)
+	if not is_finite(number) or absf(number) < EXACT:
+		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"
+		)
+		% String.num(number, 0)
+	)
+
+
 ## How a value of [param type] is written to be read as one, for a refusal to name, or empty for a
 ## type that is not built from fields. A refusal naming only the two types left a caller to find
 ## the shape in the description of another op.
 static func written_as(type: int) -> String:
 	var tag: String = type_string(type)
 	var alternatives: Array = REQUIRED.get(tag, [])
-	if alternatives.is_empty() or tag == "float" or tag == "Dictionary":
+	if alternatives.is_empty() or tag in ["float", "int", "Dictionary"]:
 		return ""
 	var keys: Array = alternatives[0]
 	var parts: Array[String] = []
@@ -530,10 +596,32 @@ func _serialize_node_path(value: NodePath) -> Dictionary:
 	return {"path": str(value), "_type": "NodePath"}
 
 
-# An id rather than nothing, because two properties holding the same RID are worth telling apart
-# even though neither can be handed back to the engine.
+# 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": 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
+# and on the engine's, and from there on neighbouring whole numbers share a double. A RefCounted's
+# instance id is one, with its top bit set, and a resource uid another; read as numbers they came
+# back as a neighbouring id, which named nothing or something else.
+func _serialize_int(value: int) -> Variant:
+	if value > -EXACT and value < EXACT:
+		return 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
+# a double to hold.
+func _serialize_ints(value: PackedInt64Array) -> Variant:
+	for number: int in value:
+		if number <= -EXACT or number >= EXACT:
+			var items: Array = []
+			for each: int in value:
+				items.append(_serialize_int(each))
+			return items
+	return value
 
 
 # A bound method, said in the terms a caller could act on: what it is on, and what it is called.
@@ -672,7 +760,7 @@ func _describe_object(value: Object) -> Dictionary:
 	# in a costume and reads as if the object had been asked and had nothing to say.
 	if value.has_method("_to_string"):
 		described["says"] = value.to_string()
-	described["id"] = value.get_instance_id()
+	described["id"] = _serialize_int(value.get_instance_id())
 	return described
 
 
@@ -808,6 +896,16 @@ func _build_float(fields: Dictionary) -> float:
 	return Read.as_float(fields)
 
 
+func _build_int(fields: Dictionary) -> int:
+	var exact: int = _exact_int(fields["value"])
+	return exact
+
+
+func _build_rid(fields: Dictionary) -> RID:
+	var id: int = _exact_int(fields["id"])
+	return rid_from_int64(id)
+
+
 ## 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.