gdharness 1.1.21 → 1.1.23

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

@@ -5,60 +5,16 @@ extends Node
 
 const Read = preload("../reading.gd")
 const PropertyValues = preload("../property_values.gd")
+const SceneFile = preload("../scene_file.gd")
 const Serialisation = preload("../serialisation.gd")
 
 var _editor_plugin: EditorPlugin = null
 var _values: Serialisation = Serialisation.new()
 var _properties: PropertyValues = PropertyValues.new()
 
-## How many scans the editor has completed, counted off `sources_changed`, which it emits at the end
-## of every scan once the reimport the scan found is done: the one moment a scan is over. Neither
-## flag it offers says so. A threaded scan stops reporting itself when its thread finishes, and its
-## import runs a frame or more later when the thread is joined; an editor in the background took
-## long enough over that frame that a rescan answered before the import of 211 changed scenes began.
-var _scans_completed: int = 0
-
-## When the last scan completed, on the engine's clock, or -1 before the first. The editor writes
-## the class cache a frame after it stops reporting a scan, measured on 4.7.2, so a game started
-## in between reads a file being rewritten; how long ago the scan ended is what tells a caller
-## whether that write can still be coming.
-var _scan_finished_at_msec: int = -1
-
-## How many reimports asked for through [method reimport_files] have finished. Counted here rather
-## than off `resources_reimported`, which a scan's own import emits as well.
-var _reimports_completed: int = 0
-
 
 func set_editor_plugin(plugin: EditorPlugin) -> void:
 	_editor_plugin = plugin
-	var filesystem: EditorFileSystem = EditorInterface.get_resource_filesystem()
-	if not filesystem.sources_changed.is_connected(_scan_completed):
-		var watched: int = filesystem.sources_changed.connect(_scan_completed)
-		if watched != OK:
-			push_error("gdharness could not watch for completed scans: %d" % watched)
-
-
-func _scan_completed(_sources_exist: bool) -> void:
-	_scans_completed += 1
-	_scan_finished_at_msec = Time.get_ticks_msec()
-
-
-func _refresh_and_reload(scene_path: String) -> void:
-	_refresh_filesystem()
-	_reload_scene_in_editor(scene_path)
-
-
-func _refresh_filesystem() -> void:
-	if _editor_plugin:
-		EditorInterface.get_resource_filesystem().scan()
-
-
-func _reload_scene_in_editor(scene_path: String) -> void:
-	if not _editor_plugin:
-		return
-	var edited: Node = EditorInterface.get_edited_scene_root()
-	if edited and edited.scene_file_path == scene_path:
-		EditorInterface.reload_scene_from_path(scene_path)
 
 
 func _ensure_res_path(path: String) -> String:
@@ -84,29 +40,10 @@ func _to_scene_res_path(project_path: String, scene_path: String) -> String:
 	return _ensure_res_path(p)
 
 
-func _load_scene(scene_path: String) -> Array:
-	if not FileAccess.file_exists(scene_path):
-		return [null, {"ok": false, "error": "Scene not found: " + scene_path}]
-	var packed: PackedScene = load(scene_path)
-	if not packed:
-		return [null, {"ok": false, "error": "Failed to load: " + scene_path}]
-	var root: Node = packed.instantiate()
-	if not root:
-		return [null, {"ok": false, "error": "Failed to instantiate: " + scene_path}]
-	return [root, {}]
-
-
-func _save_scene(scene_root: Node, scene_path: String) -> Dictionary:
-	var packed: PackedScene = PackedScene.new()
-	if packed.pack(scene_root) != OK:
-		scene_root.queue_free()
-		return {"ok": false, "error": "Failed to pack scene"}
-	if ResourceSaver.save(packed, scene_path) != OK:
-		scene_root.queue_free()
-		return {"ok": false, "error": "Failed to save scene"}
-	scene_root.queue_free()
-	_refresh_and_reload(scene_path)
-	return {}
+## [param scene_path] opened for a tool, as [scene, refusal]: the refusal is {} when it opened.
+func _open(scene_path: String, for_writing: bool) -> Array:
+	var scene: SceneFile = SceneFile.new()
+	return [scene, scene.open(scene_path, for_writing)]
 
 
 func _find_node(root: Node, path: String) -> Node:
@@ -115,9 +52,156 @@ func _find_node(root: Node, path: String) -> Node:
 	return root.get_node_or_null(path)
 
 
