gdharness 1.2.36 → 1.2.38

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

@@ -16,7 +16,19 @@ extends RefCounted
 ## - [code]pack[/code] keeps only what the scene itself owns, so a property set on a node inside an
 ##   instance, a node deleted from one and a node moved out of one were answered as done and were
 ##   not in the file.
-
+##
+## A headless engine writes for a project no editor serves, and there one more thing differs: the
+## editor gives a script that is not a tool a placeholder, and anywhere else instancing a scene runs
+## every script in it. Measured on 4.7.2, an [code]_init[/code] setting modulate and an exported
+## setter setting scale were both saved into the file by a write to another node, and a root whose
+## script failed in [code]_init[/code] was saved without it. Outside the editor, then, what a node
+## stores is put back to what the file holds wherever the tool did not ask for a change, before
+## anything is saved, and a write is refused when that does not hold. See [HeadlessCheck].
+
+const HeadlessCheck = preload("headless_check.gd")
+
+## How many times what scripts changed is put back before a write is refused for it.
+const PUTTING_BACK_PASSES: int = 4
 const PropertyValues = preload("property_values.gd")
 
 ## Whether a scan asked for through [method scan_later] is still to start, which a caller waiting
@@ -27,6 +39,19 @@ var root: Node = null
 var path: String = ""
 var _base_paths: Dictionary = {}
 var _state: SceneState = null
+## What the file stores on each node it was opened with, by the node's instance id, so a node keeps
+## its record when a tool moves or renames it. Only kept outside the editor.
+var _filed: Dictionary = {}
+## The properties a tool set on each node, by instance id: the differences it asked for.
+var _asked: Dictionary = {}
+## What each node a tool set properties on held before it did, by instance id.
+var _before: Dictionary = {}
+## Each copy a tool made, by instance id, to the instance id of the node it copies.
+var _copied_from: Dictionary = {}
+## The embedded resources a tool reached into through an indexed property, by their id in the file.
+var _reached: Dictionary = {}
+## The file as it was opened, to compare its embedded resources with what the write saves.
+var _text: String = ""
 
 
 ## Opens [param scene_path], answering a refusal, or {} with [member root] set.
@@ -56,12 +81,59 @@ func open(scene_path: String, for_writing: bool) -> Dictionary:
 		for index: int in base.get_node_count():
 			_base_paths[_relative(str(base.get_node_path(index)))] = true
 		base = base.get_base_scene_state()
+	# On a read as well, which would otherwise answer what the scripts set as what the file holds.
+	if not Engine.is_editor_hint():
+		if for_writing:
+			_text = FileAccess.get_file_as_string(path)
+		for index: int in _state.get_node_count():
+			var node: Node = _node_at(str(_state.get_node_path(index)))
+			if node != null:
+				_filed[node.get_instance_id()] = _stored_at(_state, index)
+		var unsettled: String = settle()
+		if not unsettled.is_empty():
+			return refuse(("Nothing was written: " if for_writing else "Not read: ") + unsettled)
 	return {}
 
 
+## Puts back what the scene's scripts changed on every node a tool has not asked to change, as
+## [method write] does, answering "" or why that did not hold. Called once a node has come into the
+## scene, so what its scripts did on the way in is not taken for the tool's own change.
+func settle() -> String:
+	if Engine.is_editor_hint():
+		return ""
+	var packed: PackedScene = PackedScene.new()
+	var packing: Error = packed.pack(root)
+	if packing != OK:
+		return "Failed to pack %s: %s" % [path, error_string(packing)]
+	return _settled(packed)[1]
+
+
+## Takes [param names] on [param node] as the tool's own changes, which a write saves as they are.
+## Called before the tool sets them.
+func asked(node: Node, names: Array) -> void:
+	var id: int = node.get_instance_id()
+	var on: Dictionary = _asked.get_or_add(id, {})
+	if not _before.has(id):
+		_before[id] = HeadlessCheck.stored(node)
+	for name: Variant in names:
+		var property: String = str(name)
+		on[property] = true
+		on[property.get_slice(":", 0)] = true
+		_reached.merge(HeadlessCheck.reached(node, property))
+
+
+## Takes each copy in [param copies], keyed by the node it was made from, as holding what that node's
+## file entry holds.
+func copied(copies: Dictionary) -> void:
+	for source: Variant in copies:
+		var original: Node = source
+		var copy: Node = copies[source]
+		_copied_from[copy.get_instance_id()] = original.get_instance_id()
+
+
 ## Why [param scene_path] cannot be written while the editor has it open, or "".
 static func unsaved_in_editor(scene_path: String) -> String:
