gdharness 1.2.32 → 1.2.34

package/build/cli.js

@@ -7847,6 +7847,11 @@ function isWithinRoot(rootPath, candidatePath) {
   const step = relative(resolve(rootPath), resolve(candidatePath));
   return step !== ".." && !step.startsWith(`..${sep}`) && !isAbsolute(step);
 }
+function keptInside(given) {
+  const at = given.indexOf("::");
+  const inner = at === -1 ? "" : given.slice(at + 2);
+  return KEPT_ID.test(inner) ? { file: given.slice(0, at), inner } : { file: given, inner: undefined };
+}
 function resolveWithinProject(projectPath, candidatePath, options = {}) {
   const trimmed = candidatePath.trim();
   if (trimmed === "") {
@@ -7875,6 +7880,13 @@ function resolveWithinProject(projectPath, candidatePath, options = {}) {
       reason: `Path '${trimmed}' is absolute; give a path inside the project, such as 'scenes/main.tscn'.`
     };
   }
+  const kept = keptInside(trimmed);
+  if (kept.inner !== undefined) {
+    return {
+      ok: false,
+      reason: `Path '${trimmed}' names the resource ${kept.inner} kept inside ${kept.file}, not a file. resource_edit read reads one by that path; this argument takes a file.`
+    };
+  }
   if (withoutScheme.includes(":")) {
     return {
       ok: false,
@@ -7917,9 +7929,10 @@ function exportedBuild(projectPath, candidatePath) {
   }
   return { ok: true, absolutePath: real, relativePath: found.relativePath };
 }
-var RESOURCE_SCHEME = "res://", OTHER_SCHEME;
+var RESOURCE_SCHEME = "res://", OTHER_SCHEME, KEPT_ID;
 var init_paths = __esm(() => {
   OTHER_SCHEME = /^[a-zA-Z][a-zA-Z\d+.-]+:\/\//;
+  KEPT_ID = /^[A-Za-z0-9_]+$/;
 });
 
 // src/runner.ts
@@ -11308,7 +11321,7 @@ var init_tool_definitions = __esm(() => {
     {
       name: "project_settings",
       title: "Project settings",
-      description: "Reads or writes project.godot: settings, autoloads, the main scene, input actions, plugins and audio buses. A write with an editor open on the project is handed to the editor, which takes the settings the write changed or names from the file (named under editorAdopted), including a setting the file already held, since the editor can hold another value after the file was put back, or reloads the bus layout, so it answers the new values and does not save the old ones back over them. editorNote is an editor that could not take the write, one on an addon from before this, which still holds the old values until editor_launch restart. An enabled plugin's code still loads on the editor's next start. set answers old_value and new_value, with was_new true when project.godot did not set the setting before, and was_default true when what it held was the engine's own default, which old_value then is. A set of the value the setting already holds, in the same type, writes nothing and answers unchanged true and saved false. Every write keeps the sections and keys of project.godot in the order the file had them, so a change touches only its own lines. get answers exists, true for any setting the engine knows, and at_default, true when the value is the engine's own default and so has no line in project.godot. Each setting under prefix carries at_default too, so a family read separates what the project sets from the engine's defaults; it is absent for a setting the engine registers no default for, such as an input action the project added, which only the project can have set.",
+      description: "Reads or writes project.godot: settings, autoloads, the main scene, input actions, plugins and audio buses. A write with an editor open on the project is handed to the editor, which takes the settings the write changed or names from the file (named under editorAdopted), including a setting the file already held, since the editor can hold another value after the file was put back, or reloads the bus layout, so it answers the new values and does not save the old ones back over them. editorNote is an editor that could not take the write, one on an addon from before this, which still holds the old values until editor_launch restart. An enabled plugin's code still loads on the editor's next start. set answers old_value and new_value, with was_new true when project.godot did not set the setting before, and was_default true when what it held was the engine's own default, which old_value then is. add_input_action on an action that exists, one of the engine's ui_ actions included, replaces its events and deadzone, and answers was_new false with what it held under old_events and old_deadzone. A set of the value the setting already holds, in the same type, writes nothing and answers unchanged true and saved false. Every write keeps the sections and keys of project.godot in the order the file had them, so a change touches only its own lines. get answers exists, true for any setting the engine knows, and at_default, true when the value is the engine's own default and so has no line in project.godot. Each setting under prefix carries at_default too, so a family read separates what the project sets from the engine's defaults; it is absent for a setting the engine registers no default for, such as an input action the project added, which only the project can have set.",
       parameters: {
         projectPath: PROJECT_PATH,
         setting: {
@@ -11406,8 +11419,8 @@ var init_tool_definitions = __esm(() => {
           requires: ["scenePath"]
         },
         add_input_action: {
-          effect: "additive",
-          summary: "register an input action and its events",
+          effect: "destructive",
+          summary: "register an input action and its events, or rebind one that exists",
           requires: ["actionName", "events"]
         },
         remove_input_action: {
@@ -11755,7 +11768,7 @@ var init_tool_definitions = __esm(() => {
     {
       name: "scene_animation",
       title: "Animations",
-      description: "Animations in an AnimationPlayer and states in an AnimationTree state machine. read answers with every track of an animation in the shape add_track takes, so a track read off one animation can be added to another. Needs the editor connected.",
+      description: "Animations in an AnimationPlayer and states in an AnimationTree state machine. read answers with every track of an animation in the shape add_track takes, so a track read off one animation can be added to another. read and read_states need no editor: one serving the project answers and says whether it holds unsaved changes to the scene, and with none a headless engine reads the file without running the scene's scripts. The ops that write need the editor connected.",
       parameters: {
         projectPath: PROJECT_PATH,
         scenePath: SCENE_PATH,
@@ -11787,7 +11800,11 @@ var init_tool_definitions = __esm(() => {
           ops: ["read_states", "add_state", "connect_states"],
           description: "The AnimationTree node."
         },
-        stateName: { type: "string", ops: ["add_state"], description: "add_state: the state to add." },
+        stateName: {
+          type: "string",
+          ops: ["add_state"],
+          description: "add_state: the state to add. It goes right of the rightmost state in the editor's graph, answered under position."
+        },
         stateMachinePath: {
           type: "string",
           ops: ["read_states", "add_state", "connect_states"],
@@ -11962,7 +11979,7 @@ var init_tool_definitions = __esm(() => {
         projectPath: PROJECT_PATH,
         resourcePath: {
           ...RESOURCE_PATH,
-          description: `${RESOURCE_FILE} move: a directory too.`
+          description: `${RESOURCE_FILE} move: a directory too. read: also a resource kept inside a scene or resource file, by the path a read answers a property holding it with, such as "res://hero.tscn::Animation_jump".`
         },
         resourceType: {
           type: "string",
@@ -46220,7 +46237,11 @@ class GodotServer {
       case "scene_create":
         return op === "create" ? await bridge("create_scene") : await bridge("save_scene");
       case "scene_tree":
-        return await this.readFromFile(args, "scenePath", "read_scene_tree", async () => await bridge("list_scene_nodes"));
+        return await this.readFromFile(args, "scenePath", "read_scene_tree", (file) => ({
+          scenePath: file,
+          depth: readNumber(args, "depth") ?? -1,
+          includeProperties: readBoolean(args, "includeProperties") ?? false
+        }), async () => await bridge("list_scene_nodes"));
       case "scene_node":
         switch (op) {
           case "add":
@@ -46250,9 +46271,17 @@ class GodotServer {
       case "scene_animation":
         switch (op) {
           case "read":
-            return await bridge("read_animations");
+            return await this.readFromFile(args, "scenePath", "read_animations", (file) => ({
+              scenePath: file,
+              playerNodePath: readNonEmptyString(args, "playerNodePath") ?? ".",
+              animationName: readString(args, "animationName") ?? ""
+            }), async () => await bridge("read_animations"));
           case "read_states":
-            return await bridge("read_animation_states");
+            return await this.readFromFile(args, "scenePath", "read_animation_states", (file) => ({
+              scenePath: file,
+              animTreePath: readString(args, "animTreePath") ?? "",
+              stateMachinePath: readString(args, "stateMachinePath") ?? ""
+            }), async () => await bridge("read_animation_states"));
           case "create":
             return await bridge("create_animation");
           case "add_track":
@@ -46279,8 +46308,14 @@ class GodotServer {
         switch (op) {
           case "move":
             return await this.handleMoveFile(args);
-          case "read":
-            return await this.readFromFile(args, "resourcePath", "read_resource", async () => await bridge("read_resource"));
+          case "read": {
+            const { file, inner } = keptInside(readString(args, "resourcePath") ?? "");
+            const kept = inner === undefined ? {} : { resourcePath: file, subResource: inner };
+            return await this.readFromFile({ ...args, ...kept }, "resourcePath", "read_resource", (found) => ({
+              resourcePath: inner === undefined ? found : `${found}::${inner}`,
+              includeDefaults: readBoolean(args, "includeDefaults") ?? false
+            }), async () => await bridge("read_resource", kept));
+          }
           case "create":
             return await bridge("create_resource");
           case "modify":
@@ -50670,7 +50705,7 @@ class GodotServer {
       ...leftChanged === undefined ? {} : { note: leftChanged }
     });
   }
-  async readFromFile(args, pathKey, operation, throughTheEditor) {
+  async readFromFile(args, pathKey, operation, paramsFor, throughTheEditor) {
     const project = this.project(args);
     if (!project.ok) {
       return project.response;
@@ -50688,17 +50723,11 @@ class GodotServer {
     if (file === null) {
       return this.createErrorResponse(`${pathKey} must name a file inside the project.`);
     }
-    const params = operation === "read_scene_tree" ? {
-      scenePath: file,
-      depth: readNumber(args, "depth") ?? -1,
-      includeProperties: readBoolean(args, "includeProperties") ?? false
-    } : { resourcePath: file, includeDefaults: readBoolean(args, "includeDefaults") ?? false };
-    const outcome = await this.operation(operation, params, projectPath);
+    const outcome = await this.operation(operation, paramsFor(file), projectPath);
     if (!outcome.ok) {
       return this.answer(outcome);
     }
     return this.jsonTextResponse({
-      ok: true,
       ...outcome.payload,
       readBy: "a headless engine, since no editor serves this project; unsaved changes in an editor are not seen",
       ...engineExtras(outcome)

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

@@ -0,0 +1,224 @@
+extends RefCounted
+
+## Animations and state machines read off their nodes: by the editor's tools from the scene it holds,
+## and by a headless engine with none connected from a bare node of the class given what the file
+## stores, which runs no script of the scene's, so a read answers the same either way.
+
+const FileReads = preload("file_reads.gd")
+const Serialisation = preload("serialisation.gd")
+
+const LOOP_MODE_NAMES: Dictionary[int, String] = {
+	Animation.LOOP_NONE: "none",
+	Animation.LOOP_LINEAR: "linear",
+	Animation.LOOP_PINGPONG: "pingpong",
+}
+const TRACK_TYPE_NAMES: Dictionary[int, String] = {
+	Animation.TYPE_VALUE: "property",
+	Animation.TYPE_POSITION_3D: "position_3d",
+	Animation.TYPE_ROTATION_3D: "rotation_3d",
+	Animation.TYPE_SCALE_3D: "scale_3d",
+	Animation.TYPE_BLEND_SHAPE: "blend_shape",
+	Animation.TYPE_METHOD: "method",
+	Animation.TYPE_BEZIER: "bezier",
+	Animation.TYPE_AUDIO: "audio",
+	Animation.TYPE_ANIMATION: "animation",
+}
+const SWITCH_MODE_NAMES: Dictionary[int, String] = {
+	AnimationNodeStateMachineTransition.SWITCH_MODE_IMMEDIATE: "immediate",
+	AnimationNodeStateMachineTransition.SWITCH_MODE_SYNC: "sync",
+	AnimationNodeStateMachineTransition.SWITCH_MODE_AT_END: "at_end",
+}
+
+
+## [method animations] of the AnimationPlayer at [param player_path] in the file [param scene_path].
+static func scene_animations(scene_path: String, player_path: String, animation_name: String) -> Dictionary:
+	var made: Array = _bare(scene_path, player_path, "AnimationPlayer")
+	if made[0] == null:
+		return made[1]
+	var player: AnimationPlayer = made[0]
+	var answer: Dictionary = animations(player, animation_name)
+	player.free()
+	return answer
+
+
+## [method states] of the AnimationTree at [param tree_path] in the file [param scene_path].
+static func scene_states(scene_path: String, tree_path: String, state_machine_path: String) -> Dictionary:
+	var made: Array = _bare(scene_path, tree_path, "AnimationTree")
+	if made[0] == null:
+		return made[1]
+	var tree: AnimationTree = made[0]
+	var answer: Dictionary = states(tree, state_machine_path)
+	tree.free()
+	return answer
+
+
+## A node of the class the file gives the node at [param node_path], holding every property the
+## files set but its script, as [node, null] or [null, refusal]. The caller frees it.
+static func _bare(scene_path: String, node_path: String, kind: String) -> Array:
+	var read: Dictionary = FileReads.scene_node(scene_path, node_path)
+	if not read.is_empty() and not read.get("ok", false):
+		return [null, read]
+	var type: String = str(read.get("type", ""))
+	if not ClassDB.class_exists(type) or not ClassDB.is_parent_class(type, kind):
+		return [null, {"ok": false, "error": "%s not found at: %s" % [kind, node_path]}]
+	var bare: Node = ClassDB.instantiate(type)
+	bare.name = str(read["name"])
+	var given: Dictionary = read["properties"]
+	for property: Variant in given:
+		if str(property) != "script":
+			bare.set(str(property), given[property])
+	return [bare, null]
+
+
+## The animations of [param player] with their lengths, or [param animation_name] whole when it is
+## given. A track comes back in the shape add_track takes, so one read here can be written to
+## another animation as it stands.
+static func animations(player: AnimationPlayer, animation_name: String) -> Dictionary:
+	if animation_name.is_empty():
+		var listed: Array[Dictionary] = []
+		for called: String in player.get_animation_list():
+			var listed_one: Animation = player.get_animation(StringName(called))
+			var summary: Dictionary = _summary(listed_one)
+			summary["animationName"] = called
+			summary["tracks"] = listed_one.get_track_count()
+			listed.append(summary)
+		return {"ok": true, "animations": listed}
+	if not player.has_animation(StringName(animation_name)):
+		var names: PackedStringArray = player.get_animation_list()
+		return {
+			"ok": false,
+			"error":
+			(
+				"%s has no animation %s. It has: %s."
+				% [player.name, animation_name, ", ".join(names) if not names.is_empty() else "none"]
+			)
+		}
+	var anim: Animation = player.get_animation(StringName(animation_name))
+	var answer: Dictionary = _summary(anim)
+	answer["ok"] = true
+	answer["animationName"] = animation_name
+	var tracks: Array[Dictionary] = []
+	var values: Serialisation = Serialisation.new()
+	for track: int in anim.get_track_count():
+		tracks.append(_track(anim, track, values))
+	answer["tracks"] = tracks
+	return answer
+
+
+static func _summary(anim: Animation) -> Dictionary:
+	return {
+		"length": anim.length,
+		"loopMode": LOOP_MODE_NAMES.get(anim.loop_mode, str(anim.loop_mode)),
+		"step": anim.step,
+	}
+
+
+static func _track(anim: Animation, track: int, values: Serialisation) -> Dictionary:
+	var kind: int = anim.track_get_type(track)
+	var path: NodePath = anim.track_get_path(track)
+	var shaped: Dictionary = {
+		"type": TRACK_TYPE_NAMES.get(kind, str(kind)), "nodePath": str(path.get_concatenated_names())
+	}
+	var property: String = str(path.get_concatenated_subnames())
+	if not property.is_empty():
+		shaped["property"] = property
+	var keyframes: Array[Dictionary] = []
+	var methods: Dictionary = {}
+	for key: int in anim.track_get_key_count(track):
+		var keyframe: Dictionary = {"time": anim.track_get_key_time(track, key)}
+		if kind == Animation.TYPE_METHOD:
+			var method: String = str(anim.method_track_get_name(track, key))
+			methods[method] = true
+			keyframe["method"] = method
+			keyframe["args"] = values.serialize_value(anim.method_track_get_params(track, key))
+		else:
+			keyframe["value"] = values.serialize_value(anim.track_get_key_value(track, key))
+		keyframes.append(keyframe)
+	# One method across every key is the track's, as add_track takes it. Keys calling different
+	# methods, which the editor can make and add_track cannot, keep their own.
+	if methods.size() == 1:
+		shaped["method"] = methods.keys()[0]
+		for keyframe: Dictionary in keyframes:
+			var _shared: bool = keyframe.erase("method")
+	shaped["keyframes"] = keyframes
+	return shaped
+
+
+## The state machine at a slash-separated path of nested state machine names in [param tree], or
+## null when any step of the path is not one. Every node in a tree of state machines is a state
+## machine itself, so the walk asks each step for the child by name and refuses anything else.
+static func state_machine(tree: AnimationTree, state_machine_path: String) -> AnimationNodeStateMachine:
+	if tree == null:
+		return null
+	var current: AnimationNodeStateMachine = tree.tree_root as AnimationNodeStateMachine
+	if state_machine_path == "root":
+		return current
+	for segment: String in state_machine_path.split("/", false):
+		if current == null or not current.has_node(StringName(segment)):
+			return null
+		current = current.get_node(StringName(segment)) as AnimationNodeStateMachine
+	return current
+
+
+## Why [method state_machine] found none at [param state_machine_path] in [param tree]: the step of
+## the path that failed, and what is there instead.
+static func no_machine(tree: AnimationTree, state_machine_path: String) -> String:
+	if tree == null or tree.tree_root == null:
+		return "The AnimationTree has no tree_root."
+	var current: AnimationNodeStateMachine = tree.tree_root as AnimationNodeStateMachine
+	if current == null:
+		return (
+			"The AnimationTree's tree_root is not a state machine: its type is %s."
+			% tree.tree_root.get_class()
+		)
+	var walked: PackedStringArray = []
+	for segment: String in state_machine_path.split("/", false):
+		var where: String = "the root state machine"
+		if not walked.is_empty():
+			where = "the state machine at " + "/".join(walked)
+		if not current.has_node(StringName(segment)):
+			var names: PackedStringArray = []
+			for state: StringName in current.get_node_list():
+				if state != &"Start" and state != &"End":
+					var _listed: bool = names.push_back(str(state))
+			var held: String = ", ".join(names) if not names.is_empty() else "none"
+			return (
+				"%s has no state %s. Its states are: %s."
+				% [where.to_upper()[0] + where.substr(1), segment, held]
+			)
+		var next: AnimationNode = current.get_node(StringName(segment))
+		if not next is AnimationNodeStateMachine:
+			return (
+				"The state %s in %s is not a state machine: its type is %s."
+				% [segment, where, next.get_class()]
+			)
+		current = next
+		var _walked: bool = walked.push_back(segment)
+	return "No state machine at " + state_machine_path
+
+
+## The states and transitions of the state machine at [param state_machine_path] in [param tree].
+static func states(tree: AnimationTree, state_machine_path: String) -> Dictionary:
+	var sm: AnimationNodeStateMachine = state_machine(tree, state_machine_path)
+	if sm == null:
+		return {"ok": false, "error": no_machine(tree, state_machine_path)}
+	var listed: Array[Dictionary] = []
+	for state: StringName in sm.get_node_list():
+		var node: AnimationNode = sm.get_node(state)
+		var entry: Dictionary = {"stateName": str(state), "type": node.get_class()}
+		if node is AnimationNodeAnimation:
+			var plays: AnimationNodeAnimation = node
+			entry["animationName"] = str(plays.animation)
+		listed.append(entry)
+	var transitions: Array[Dictionary] = []
+	for index: int in sm.get_transition_count():
+		var transition: AnimationNodeStateMachineTransition = sm.get_transition(index)
+		var shaped: Dictionary = {
+			"from": str(sm.get_transition_from(index)),
+			"to": str(sm.get_transition_to(index)),
+			"transitionType": SWITCH_MODE_NAMES.get(transition.switch_mode, str(transition.switch_mode)),
+		}
+		if not str(transition.advance_condition).is_empty():
+			shaped["advanceCondition"] = str(transition.advance_condition)
+		transitions.append(shaped)
+	return {"ok": true, "states": listed, "transitions": transitions}

package/build/godot/addons/gdharness_editor/animation_reads.gd.uid

@@ -0,0 +1 @@
+uid://c3calvdgcggh9

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

@@ -19,6 +19,30 @@ const Serialisation = preload("serialisation.gd")
 ## instances another scene and every stored property when [param include_properties] is set, the
 ## file's value or the default where it sets none. [param depth] -1 reads every level.
 static func scene_tree(scene_path: String, depth: int, include_properties: bool) -> Dictionary:
+	var laid: Dictionary = _laid(scene_path)
+	if not laid.get("ok", false):
+		return laid
+	var nodes: Dictionary = laid["nodes"]
+	return {"ok": true, "tree": _entry(nodes, ".", include_properties, depth, 0)}
+
+
+## The node at [param node_path] in [param scene_path] as {ok, name, type, properties}, laid as
+## [method scene_tree] lays it, with only the properties the files set; {} when the scene has no
+## node there, and a refusal when the file does not read as a scene.
+static func scene_node(scene_path: String, node_path: String) -> Dictionary:
+	var laid: Dictionary = _laid(scene_path)
+	if not laid.get("ok", false):
+		return laid
+	var nodes: Dictionary = laid["nodes"]
+	var path: String = _joined(".", node_path)
+	if not nodes.has(path):
+		return {}
+	var found: Dictionary = nodes[path]
+	return {"ok": true, "name": found["name"], "type": found["type"], "properties": found["properties"]}
+
+
+## Every node of [param scene_path] as {ok, nodes}, keyed by path, or a refusal.
+static func _laid(scene_path: String) -> Dictionary:
 	if not FileAccess.file_exists(scene_path):
 		return {"ok": false, "error": "Scene not found: " + scene_path}
 	# Loaded without naming the type, so a resource handed in by mistake loads as what it is and the
@@ -42,7 +66,7 @@ static func scene_tree(scene_path: String, depth: int, include_properties: bool)
 		return {"ok": false, "error": refused}
 	if not nodes.has("."):
 		return {"ok": false, "error": "%s holds no nodes" % scene_path}
-	return {"ok": true, "tree": _entry(nodes, ".", include_properties, depth, 0)}
+	return {"ok": true, "nodes": nodes}
 
 
 ## Lays the nodes of [param state] into [param nodes] under [param prefix], keyed by their path
@@ -192,12 +216,22 @@ static func _stored(type: String, given: Dictionary) -> Dictionary:
 ## What a resource file holds, in the form modify takes, so a value read here can be written back.
 ## Read from the file rather than a cached copy, since the file is what the writes change and what
 ## the project loads.
+##
+## [param res_path] may name a resource kept inside a file, as "res://hero.tscn::Animation_jump",
+## the path a property holding one is read back with.
 static func resource(res_path: String, include_defaults: bool) -> Dictionary:
-	if not FileAccess.file_exists(res_path):
-		return {"ok": false, "error": "No resource at " + res_path}
-	var loaded: Resource = ResourceLoader.load(res_path, "", ResourceLoader.CACHE_MODE_IGNORE)
+	var file: String = res_path.get_slice("::", 0)
+	if not FileAccess.file_exists(file):
+		return {"ok": false, "error": "No resource at " + file}
+	var loaded: Resource = ResourceLoader.load(file, "", ResourceLoader.CACHE_MODE_IGNORE)
 	if loaded == null:
-		return {"ok": false, "error": "%s did not load as a resource." % res_path}
+		return {"ok": false, "error": "%s did not load as a resource." % file}
+	if file != res_path:
+		var id: String = res_path.trim_prefix(file + "::")
+		var inner: Resource = _kept_in(loaded, file, id, {})
+		if inner == null:
+			return {"ok": false, "error": "%s keeps no resource with the id %s." % [file, id]}
+		loaded = inner
 	# A scene's own properties are its packed bundle, which says nothing a caller can use.
 	if loaded is PackedScene:
 		return {
@@ -235,3 +269,40 @@ static func resource(res_path: String, include_defaults: bool) -> Dictionary:
 	if script != null:
 		answer["script"] = script.resource_path
 	return answer
+
+
+## The resource [param file] keeps under [param id], found in [param value] or anything it holds.
+## The engine loads such a path only while the file is cached, and a read loads the file uncached,
+## so it is looked for among what the file holds. A resource of another file is neither taken nor
+## walked into: ids are unique only within one file, and a scene instancing another holds that
+## file's resources under ids of the other file's.
+static func _kept_in(value: Variant, file: String, id: String, seen: Dictionary) -> Resource:
+	if value is Resource:
+		var held: Resource = value
+		if seen.has(held.get_instance_id()):
+			return null
+		seen[held.get_instance_id()] = true
+		var at: String = held.resource_path
+		if not at.is_empty() and at.get_slice("::", 0) != file:
+			return null
+		if held.resource_scene_unique_id == id:
+			return held
+		for p: Dictionary in held.get_property_list():
+			if Read.as_int(p.get("usage", 0)) & PROPERTY_USAGE_STORAGE:
+				var found: Resource = _kept_in(held.get(str(p.get("name", ""))), file, id, seen)
+				if found != null:
+					return found
+	elif value is Array:
+		var items: Array = value
+		for item: Variant in items:
+			var found: Resource = _kept_in(item, file, id, seen)
+			if found != null:
+				return found
+	elif value is Dictionary:
+		var entries: Dictionary = value
+		for key: Variant in entries:
+			for side: Variant in [key, entries[key]]:
+				var found: Resource = _kept_in(side, file, id, seen)
+				if found != null:
+					return found
+	return null