-## Set each property, answering with what went wrong or "" when nothing did.
-func _set_node_properties(node: Node, properties: Dictionary) -> String:
-	return _properties.write_all(node, properties)
+## Why the property or signal [param missing] could not be found on [param node], adding the one
+## cause the name alone does not show: a script that does not compile leaves the editor holding a
+## placeholder with no properties or signals at all, and the refusal named the property instead.
+func _missing_on(node: Node, missing: String) -> String:
+	var script: Script = node.get_script()
+	if script == null or not script.has_source_code():
+		return missing
+	var probe: GDScript = GDScript.new()
+	probe.source_code = script.source_code
+	if probe.reload() == OK:
+		return missing
+	return (
+		"%s. Its script, %s, does not compile, so the editor knows none of what it declares."
+		% [missing, script.resource_path]
+	)
+
+
+## Whether each of [param names] reads the same off [param saved] as off [param node], answering
+## the first that does not, or "".
+func _kept(scene: SceneFile, saved: Node, node: Node, names: Array) -> String:
+	var at: String = scene.path_of(node)
+	var copy: Node = saved.get_node_or_null(at)
+	if copy == null:
+		return "%s is not in the scene as it would be saved." % at
+	for key: Variant in names:
+		var property: String = str(key)
+		var loaded: Variant = copy.get(property)
+		if not scene.kept(saved, loaded, node.get(property)):
+			return (
+				(
+					"%s.%s would load from the file as %s: the scene does not keep it, because the property "
+					+ "is not one a scene stores or the node belongs to another scene."
+				)
+				% [at, property, JSON.stringify(_values.serialize_value(loaded))]
+			)
+	return ""
+
+
+## Owns [param node] and the nodes under it to [param root], except those an instanced scene
+## inside it owns: giving those to the root made the pack write the instance's own nodes into this
+## scene as overrides.
+func _copy(source: Node, root: Node, copies: Dictionary) -> Node:
+	var copy: Node = null
+	if not source.scene_file_path.is_empty():
+		# An instanced scene made again from its file, so the copy is an instance too. Node.duplicate
+		# makes a plain node of the instance's class, and the pack saved it with every property of the
+		# instance's root frozen into this scene.
+		var packed: PackedScene = ResourceLoader.load(source.scene_file_path, "PackedScene") as PackedScene
+		if packed == null:
+			return null
+		copy = packed.instantiate(PackedScene.GEN_EDIT_STATE_INSTANCE)
+		for declared: Dictionary in source.get_property_list():
+			if not (Read.as_int(declared.get("usage", 0)) & PROPERTY_USAGE_STORAGE):
+				continue
+			var property: String = str(declared.get("name", ""))
+			var value: Variant = source.get(property)
+			if not PropertyValues.same(copy.get(property), value):
+				copy.set(property, value)
+		for group: StringName in source.get_groups():
+			if not copy.is_in_group(group):
+				copy.add_to_group(group, true)
+	else:
+		copy = source.duplicate(Node.DUPLICATE_GROUPS | Node.DUPLICATE_SCRIPTS)
+		for child: Node in copy.get_children():
+			copy.remove_child(child)
+			child.free()
+	copy.name = source.name
+	copies[source] = copy
+	# Only what this scene owns: an instance's own nodes come with the instance.
+	for child: Node in source.get_children():
+		if child.owner == root:
+			var copied: Node = _copy(child, root, copies)
+			if copied == null:
+				return null
+			copy.add_child(copied)
+	return copy
+
+
+## Gives each copy in [param copies] the persistent connections its source has, to the copy of the
+## target when the target was copied too. A connection an instance makes inside itself is skipped:
+## the instance made again from its file already has it.
+func _reconnect(copies: Dictionary, top: Node) -> void:
+	for key: Variant in copies:
+		var source: Node = key
+		var copy: Node = copies[key]
+		for info: Dictionary in source.get_signal_list():
+			var signal_name: String = str(info.get("name", ""))
+			for conn: Dictionary in source.get_signal_connection_list(signal_name):
+				var flags: int = Read.as_int(conn.get("flags", 0))
+				var callable: Callable = conn.get("callable", Callable())
+				var target: Object = callable.get_object()
+				if not flags & Object.CONNECT_PERSIST or target == null:
+					continue
+				var to: Object = copies.get(target, target)
+				if to == target and target is Node and (target == top or top.is_ancestor_of(target as Node)):
+					continue
+				var copied: Callable = Callable(to, callable.get_method())
+				if (
+					not copy.is_connected(signal_name, copied)
+					and copy.connect(signal_name, copied, flags) != OK
+				):
+					push_error(
+						"gdharness: could not copy the connection %s of %s" % [signal_name, source.name]
+					)
+
+
+func _own(node: Node, root: Node) -> void:
+	node.owner = root
+	for child: Node in node.get_children():
+		if child.owner == null or child.owner == root:
+			_own(child, root)
+
+
+## [param node]'s stored properties as a read answers them. A property holding a node is answered
+## as the path to it: the copy read here is never in the tree, and an object description named a
+## node that was freed when the call ended.
+func _properties_of(node: Node, include_defaults: bool, set_here: Dictionary) -> Dictionary:
+	var script: Script = node.get_script()
+	var scripted: Dictionary = {}
+	if script != null:
+		for declared: Dictionary in script.get_script_property_list():
+			scripted[str(declared.get("name", ""))] = true
+	var props: Dictionary = {}
+	for p: Dictionary in node.get_property_list():
+		if not (Read.as_int(p.get("usage", 0)) & PROPERTY_USAGE_STORAGE):
+			continue
+		var property: String = str(p.get("name", ""))
+		if property.is_empty():
+			continue
+		var value: Variant = node.get(property)
+		if not include_defaults and not set_here.has(property):
+			var default: Variant = (
+				script.get_property_default_value(property)
+				if scripted.has(property)
+				else ClassDB.class_get_property_default_value(node.get_class(), property)
+			)
+			if PropertyValues.same(value, default):
+				continue
+		props[property] = _readable(node, value)
+	return props
+
+
+func _readable(node: Node, value: Variant) -> Variant:
+	if value is Node:
+		var target: Node = value
+		return _values.serialize_value(node.get_path_to(target))
+	if value is Array:
+		var items: Array = value
+		return items.map(func(item: Variant) -> Variant: return _readable(node, item))
+	return _values.serialize_value(value)
 
 
 func _parse_properties_arg(raw_properties: Variant) -> Dictionary:
@@ -133,20 +217,6 @@ func _parse_properties_arg(raw_properties: Variant) -> Dictionary:
 	return {}
 
 
-func _ensure_parent_dir_for_scene(scene_path: String) -> void:
-	var base_dir: String = scene_path.get_base_dir()
-	if not DirAccess.dir_exists_absolute(base_dir):
-		var made: Error = DirAccess.make_dir_recursive_absolute(base_dir)
-		if made != OK:
-			push_error("gdharness: could not create " + base_dir + ": " + error_string(made))
-
-
-func _set_owner_recursive(node: Node, scene_owner: Node) -> void:
-	node.owner = scene_owner
-	for child: Node in node.get_children():
-		_set_owner_recursive(child, scene_owner)
-
-
 func _build_node_tree(
 	node: Node, include_properties: bool, depth: int, current_depth: int, node_path: String
 ) -> Dictionary:
@@ -156,15 +226,7 @@ func _build_node_tree(
 	}
 
 	if include_properties:
-		var props: Dictionary = {}
-		for p: Dictionary in node.get_property_list():
-			if not (Read.as_int(p.get("usage", 0)) & PROPERTY_USAGE_STORAGE):
-				continue
-			var pn: String = str(p.get("name", ""))
-			if pn.is_empty():
-				continue
-			props[pn] = _values.serialize_value(node.get(pn))
-		data["properties"] = props
+		data["properties"] = _properties_of(node, true, {})
 
 	if depth >= 0 and current_depth >= depth:
 		return data
@@ -193,27 +255,53 @@ func create_scene(args: Dictionary) -> Dictionary:
 		return {"ok": false, "error": "Missing scenePath"}
 	if not scene_path.ends_with(".tscn"):
 		scene_path += ".tscn"
-	if not ClassDB.class_exists(root_node_type):
-		return {"ok": false, "error": "Invalid rootNodeType: " + root_node_type}
-
-	_ensure_parent_dir_for_scene(scene_path)
+	# 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"):
+		return {
+			"ok": false, "error": "rootNodeType must be a node class, and %s is not one." % root_node_type
+		}
+	if not ClassDB.can_instantiate(root_node_type):
+		return {"ok": false, "error": "%s cannot be instantiated." % root_node_type}
+	# Saving over a scene that is there replaced it, nodes and all, and answered as a new scene.
+	if FileAccess.file_exists(scene_path):
+		return {
+			"ok": false,
+			"error":
+			(
+				(
+					"%s already exists, and scene_create op=create would replace everything in it. Edit it "
+					+ "with scene_node, or create the scene under another path."
+				)
+				% scene_path
+			)
+		}
 
 	var root: Node = ClassDB.instantiate(root_node_type)