-	if not EditorInterface.get_unsaved_scenes().has(scene_path):
+	if not Engine.is_editor_hint() or not EditorInterface.get_unsaved_scenes().has(scene_path):
 		return ""
 	return (
 		(
@@ -142,21 +214,84 @@ static func make_folder_for(file_path: String) -> String:
 ## Why [param script], loaded from [param script_path], cannot be attached because the editor could not
 ## compile it, or "". A script that did not compile has no base type, and the refusal built from that
 ## said "start.gd extends , so it cannot be on a Control root" about a script that was fine, whose
-## failure was a class it called being behind in the editor.
+## failure was a class it called being behind in the editor. A headless engine compiles every
+## script from its file, so only an editor can hold a copy that is behind.
 static func uncompiled(script: Script, script_path: String) -> String:
 	if not str(script.get_instance_base_type()).is_empty():
 		return ""
+	if not Engine.is_editor_hint():
+		return (
+			(
+				"%s does not compile, so it cannot be attached. script_diagnostics on it gives the "
+				+ "parser's errors."
+			)
+			% script_path
+		)
 	return (
 		(
-			"%s does not compile in the editor, so it cannot be attached. script_diagnostics on it gives "
-			+ "the parser's errors. If they deny a member that another class's file declares, the "
-			+ "editor's copy of that class is behind: editor_rescan with reloadScript on that class, then "
-			+ "ask again."
+			"%s does not compile in the editor, so it cannot be attached. script_diagnostics on it "
+			+ "gives the parser's errors. If they deny a member that another class's file declares, "
+			+ "the editor's copy of that class is behind: editor_rescan with reloadScript on that "
+			+ "class, then ask again."
 		)
 		% script_path
 	)
 
 
+## The script a project declares [param type_name] in with class_name, as {"script", "path",
+## "base"} with base the engine class its objects are made as, or {"error"} when that script cannot
+## make one, or an empty dictionary when no script declares it. The editor's create dialogs offer
+## these classes beside the engine's, and ClassDB knows only the engine's.
+static func script_class(type_name: String, kind: String) -> Dictionary:
+	for entry: Dictionary in ProjectSettings.get_global_class_list():
+		if str(entry.get("class", "")) != type_name:
+			continue
+		var declaring: String = str(entry.get("path", ""))
+		if entry.get("is_abstract", false) == true:
+			return {
+				"error":
+				"%s, declared in %s, is abstract, so nothing can be made of it." % [type_name, declaring]
+			}
+		var script: Script = load(declaring) as Script
+		if script == null:
+			return {"error": "%s is declared in %s, which does not load." % [type_name, declaring]}
+		var failed: String = uncompiled(script, declaring)
+		if not failed.is_empty():
+			return {"error": failed}
+		var base: String = str(script.get_instance_base_type())
+		if not ClassDB.is_parent_class(base, kind):
+			return {
+				"error":
+				"%s, declared in %s, extends %s, which is not a %s." % [type_name, declaring, base, kind]
+			}
+		return {"script": script, "path": declaring, "base": base}
+	return {}
+
+
+## The engine class and the script a create makes for [param type_name] and [param given], the
+## res:// path of the script the call named or "", as {"type", "script"}, or {"error"}. A class_name
+## a project script declares is that script on its engine class; [param argument] names the
+## argument the type came in, for the refusal when the call also named another script.
+static func made_as(type_name: String, given: String, kind: String, argument: String) -> Dictionary:
+	if ClassDB.class_exists(type_name):
+		return {"type": type_name, "script": given}
+	var declared: Dictionary = script_class(type_name, kind)
+	if declared.has("error"):
+		return declared
+	if declared.is_empty():
+		return {"type": type_name, "script": given}
+	var declaring: String = str(declared["path"])
+	if not given.is_empty() and given != declaring:
+		return {
+			"error":
+			(
+				"%s %s is the class %s declares, and script names %s: pass one of them."
+				% [argument, type_name, declaring, given]
+			)
+		}
+	return {"type": str(declared["base"]), "script": declaring}
+
+
 ## Why no node can be called [param node_name], wherever it sits, or "".
 static func unfit_name(node_name: String) -> String:
 	if node_name.is_empty():
@@ -221,6 +356,26 @@ func write(check: Callable = Callable()) -> Dictionary:
 	var packing: Error = packed.pack(root)
 	if packing != OK:
 		return refuse("Failed to pack %s: %s" % [path, error_string(packing)])
+	var headless: bool = not Engine.is_editor_hint()
+	if headless:
+		var settled: Array = _settled(packed)
+		if not str(settled[1]).is_empty():
+			return refuse("Nothing was written: " + str(settled[1]))
+		packed = settled[0]
+		if not path.ends_with(".tscn") and _holds_scripted_embedded():
+			return refuse(
+				(
+					(
+						(
+							"Nothing was written: %s is a binary scene holding an embedded resource with a script "
+							+ "that is not a tool, and what that script changed when a headless engine loaded it "
+							+ "cannot be told apart from the file here. "
+						)
+						% path
+					)
+					+ HeadlessCheck.REMEDY
+				)
+			)
 	if check.is_valid():
 		var saved: Node = packed.instantiate(PackedScene.GEN_EDIT_STATE_MAIN)
 		if saved == null:
@@ -230,7 +385,33 @@ func write(check: Callable = Callable()) -> Dictionary:
 		if not missing.is_empty():
 			return refuse("Nothing was written: " + missing)
 	close()
-	return save_packed(packed, path)
+	var previous: Variant = null
+	if FileAccess.file_exists(path):
+		previous = FileAccess.get_file_as_bytes(path)
+	var written: Dictionary = save_packed(packed, path)
+	if not written.is_empty() or not headless or not path.ends_with(".tscn"):
+		return written
+	var state: SceneState = packed.get_state()
+	var values: Array = []
+	for index: int in state.get_node_count():
+		values.append_array(_stored_at(state, index).values())
+	var unkept: String = HeadlessCheck.settle_saved(
+		path, _text, values, null, {}, _reached, func() -> Error: return save_keeping_uid(packed, path)
+	)
+	if unkept.is_empty():
+		return {}
+	return {"ok": false, "error": "Nothing was written: " + unkept + HeadlessCheck.put_back(path, previous)}
+
+
+func _holds_scripted_embedded() -> bool:
+	var seen: Dictionary = {}
+	var nodes: Array[Node] = [root]
+	while not nodes.is_empty():
+		var node: Node = nodes.pop_back()
+		if HeadlessCheck.holds_scripted_embedded(node, seen):
+			return true
+		nodes.append_array(node.get_children())
+	return false
 
 
 ## Writes [param packed] to [param scene_path], making its directory, and brings the editor up to
@@ -241,18 +422,51 @@ static func save_packed(packed: PackedScene, scene_path: String) -> Dictionary:
 		var made: Error = DirAccess.make_dir_recursive_absolute(directory)
 		if made != OK:
 			return {"ok": false, "error": "Could not create %s: %s" % [directory, error_string(made)]}
-	var saving: Error = ResourceSaver.save(packed, scene_path)
+	var saving: Error = save_keeping_uid(packed, scene_path)
 	if saving != OK:
 		return {"ok": false, "error": "Failed to save %s: %s" % [scene_path, error_string(saving)]}
 	refresh(scene_path)
 	return {}
 
 
+## Saves [param resource] at [param file_path], keeping the uid the file already has.
+##
+## The editor saves through its uid cache, which knows every file's. A headless engine that has not
+## imported the project has none, and a resave dropped the uid from the header, so every reference
+## made through it stopped resolving. Read from the file itself, since the loader does not answer it
+## for a text scene there, and a new file is given one as the editor gives it.
+static func save_keeping_uid(resource: Resource, file_path: String) -> Error:
+	if Engine.is_editor_hint():
+		return ResourceSaver.save(resource, file_path)
+	var uid: int = _uid_in(file_path)
+	var saving: Error = ResourceSaver.save(resource, file_path)
+	if saving != OK:
+		return saving
+	if uid == ResourceUID.INVALID_ID:
+		uid = ResourceUID.create_id()
+	return ResourceSaver.set_uid(file_path, uid)
+
+
+## The uid the file at [param file_path] declares, or [constant ResourceUID.INVALID_ID].
+static func _uid_in(file_path: String) -> int:
+	if not FileAccess.file_exists(file_path):
+		return ResourceUID.INVALID_ID
+	var file: FileAccess = FileAccess.open(file_path, FileAccess.READ)
+	if file != null:
+		var header: RegExMatch = RegEx.create_from_string('uid="(uid://[a-z0-9]+)"').search(file.get_line())
+		file.close()
+		if header != null:
+			return ResourceUID.text_to_id(header.get_string(1))
+	return ResourceLoader.get_resource_uid(file_path)
+
+
 ## Brings the editor up to date with a scene file written under it: the cached copy anything holds,
 ## the editor's file list, and the tab showing it, whether current or not.
 static func refresh(scene_path: String) -> void:
 	if ResourceLoader.has_cached(scene_path):
 		var _replaced: Resource = ResourceLoader.load(scene_path, "", ResourceLoader.CACHE_MODE_REPLACE)
+	if not Engine.is_editor_hint():
+		return
 	scan_later()
 	if EditorInterface.get_open_scenes().has(scene_path):
 		EditorInterface.reload_scene_from_path(scene_path)
@@ -294,7 +508,191 @@ static func _start_scan() -> void:
 ## Whether the editor holds unsaved changes to [param scene_path], for a read to say that the file
 ## it answers from is not what the editor shows.
 static func unsaved(scene_path: String) -> bool:
-	return EditorInterface.get_unsaved_scenes().has(scene_path)
+	return Engine.is_editor_hint() and EditorInterface.get_unsaved_scenes().has(scene_path)
+
+
+## [param packed] with what the scene's scripts changed put back, as [pack, ""], or [null, why not].
+##
+## On a node the tool did not ask to change, a difference is put back to what the file holds, or, for
+## a property the file does not set, to what the node would load with without it. On a node it did
+## ask to change, through a script that is not a tool, every property it did not name is put back to
+## what it held before. Packed again afterwards and put back again until nothing differs, since
+## putting one property back can run a setter that changes another already put back (a script
+## setting speed in _init, whose setter tints modulate), and refused if something still does.
+func _settled(packed: PackedScene) -> Array:
+	var current: PackedScene = packed
+	var left: Array[Array] = []
+	for put_back: int in PUTTING_BACK_PASSES + 1:
+		var stray: Array[Array] = _strays(current.get_state())
+		var moved: Array[Array] = _moved_by_scripts()
+		if stray.is_empty() and moved.is_empty():
+			return [current, ""]
+		if put_back == PUTTING_BACK_PASSES:
+			left = stray
+			left.append_array(moved)
+			break
+		for found: Array in stray:
+			var node: Node = found[0]
+			var name: String = found[1]
+			node.set(name, found[3] if found[2] else _unset_value(node, name))
+		for found: Array in moved:
+			var node: Node = found[0]
+			var before: Dictionary = _before[node.get_instance_id()]
+			for name: String in found[1]:
+				node.set(name, before.get(name, HeadlessCheck.default_of(node, name)))
+		current = PackedScene.new()
+		var packing: Error = current.pack(root)
+		if packing != OK:
+			return [null, "Failed to pack %s: %s" % [path, error_string(packing)]]
+	var first: Array = left[0]
+	var stray_node: Node = first[0]
+	var named: String = str(first[1])
+	if first[1] is Array:
+		var names: Array = first[1]
+		named = str(names[0])
+	return [null, _stray_text(stray_node, named)]
+
+
+## Each node the tool asked to change through a script that is not a tool, with the properties it did
+## not name that no longer hold what they held before, as [node, names].
+func _moved_by_scripts() -> Array[Array]:
+	var moved: Array[Array] = []
+	for key: Variant in _asked:
+		var id: int = key
+		var node: Node = instance_from_id(id) as Node
+		if node == null or not root.is_ancestor_of(node) and node != root:
+			continue
+		var on: Dictionary = _asked[id]
+		if not HeadlessCheck.through_script(node, on):
+			continue
+		var before: Dictionary = _before[id]
+		var changed: Array[String] = HeadlessCheck.differing(node, before, on)
+		if not changed.is_empty():
+			moved.append([node, changed])
+	return moved
+
+
+## Every property [param state] stores differently from the file, on a node the tool did not ask to
+## change it on, as [node, name, whether the file stores it, the file's value].
+func _strays(state: SceneState) -> Array[Array]:
+	var stray: Array[Array] = []
+	for index: int in state.get_node_count():
+		var node: Node = _node_at(str(state.get_node_path(index)))
+		if node == null:
+			continue
+		var id: int = node.get_instance_id()
+		if _asked.has(id):
+			continue
+		var filed: Dictionary = _filed.get(id, _filed.get(_copied_from.get(id, 0), {}))
+		# A node is instanced before it is added to its parent, which is before its children are, so
+		# what a script does as a scene loads stays on the script's own node. Anything else a pack
+		# changes is Godot's doing and the editor's pack does it too: a Control saved without its
+		# grow directions gets them back from anchors_preset's setter, and loses an anchors_preset
+		# its layout mode does not store.
+		if not HeadlessCheck.untooled(node.get_script()) and not HeadlessCheck.untooled(filed.get("script")):
+			continue
+		var stored: Dictionary = _stored_at(state, index)
+		var names: Dictionary = filed.duplicate()
+		names.merge(stored)
+		for key: Variant in names:
+			var name: String = str(key)
+			var held: bool = filed.has(name)
+			if held == stored.has(name) and (not held or PropertyValues.same(stored[name], filed[name])):
+				continue
+			if not held and HeadlessCheck.at_default(node, name):
+				continue
+			stray.append([node, name, held, filed.get(name)])
+	return stray
+
+
+func _stray_text(node: Node, name: String) -> String:
+	var at: String = str(root.name) if node == root else path_of(node)
+	if name == "script":
+		return (
+			(
+				(
+					"the script of %s did not start when a headless engine instanced %s, so the node would be "
+					+ "saved without it; the engine's messages give its errors. "
+				)
+				% [at, path]
+			)
+			+ HeadlessCheck.REMEDY
+		)
+	return (
+		(
+			(
+				"%s.%s would be saved differently from what %s holds, and the call did not ask for it: the "
+				+ "scene's scripts ran when a headless engine instanced it, as they do in the game and not in "
+				+ "an editor. "
+			)
+			% [at, name, path]
+		)
+		+ HeadlessCheck.REMEDY
+	)
+
+
+## What [param node] would load with for [param name] if this file did not set it: what the scenes
+## it comes from store, followed down through every scene instanced or inherited, else its script's
+## or class's default. Read from their files, since instancing them would run their scripts.
+func _unset_value(node: Node, name: String) -> Variant:
+	var base: SceneState = _state.get_base_scene_state() if _state != null else null
+	if node == root or _base_paths.has(path_of(node)):
+		return _value_in(base, path_of(node), node, name)
+	var top: Node = node
+	while top != root and top.owner != root:
+		top = top.get_parent()
+	if top == root or top.scene_file_path.is_empty():
+		return HeadlessCheck.default_of(node, name)
+	if _base_paths.has(path_of(top)):
+		return _value_in(base, path_of(node), node, name)
+	var instanced: PackedScene = ResourceLoader.load(top.scene_file_path) as PackedScene
+	return _value_in(
+		instanced.get_state() if instanced != null else null, str(top.get_path_to(node)), node, name
+	)
+
+
+## What [param state] gives the node at [param at] for [param name], following it into the scene an
+## enclosing node instances, or into the base scene, until a file sets it.
+func _value_in(state: SceneState, at: String, node: Node, name: String) -> Variant:
+	while state != null:
+		var inside: String = ""
+		var instanced: PackedScene = null
+		for index: int in state.get_node_count():
+			var here: String = _relative(str(state.get_node_path(index)))
+			if here == at:
+				for property: int in state.get_node_property_count(index):
+					if str(state.get_node_property_name(index, property)) == name:
+						return state.get_node_property_value(index, property)
+			var scene: PackedScene = state.get_node_instance(index)
+			if scene == null:
+				continue
+			var encloses: bool = here == at or here == "." or at.begins_with(here + "/")
+			if encloses and (instanced == null or here.length() > inside.length() or inside == "."):
+				inside = here
+				instanced = scene
+		if instanced != null:
+			if inside == at:
+				at = "."
+			elif inside != ".":
+				at = at.substr(inside.length() + 1)
+			state = instanced.get_state()
+		else:
+			state = state.get_base_scene_state()
+	return HeadlessCheck.default_of(node, name)
+
+
+func _node_at(node_path: String) -> Node:
+	var at: String = _relative(node_path)
+	return root if at == "." else root.get_node_or_null(NodePath(at))
+
+
+static func _stored_at(state: SceneState, index: int) -> Dictionary:
+	var stored: Dictionary = {}
+	for property: int in state.get_node_property_count(index):
+		stored[str(state.get_node_property_name(index, property))] = (state.get_node_property_value(
+			index, property
+		))
+	return stored
 
 
 func _relative(node_path: String) -> String:

package/build/godot/addons/gdharness_editor/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.