-	if not root:
-		return {"ok": false, "error": "Failed to instantiate root node: " + root_node_type}
 	root.name = root_node_type
 
 	if not script_path.is_empty():
 		var full_script_path: String = _to_scene_res_path(project_path, script_path)
-		var script: Resource = load(full_script_path)
-		if not script:
-			root.queue_free()
-			return {"ok": false, "error": "Failed to load script: " + full_script_path}
+		var script: Script = load(full_script_path) as Script
+		if script == null:
+			root.free()
+			return {"ok": false, "error": "No script loads from " + full_script_path}
+		var base: String = str(script.get_instance_base_type())
+		if not ClassDB.is_parent_class(root_node_type, base):
+			root.free()
+			return {
+				"ok": false,
+				"error":
+				"%s extends %s, so it cannot be on a %s root." % [full_script_path, base, root_node_type]
+			}
 		root.set_script(script)
 
-	var err: Dictionary = _save_scene(root, scene_path)
-	if not err.is_empty():
-		return err
+	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}
 
@@ -224,15 +312,15 @@ func list_scene_nodes(args: Dictionary) -> Dictionary:
 	var depth: int = Read.as_int(args.get("depth", -1), -1)
 	var include_properties: bool = Read.as_bool(args.get("includeProperties", false))
 
-	var loaded: Array = _load_scene(scene_path)
-	var refused: Dictionary = loaded[1]
+	var opened: Array = _open(scene_path, false)
+	var scene: SceneFile = opened[0]
+	var refused: Dictionary = opened[1]
 	if not refused.is_empty():
 		return refused
 
-	var root: Node = loaded[0]
-	var tree: Dictionary = _build_node_tree(root, include_properties, depth, 0, ".")
-	root.queue_free()
-	return {"ok": true, "tree": tree}
+	var tree: Dictionary = _build_node_tree(scene.root, include_properties, depth, 0, ".")
+	scene.close()
+	return {"ok": true, "tree": tree, "unsavedInEditor": SceneFile.unsaved(scene_path)}
 
 
 func add_node(args: Dictionary) -> Dictionary:
@@ -245,40 +333,45 @@ func add_node(args: Dictionary) -> Dictionary:
 
 	if node_type.is_empty() or node_name.is_empty():
 		return {"ok": false, "error": "Missing nodeType or nodeName"}
-	if not ClassDB.class_exists(node_type):
-		return {"ok": false, "error": "Invalid nodeType: " + node_type}
-
-	var loaded: Array = _load_scene(scene_path)
-	var refused: Dictionary = loaded[1]
+	if not ClassDB.class_exists(node_type) or not ClassDB.is_parent_class(node_type, "Node"):
+		return {"ok": false, "error": "nodeType must be a node class, and %s is not one." % node_type}
+	if not ClassDB.can_instantiate(node_type):
+		return {"ok": false, "error": "%s cannot be instantiated." % node_type}
+
+	var opened: Array = _open(scene_path, true)
+	var scene: SceneFile = opened[0]
+	var refused: Dictionary = opened[1]
 	if not refused.is_empty():
 		return refused
 
-	var root: Node = loaded[0]
+	var root: Node = scene.root
 	var parent: Node = _find_node(root, parent_node_path)
 	if not parent:
-		root.queue_free()
-		return {"ok": false, "error": "Parent node not found: " + parent_node_path}
-
+		return scene.refuse("Parent node not found: " + parent_node_path)
+	var foreign: String = scene.foreign(parent)
+	if not foreign.is_empty():
+		return scene.refuse(foreign)
+	var unusable: String = scene.unusable_name(parent, node_name)
+	if not unusable.is_empty():
+		return scene.refuse(unusable)
+
+	# In the tree before its properties, so a property holding a node can find it by path.
 	var new_node: Node = ClassDB.instantiate(node_type)
-	if not new_node:
-		root.queue_free()
-		return {"ok": false, "error": "Failed to instantiate nodeType: " + node_type}
-
 	new_node.name = node_name
-	var refused_property: String = _set_node_properties(new_node, properties)
-	if not refused_property.is_empty():
-		new_node.queue_free()
-		root.queue_free()
-		return {"ok": false, "error": refused_property}
-
 	parent.add_child(new_node)
-	_set_owner_recursive(new_node, root)
+	_own(new_node, root)
+	var refused_property: String = _properties.write_all(new_node, properties)
+	if not refused_property.is_empty():
+		return scene.refuse(refused_property)
 
-	var err: Dictionary = _save_scene(root, scene_path)
-	if not err.is_empty():
-		return err
+	var new_path: String = scene.path_of(new_node)
+	var written: Dictionary = scene.write(
+		func(saved: Node) -> String: return _kept(scene, saved, new_node, properties.keys())
+	)
+	if not written.is_empty():
+		return written
 
-	return {"ok": true, "nodeName": node_name, "nodeType": node_type}
+	return {"ok": true, "nodeName": node_name, "nodeType": node_type, "nodePath": new_path}
 
 
 func delete_node(args: Dictionary) -> Dictionary:
@@ -289,30 +382,33 @@ func delete_node(args: Dictionary) -> Dictionary:
 	if node_path.is_empty() or node_path == ".":
 		return {"ok": false, "error": "Cannot delete root node"}
 
-	var loaded: Array = _load_scene(scene_path)
-	var refused: Dictionary = loaded[1]
+	var opened: Array = _open(scene_path, true)
+	var scene: SceneFile = opened[0]
+	var refused: Dictionary = opened[1]
 	if not refused.is_empty():
 		return refused
 
-	var root: Node = loaded[0]
-	var node: Node = _find_node(root, node_path)
+	var node: Node = _find_node(scene.root, node_path)
 	if not node:
-		root.queue_free()
-		return {"ok": false, "error": "Node not found: " + node_path}
-
-	var parent: Node = node.get_parent()
-	if not parent:
-		root.queue_free()
-		return {"ok": false, "error": "Cannot delete root node"}
+		return scene.refuse("Node not found: " + node_path)
+	var fixed: String = scene.fixed(node)
+	if not fixed.is_empty():
+		return scene.refuse(fixed)
 
-	parent.remove_child(node)
-	node.queue_free()
+	var at: String = scene.path_of(node)
+	node.get_parent().remove_child(node)
+	node.free()
 
-	var err: Dictionary = _save_scene(root, scene_path)
-	if not err.is_empty():
-		return err
+	var written: Dictionary = scene.write(
+		func(saved: Node) -> String:
+			if saved.get_node_or_null(at) != null:
+				return "%s would still be in the scene when it loads." % at
+			return ""
+	)
+	if not written.is_empty():
+		return written
 
-	return {"ok": true, "deletedNodePath": node_path}
+	return {"ok": true, "deletedNodePath": at}
 
 
 func duplicate_node(args: Dictionary) -> Dictionary:
@@ -325,38 +421,55 @@ func duplicate_node(args: Dictionary) -> Dictionary:
 	if node_path.is_empty() or new_name.is_empty():
 		return {"ok": false, "error": "Missing nodePath or newName"}
 
-	var loaded: Array = _load_scene(scene_path)
-	var refused: Dictionary = loaded[1]
+	var opened: Array = _open(scene_path, true)
+	var scene: SceneFile = opened[0]
+	var refused: Dictionary = opened[1]
 	if not refused.is_empty():
 		return refused
 
-	var root: Node = loaded[0]
+	var root: Node = scene.root
 	var source: Node = _find_node(root, node_path)
 	if not source:
-		root.queue_free()
-		return {"ok": false, "error": "Node not found: " + node_path}
+		return scene.refuse("Node not found: " + node_path)
+	if source == root:
+		return scene.refuse("The root of %s cannot be copied into its own scene." % scene_path)
+	var foreign: String = scene.foreign(source)
+	if not foreign.is_empty():
+		return scene.refuse(foreign)
 
 	var target_parent: Node = source.get_parent()
 	if not parent_path.is_empty():
 		target_parent = _find_node(root, parent_path)
 	if not target_parent:
-		root.queue_free()
-		return {"ok": false, "error": "Parent not found: " + parent_path}
-
-	var duplicated_node: Node = source.duplicate()
+		return scene.refuse("Parent not found: " + parent_path)
+	foreign = scene.foreign(target_parent)
+	if not foreign.is_empty():
+		return scene.refuse(foreign)
+	var unusable: String = scene.unusable_name(target_parent, new_name)
+	if not unusable.is_empty():
+		return scene.refuse(unusable)
+
+	var copies: Dictionary = {}
+	var duplicated_node: Node = _copy(source, root, copies)
 	if not duplicated_node:
-		root.queue_free()
-		return {"ok": false, "error": "Failed to duplicate node: " + node_path}
+		return scene.refuse("Failed to duplicate node: " + node_path)
 
 	duplicated_node.name = new_name
 	target_parent.add_child(duplicated_node)
-	_set_owner_recursive(duplicated_node, root)
+	_own(duplicated_node, root)
+	_reconnect(copies, source)
 
-	var err: Dictionary = _save_scene(root, scene_path)
-	if not err.is_empty():
-		return err
+	var new_path: String = scene.path_of(duplicated_node)
+	var written: Dictionary = scene.write(
+		func(saved: Node) -> String:
+			if saved.get_node_or_null(new_path) == null:
+				return "the copy would not be in the scene when it loads."
+			return ""
+	)
+	if not written.is_empty():
+		return written
 
-	return {"ok": true, "nodePath": node_path, "newName": new_name}
+	return {"ok": true, "nodePath": node_path, "newName": new_name, "newNodePath": new_path}
 
 
 func reparent_node(args: Dictionary) -> Dictionary:
@@ -370,35 +483,53 @@ func reparent_node(args: Dictionary) -> Dictionary:
 	if new_parent_path.is_empty():
 		return {"ok": false, "error": "Missing newParentPath"}
 
-	var loaded: Array = _load_scene(scene_path)
-	var refused: Dictionary = loaded[1]
+	var opened: Array = _open(scene_path, true)
+	var scene: SceneFile = opened[0]
+	var refused: Dictionary = opened[1]
 	if not refused.is_empty():
 		return refused
 
-	var root: Node = loaded[0]
+	var root: Node = scene.root
 	var node: Node = _find_node(root, node_path)
 	var new_parent: Node = _find_node(root, new_parent_path)
 	if not node:
-		root.queue_free()
-		return {"ok": false, "error": "Node not found: " + node_path}
+		return scene.refuse("Node not found: " + node_path)
 	if not new_parent:
-		root.queue_free()
-		return {"ok": false, "error": "New parent not found: " + new_parent_path}
-
-	var old_parent: Node = node.get_parent()
-	if not old_parent:
-		root.queue_free()
-		return {"ok": false, "error": "Cannot reparent root node"}
-
-	old_parent.remove_child(node)
+		return scene.refuse("New parent not found: " + new_parent_path)
+	var fixed: String = scene.fixed(node)
+	if not fixed.is_empty():
+		return scene.refuse(fixed)
+	# Removed first and then refused by add_child, the node and everything under it were saved as
+	# gone.
+	if new_parent == node or node.is_ancestor_of(new_parent):
+		return scene.refuse(
+			"%s cannot go under %s, which is itself or inside it." % [node_path, new_parent_path]
+		)
+	var foreign: String = scene.foreign(new_parent)
+	if not foreign.is_empty():
+		return scene.refuse(foreign)
+	var unusable: String = scene.unusable_name(new_parent, str(node.name), node)
+	if not unusable.is_empty():
+		return scene.refuse(unusable)
+
+	var old_path: String = scene.path_of(node)
+	node.get_parent().remove_child(node)
 	new_parent.add_child(node)
-	_set_owner_recursive(node, root)
+	_own(node, root)
 
-	var err: Dictionary = _save_scene(root, scene_path)
-	if not err.is_empty():
-		return err
+	var new_path: String = scene.path_of(node)
+	var written: Dictionary = scene.write(
+		func(saved: Node) -> String:
+			if saved.get_node_or_null(new_path) == null:
+				return "%s would not be in the scene when it loads." % new_path
+			if old_path != new_path and saved.get_node_or_null(old_path) != null:
+				return "%s would still be in the scene as well when it loads." % old_path
+			return ""
+	)
+	if not written.is_empty():
+		return written
 
-	return {"ok": true, "nodePath": node_path, "newParentPath": new_parent_path}
+	return {"ok": true, "nodePath": old_path, "newParentPath": new_parent_path, "newNodePath": new_path}
 
 
 func set_node_properties(args: Dictionary) -> Dictionary:
@@ -407,27 +538,41 @@ func set_node_properties(args: Dictionary) -> Dictionary:
 	var node_path: String = str(args.get("nodePath", "."))
 	var properties: Dictionary = _parse_properties_arg(args.get("properties", {}))
 
-	var loaded: Array = _load_scene(scene_path)
-	var refused: Dictionary = loaded[1]
+	var opened: Array = _open(scene_path, true)
+	var scene: SceneFile = opened[0]
+	var refused: Dictionary = opened[1]
 	if not refused.is_empty():
 		return refused
 
-	var root: Node = loaded[0]
-	var node: Node = _find_node(root, node_path)
+	var node: Node = _find_node(scene.root, node_path)
 	if not node:
-		root.queue_free()
-		return {"ok": false, "error": "Node not found: " + node_path}
-
-	var refused_property: String = _set_node_properties(node, properties)
+		return scene.refuse("Node not found: " + node_path)
+	var foreign: String = scene.foreign(node)
+	if not foreign.is_empty():
+		return scene.refuse(foreign)
+	if properties.has("name") and node != scene.root:
+		var fixed: String = scene.fixed(node)
+		if not fixed.is_empty():
+			return scene.refuse(fixed)
+		var unusable: String = scene.unusable_name(node.get_parent(), str(properties["name"]), node)
+		if not unusable.is_empty():
+			return scene.refuse(unusable)
+
+	var refused_property: String = _properties.write_all(node, properties)
 	if not refused_property.is_empty():
-		root.queue_free()
-		return {"ok": false, "error": refused_property}
+		return scene.refuse(_missing_on(node, refused_property))
 
-	var err: Dictionary = _save_scene(root, scene_path)
-	if not err.is_empty():
-		return err
+	var held: Dictionary = {}
+	for key: Variant in properties:
+		held[str(key)] = _readable(node, node.get(str(key)))
+	var new_path: String = scene.path_of(node)
+	var written: Dictionary = scene.write(
+		func(saved: Node) -> String: return _kept(scene, saved, node, properties.keys())
+	)
+	if not written.is_empty():
+		return written
 
-	return {"ok": true, "nodePath": node_path}
+	return {"ok": true, "nodePath": new_path, "properties": held}
 
 
 func get_node_properties(args: Dictionary) -> Dictionary:
@@ -436,40 +581,28 @@ func get_node_properties(args: Dictionary) -> Dictionary:
 	var node_path: String = str(args.get("nodePath", "."))
 	var include_defaults: bool = Read.as_bool(args.get("includeDefaults", false))
 
-	var loaded: Array = _load_scene(scene_path)
-	var refused: Dictionary = loaded[1]
+	var opened: Array = _open(scene_path, false)
+	var scene: SceneFile = opened[0]
+	var refused: Dictionary = opened[1]
 	if not refused.is_empty():
 		return refused
 
-	var root: Node = loaded[0]
-	var node: Node = _find_node(root, node_path)
+	var node: Node = _find_node(scene.root, node_path)
 	if not node:
-		root.queue_free()
-		return {"ok": false, "error": "Node not found: " + node_path}
-
-	var defaults: Node = null
-	if not include_defaults and ClassDB.class_exists(node.get_class()):
-		defaults = ClassDB.instantiate(node.get_class())
-
-	var props: Dictionary = {}
-	for p: Dictionary in node.get_property_list():
-		var usage: int = Read.as_int(p.get("usage", 0))
-		if not (usage & PROPERTY_USAGE_STORAGE):
-			continue
-		var prop_name: String = str(p.get("name", ""))
-		if prop_name.is_empty():
-			continue
-		var current_val: Variant = node.get(prop_name)
-		if not include_defaults and defaults:
-			var default_val: Variant = defaults.get(prop_name)
-			if current_val == default_val:
-				continue
-		props[prop_name] = _values.serialize_value(current_val)
-
-	if defaults:
-		defaults.queue_free()
-	root.queue_free()
-	return {"ok": true, "nodePath": node_path, "properties": props}
+		return scene.refuse("Node not found: " + node_path)
+
+	# Against the default the node would have in no scene: its script's for what the script
+	# declares, the class's for the rest. Compared with a bare instance of the class, every exported
+	# variable read as changed; and a value this scene sets back to the default was hidden, so the
+	# names this scene's file sets are always answered.
+	var props: Dictionary = _properties_of(node, include_defaults, scene.set_here(node))
+	scene.close()
+	return {
+		"ok": true,
+		"nodePath": node_path,
+		"properties": props,
+		"unsavedInEditor": SceneFile.unsaved(scene_path)
+	}
 
 
 func save_scene(args: Dictionary) -> Dictionary:
@@ -480,18 +613,69 @@ func save_scene(args: Dictionary) -> Dictionary:
 	if not new_path_raw.is_empty():
 		target_path = _to_scene_res_path(project_path, new_path_raw)
 
-	var loaded: Array = _load_scene(scene_path)
-	var refused: Dictionary = loaded[1]
-	if not refused.is_empty():
-		return refused
+	if target_path != scene_path:
+		var unsaved: String = SceneFile.unsaved_in_editor(target_path)
+		if not unsaved.is_empty():
+			return {"ok": false, "error": unsaved}
+
+	var open_root: Node = null
+	for open: Node in EditorInterface.get_open_scene_roots():
+		if open.scene_file_path == scene_path:
+			open_root = open
+	if open_root != null and target_path == scene_path:
+		return _save_open_scene(scene_path)
+
+	# Of the editor's scene when it is open, since that is what a save means, and of the file as it
+	# loads otherwise. The editor's scene is packed where it is, as the editor's own save packs it;
+	# packing leaves the nodes as they were.
+	var written: Dictionary = {}
+	if open_root != null:
+		var packed: PackedScene = PackedScene.new()
+		var packing: Error = packed.pack(open_root)
+		if packing != OK:
+			return {"ok": false, "error": "Failed to pack %s: %s" % [scene_path, error_string(packing)]}
+		written = SceneFile.save_packed(packed, target_path)
+	else:
+		var scene: SceneFile = SceneFile.new()
+		var refused: Dictionary = scene.open(scene_path, false)
+		if not refused.is_empty():
+			return refused
+		scene.path = target_path
+		written = scene.write()
+	if not written.is_empty():
+		return written
 
-	_ensure_parent_dir_for_scene(target_path)
-	var root: Node = loaded[0]
-	var err: Dictionary = _save_scene(root, target_path)
-	if not err.is_empty():
-		return err
+	return {
+		"ok": true,
+		"scenePath": scene_path,
+		"savedPath": target_path,
+		"from": "editor" if open_root != null else "file"
+	}
 
-	return {"ok": true, "scenePath": scene_path, "savedPath": target_path}
+
+## Saves the editor's own copy of [param scene_path] through the editor, which is what its Save
+## does. Loading the file and writing it back, as this did, saved the disk version, and the reload
+## after it discarded every unsaved change in the editor.
+func _save_open_scene(scene_path: String) -> Dictionary:
+	var current: Node = EditorInterface.get_edited_scene_root()
+	var previous: String = current.scene_file_path if current != null else ""
+	if previous != scene_path:
+		EditorInterface.open_scene_from_path(scene_path)
+	var now: Node = EditorInterface.get_edited_scene_root()
+	if now == null or now.scene_file_path != scene_path:
+		return {"ok": false, "error": "The editor did not switch to %s to save it." % scene_path}
+	var saving: Error = EditorInterface.save_scene()
+	if not previous.is_empty() and previous != scene_path:
+		EditorInterface.open_scene_from_path(previous)
+	if saving != OK:
+		return {"ok": false, "error": "The editor failed to save %s: %s" % [scene_path, error_string(saving)]}
+	return {
+		"ok": true,
+		"scenePath": scene_path,
+		"savedPath": scene_path,
+		"from": "editor",
+		"unsavedInEditor": SceneFile.unsaved(scene_path)
+	}
 
 
 func connect_signal(args: Dictionary) -> Dictionary:
@@ -513,45 +697,94 @@ func connect_signal(args: Dictionary) -> Dictionary:
 	):
 		return {"ok": false, "error": "Missing required signal connection arguments"}
 
-	var loaded: Array = _load_scene(scene_path)
-	var refused: Dictionary = loaded[1]
+	var opened: Array = _open(scene_path, true)
+	var scene: SceneFile = opened[0]
+	var refused: Dictionary = opened[1]
 	if not refused.is_empty():
 		return refused
 
-	var root: Node = loaded[0]
-	var source: Node = _find_node(root, source_node_path)
-	var target: Node = _find_node(root, target_node_path)
-	if not source:
-		root.queue_free()
-		return {"ok": false, "error": "Source node not found: " + source_node_path}
-	if not target:
-		root.queue_free()
-		return {"ok": false, "error": "Target node not found: " + target_node_path}
-	if not source.has_signal(signal_name):
-		root.queue_free()
-		return {"ok": false, "error": "Signal not found on source: " + signal_name}
+	var ends: Array = _connection_ends(scene, source_node_path, signal_name, target_node_path)
+	if ends[0] == null:
+		return scene.refuse(str(ends[1]))
+	var source: Node = ends[0]
+	var target: Node = ends[1]
 
+	# Reconnected rather than left alone when the flags differ, so the connection saved is the one
+	# asked for. Left alone, the answer gave the flags asked for and the file kept the old ones.
 	var callable: Callable = Callable(target, method_name)
-	if not source.is_connected(signal_name, callable):
-		var connect_result: Error = source.connect(signal_name, callable, flags)
-		if connect_result != OK:
-			root.queue_free()
-			return {"ok": false, "error": "Failed to connect signal: " + error_string(connect_result)}
-
-	var err: Dictionary = _save_scene(root, scene_path)
-	if not err.is_empty():
-		return err
+	var method_found: bool = target.has_method(method_name)
+	if source.is_connected(signal_name, callable):
+		source.disconnect(signal_name, callable)
+	var connect_result: Error = source.connect(signal_name, callable, flags)
+	if connect_result != OK:
+		return scene.refuse("Failed to connect signal: " + error_string(connect_result))
+
+	var from: String = scene.path_of(source)
+	var to: String = scene.path_of(target)
+	var saved_flags: Array = [-1]
+	var written: Dictionary = scene.write(
+		func(saved: Node) -> String:
+			saved_flags[0] = _connection_flags(saved, from, signal_name, to, method_name)
+			if saved_flags[0] < 0:
+				return "the connection would not be in the scene when it loads."
+			return ""
+	)
+	if not written.is_empty():
+		return written
 
 	return {
 		"ok": true,
-		"sourceNodePath": source_node_path,
+		"sourceNodePath": from,
 		"signalName": signal_name,
-		"targetNodePath": target_node_path,
+		"targetNodePath": to,
 		"methodName": method_name,
-		"flags": flags
+		"flags": saved_flags[0],
+		# Connected either way, as the editor's own dialog allows, since the method may be written
+		# next; a caller told nothing learnt of a misspelt one only when the signal fired.
+		"methodFound": method_found
 	}
 
 
+## The two ends of a connection in [param scene], as [source, target], or [null, why not].
+func _connection_ends(
+	scene: SceneFile, source_node_path: String, signal_name: String, target_node_path: String
+) -> Array:
+	var source: Node = _find_node(scene.root, source_node_path)
+	var target: Node = _find_node(scene.root, target_node_path)
+	if not source:
+		return [null, "Source node not found: " + source_node_path]
+	if not target:
+		return [null, "Target node not found: " + target_node_path]
+	# pack drops a connection with either end inside an instanced scene, and the answer said it was
+	# made or removed.
+	for end: Node in [source, target]:
+		var foreign: String = scene.foreign(end)
+		if not foreign.is_empty():
+			return [null, foreign]
+	if not source.has_signal(signal_name):
+		return [null, _missing_on(source, "%s has no signal %s" % [source_node_path, signal_name])]
+	return [source, target]
+
+
+## The flags of the persistent connection from [param from]'s [param signal_name] to
+## [param method] on [param to] in the tree under [param root], or -1 when there is none.
+func _connection_flags(root: Node, from: String, signal_name: String, to: String, method: String) -> int:
+	var source: Node = root.get_node_or_null(from)
+	var target: Node = root.get_node_or_null(to)
+	if source == null or target == null or not source.has_signal(signal_name):
+		return -1
+	for conn: Dictionary in source.get_signal_connection_list(signal_name):
+		var flags: int = Read.as_int(conn.get("flags", 0))
+		var callable: Callable = conn.get("callable", Callable())
+		if (
+			flags & Object.CONNECT_PERSIST
+			and callable.get_object() == target
+			and str(callable.get_method()) == method
+		):
+			return flags
+	return -1
+
+
 func disconnect_signal(args: Dictionary) -> Dictionary:
 	var project_path: String = str(args.get("projectPath", ""))
 	var scene_path: String = _to_scene_res_path(project_path, str(args.get("scenePath", "")))
@@ -568,34 +801,42 @@ func disconnect_signal(args: Dictionary) -> Dictionary:
 	):
 		return {"ok": false, "error": "Missing required signal disconnection arguments"}
 
-	var loaded: Array = _load_scene(scene_path)
-	var refused: Dictionary = loaded[1]
+	var opened: Array = _open(scene_path, true)
+	var scene: SceneFile = opened[0]
+	var refused: Dictionary = opened[1]
 	if not refused.is_empty():
 		return refused
 
-	var root: Node = loaded[0]
-	var source: Node = _find_node(root, source_node_path)
-	var target: Node = _find_node(root, target_node_path)
-	if not source:
-		root.queue_free()
-		return {"ok": false, "error": "Source node not found: " + source_node_path}
-	if not target:
-		root.queue_free()
-		return {"ok": false, "error": "Target node not found: " + target_node_path}
-
-	var callable: Callable = Callable(target, method_name)
-	if source.is_connected(signal_name, callable):
-		source.disconnect(signal_name, callable)
-
-	var err: Dictionary = _save_scene(root, scene_path)
-	if not err.is_empty():
-		return err
+	var ends: Array = _connection_ends(scene, source_node_path, signal_name, target_node_path)
+	if ends[0] == null:
+		return scene.refuse(str(ends[1]))
+	var source: Node = ends[0]
+	var target: Node = ends[1]
+
+	var from: String = scene.path_of(source)
+	var to: String = scene.path_of(target)
+	# A connection that was never there saved the scene unchanged and answered as removed, so a
+	# typo in either name read as success.
+	if _connection_flags(scene.root, from, signal_name, to, method_name) < 0:
+		return scene.refuse(
+			"%s has no connection from %s.%s to %s.%s." % [scene_path, from, signal_name, to, method_name]
+		)
+	source.disconnect(signal_name, Callable(target, method_name))
+
+	var written: Dictionary = scene.write(
+		func(saved: Node) -> String:
+			if _connection_flags(saved, from, signal_name, to, method_name) >= 0:
+				return "the connection would still be in the scene when it loads."
+			return ""
+	)
+	if not written.is_empty():
+		return written
 
 	return {
 		"ok": true,
-		"sourceNodePath": source_node_path,
+		"sourceNodePath": from,
 		"signalName": signal_name,
-		"targetNodePath": target_node_path,
+		"targetNodePath": to,
 		"methodName": method_name
 	}
 
@@ -605,207 +846,60 @@ func list_connections(args: Dictionary) -> Dictionary:
 	var scene_path: String = _to_scene_res_path(project_path, str(args.get("scenePath", "")))
 	var filter_path: String = str(args.get("nodePath", ""))
 
-	var loaded: Array = _load_scene(scene_path)
-	var refused: Dictionary = loaded[1]
+	var opened: Array = _open(scene_path, false)
+	var scene: SceneFile = opened[0]
+	var refused: Dictionary = opened[1]
 	if not refused.is_empty():
 		return refused
 
-	var root: Node = loaded[0]
+	var root: Node = scene.root
+	var filtered: Node = null
+	if not filter_path.is_empty():
+		filtered = _find_node(root, filter_path)
+		if filtered == null:
+			return scene.refuse("Node not found: " + filter_path)
 	var nodes: Array = []
 	_collect_nodes_recursive(root, ".", nodes)
 
+	# Only persistent connections, which are the ones a scene file holds: a Container connects
+	# signals of each child to itself as the child is added, and those were answered as if the file
+	# held them. Matched on either end, since the filter is for connections involving the node.
 	var connections: Array = []
 	for entry: Dictionary in nodes:
 		var path: String = str(entry["path"])
-		if not filter_path.is_empty() and filter_path != path:
-			continue
 		var node: Node = entry["node"]
 		for signal_info: Dictionary in node.get_signal_list():
 			var signal_name: String = str(signal_info.get("name", ""))
 			if signal_name.is_empty():
 				continue
 			for conn: Dictionary in node.get_signal_connection_list(signal_name):
+				var flags: int = Read.as_int(conn.get("flags", 0))
+				if not flags & Object.CONNECT_PERSIST:
+					continue
 				var callable: Callable = conn.get("callable", Callable())
 				var target_obj: Object = callable.get_object()
+				if filtered != null and node != filtered and target_obj != filtered:
+					continue
 				var target_path: String = ""
+				var editable: bool = scene.foreign(node).is_empty()
 				if target_obj is Node:
 					target_path = str(root.get_path_to(target_obj as Node))
-				connections.append(
-					{
-						"sourceNodePath": path,
-						"signalName": signal_name,
-						"targetNodePath": target_path,
-						"methodName": str(callable.get_method()),
-						"flags": Read.as_int(conn.get("flags", 0))
-					}
+					editable = editable and scene.foreign(target_obj as Node).is_empty()
+				(
+					connections
+					. append(
+						{
+							"sourceNodePath": path,
+							"signalName": signal_name,
+							"targetNodePath": target_path,
+							"methodName": str(callable.get_method()),
+							"flags": flags,
+							# False for a connection an instanced scene makes inside itself, which only that
+							# scene can change.
+							"editable": editable
+						}
+					)
 				)
 
-	root.queue_free()
-	return {"ok": true, "connections": connections}
-
-
-## Rescan the project filesystem, and report whether a scan is still running.
-##
-## The editor rescans when its window regains focus, so a script written by anything other
-## than the editor stays invisible until someone clicks on Godot. Until then its
-## `class_name` is missing from the global class list and the language server reports every
-## use of it as an unknown type, which is godotengine/godot#42786.
-##
-## Returns as soon as the scan is queued rather than awaiting it, because the tool executor
-## takes a Dictionary and not a coroutine. Pass `statusOnly` to poll without starting
-## another scan.
-func rescan_filesystem(args: Dictionary) -> Dictionary:
-	if not _editor_plugin:
-		return {"ok": false, "error": "Editor plugin unavailable"}
-
-	var filesystem: EditorFileSystem = EditorInterface.get_resource_filesystem()
-	# Not over a scan or an import the editor is already running: a scan asked for then starts a
-	# second reimport over the first, and the editor logs "Task 'reimport' already exists" and two
-	# conditions from its progress dialog. Declined and said, so the caller waits and asks again.
-	var busy: bool = filesystem.is_scanning() or filesystem.is_importing()
-	var started: bool = false
-	var completed_before: int = _scans_completed
-	var uids: Dictionary = {"reread": [], "duplicated": []}
-	if not Read.as_bool(args.get("statusOnly", false)) and not busy:
-		uids = _reread_changed_uids(filesystem)
-		filesystem.scan()
-		# Whether the scan ran, read off the editor rather than assumed. `scan()` returns without
-		# a word while the thread of the scan before is still to be joined, which is a frame or
-		# more after that scan stops reporting itself, and that scan then signals as it is joined.
-		# Taken as started, the answer came from a scan begun before the files were written:
-		# downstream, a rescan after 698 files were rewritten answered finished in 1.5s and the
-		# one changed file stayed on its old import. A threaded scan reports itself from inside
-		# the call, and one run on this thread has finished and signalled before it returns.
-		started = filesystem.is_scanning() or _scans_completed != completed_before
-
-	# Importing is reported separately from scanning, and a class is not registered until
-	# both are done, so a caller watching only one of them can look too early. The two counts are
-	# what a caller waits on: the scan it asked for is over once the count has moved past the one
-	# from before it was asked.
-	return {
-		"ok": true,
-		"started": started,
-		"scanning": filesystem.is_scanning(),
-		"importing": filesystem.is_importing(),
-		"scansCompletedBefore": completed_before,
-		"scansCompleted": _scans_completed,
-		"uidsReread": uids["reread"],
-		"uidsDuplicatedOnDisk": uids["duplicated"],
-	}
-
-
-## Has the editor read again every file whose `.uid` names a UID the editor does not hold for it.
-##
-## The scan re-reads a file when the file changes and not when only the `.uid` beside it does, so a
-## script copied with its `.uid` and then given a fresh one keeps the copied UID in the editor, and
-## every headless engine reading the editor's cache warns of a duplicate. Measured on 4.7.2: a scan
-## after the `.uid` was rewritten left both scripts on one UID in the cache. What the editor holds
-## is read off its UID table, which maps each UID to one path, so a `.uid` whose UID is missing from
-## the table or mapped to another file is one the editor has not taken in.
-##
-## Two files on disk naming one UID are left alone and named: reading them again cannot settle
-## which of them owns it, and doing it on every scan would only move the UID between them.
-func _reread_changed_uids(filesystem: EditorFileSystem) -> Dictionary:
-	var sidecars: Array[String] = []
-	_uid_files("res://", sidecars)
-	var claimed: Dictionary = {}
-	for sidecar: String in sidecars:
-		var id: int = ResourceUID.text_to_id(FileAccess.get_file_as_string(sidecar).strip_edges())
-		var path: String = sidecar.trim_suffix(".uid")
-		if id == ResourceUID.INVALID_ID or not FileAccess.file_exists(path):
-			continue
-		var paths: Array = claimed.get_or_add(id, [])
-		paths.append(path)
-	var reread: Array[String] = []
-	var duplicated: Array[Array] = []
-	for id: int in claimed:
-		var paths: Array = claimed[id]
-		if paths.size() > 1:
-			paths.sort()
-			duplicated.append(paths)
-			continue
-		var path: String = str(paths[0])
-		if ResourceUID.has_id(id) and ResourceUID.get_id_path(id) == path:
-			continue
-		filesystem.update_file(path)
-		reread.append(path)
-	reread.sort()
-	duplicated.sort()
-	return {"reread": reread, "duplicated": duplicated}
-
-
-## Every `.uid` under [param directory], skipping what the editor skips: hidden directories, any
-## holding a `.gdignore`, and any below the project's own that holds a `project.godot` of its own,
-## which the editor passes over as another project. A nested project's UIDs are never in the editor's
-## table, so without that last one its files would be read again on every rescan, and one holding a
-## copy of an outer file's `.uid` named as a duplicate on disk.
-func _uid_files(directory: String, found: Array[String]) -> void:
-	var listing: DirAccess = DirAccess.open(directory)
-	if listing == null or FileAccess.file_exists(directory.path_join(".gdignore")):
-		return
-	if directory != "res://" and FileAccess.file_exists(directory.path_join("project.godot")):
-		return
-	for child: String in listing.get_directories():
-		if not child.begins_with("."):
-			_uid_files(directory.path_join(child), found)
-	for file: String in listing.get_files():
-		if file.ends_with(".uid"):
-			found.append(directory.path_join(file))
-
-
-## Whether the editor is scanning, and how long ago its last scan finished, without asking for one.
-##
-## For a caller about to start a game: the editor rewrites the class cache a frame after a scan
-## stops reporting, so a game booted during the scan or in that frame reads a file being rewritten.
-## Apart from `rescan_filesystem` because asking must not start or count anything.
-func scan_status(_args: Dictionary) -> Dictionary:
-	if not _editor_plugin:
-		return {"ok": false, "error": "Editor plugin unavailable"}
-	var filesystem: EditorFileSystem = EditorInterface.get_resource_filesystem()
-	return {
-		"ok": true,
-		"scanning": filesystem.is_scanning(),
-		"importing": filesystem.is_importing(),
-		"sinceScanFinishedMs":
-		-1 if _scan_finished_at_msec < 0 else Time.get_ticks_msec() - _scan_finished_at_msec,
-		"reimportsCompleted": _reimports_completed,
-	}
-
-
-## Reimport the files named under `paths`, whatever their state, the way the editor's Reimport
-## button does, and report whether the reimport was started.
-##
-## Started on the next frame rather than run here: the editor imports on its main thread, and a
-## reimport of a few hundred scenes outlasts the wait on any one command. The caller waits for
-## `reimportsCompleted` in [method scan_status] to move past `reimportsCompletedBefore`. Declined
-## while the editor scans or imports, since `reimport_files` refuses to run inside an import.
-func reimport_files(args: Dictionary) -> Dictionary:
-	if not _editor_plugin:
-		return {"ok": false, "error": "Editor plugin unavailable"}
-	var paths: Array[String] = []
-	var given: Variant = args.get("paths", [])
-	if given is Array:
-		for path: Variant in given:
-			paths.append(str(path))
-	if paths.is_empty():
-		return {"ok": false, "error": "reimport_files needs paths"}
-	var filesystem: EditorFileSystem = EditorInterface.get_resource_filesystem()
-	var busy: bool = filesystem.is_scanning() or filesystem.is_importing()
-	if not busy:
-		_reimport.call_deferred(PackedStringArray(paths))
-	return {
-		"ok": true,
-		"started": not busy,
-		"scanning": filesystem.is_scanning(),
-		"importing": filesystem.is_importing(),
-		"reimportsCompletedBefore": _reimports_completed,
-	}
-
-
-func _reimport(paths: PackedStringArray) -> void:
-	var filesystem: EditorFileSystem = EditorInterface.get_resource_filesystem()
-	# A scan can begin between the answer and this frame, and its import would refuse this one.
-	while filesystem.is_scanning() or filesystem.is_importing():
-		await get_tree().process_frame
-	filesystem.reimport_files(paths)
-	_reimports_completed += 1
+	scene.close()
+	return {"ok": true, "connections": connections, "unsavedInEditor": SceneFile.unsaved(scene_path)}