gdharness 1.3.46 → 1.3.48

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

@@ -25,29 +25,41 @@ static func save_keeping_uid(resource: Resource, file_path: String) -> Error:
 	var marked: Error = ResourceSaver.set_uid(file_path, uid)
 	if marked != OK:
 		return marked
-	return _with_external_uids(file_path)
+	return _as_the_editor_writes(file_path)
 
 
-## Puts back the uid on each external resource the text file at [param file_path] names. Only the
-## editor's file system tells the saver a path's uid, so a headless save writes every reference by
-## path alone, and each breaks when the file it names is moved.
-static func _with_external_uids(file_path: String) -> Error:
+## Writes the text file at [param file_path] as the editor's save would have.
+##
+## Only the editor's file system tells the saver a path's uid, so a headless save writes every
+## reference by path alone, and each breaks when the file it names is moved: the uid is put back on
+## each external resource.
+##
+## The saver leaves out a shader parameter holding the default the renderer gives it, and a headless
+## engine's renderer gives none, so every parameter a ShaderMaterial never set was written as null.
+## Loading null clears the parameter, so the line changes nothing, and the editor drops it again.
+static func _as_the_editor_writes(file_path: String) -> Error:
 	if not (file_path.ends_with(".tscn") or file_path.ends_with(".tres")):
 		return OK
 	var lines: PackedStringArray = FileAccess.get_file_as_string(file_path).split("\n")
 	var pattern: RegEx = RegEx.create_from_string(' path="([^"]+)"')
+	var unset: RegEx = RegEx.create_from_string("^shader_parameter/\\S+ = null$")
+	var kept: PackedStringArray = []
 	var changed: bool = false
-	for at: int in lines.size():
-		var line: String = lines[at]
-		if not line.begins_with("[ext_resource ") or line.contains(' uid="'):
-			continue
-		var named: RegExMatch = pattern.search(line)
-		if named == null:
+	for line: String in lines:
+		if unset.search(line) != null:
+			changed = true
 			continue
-		var uid: String = reference_uid(named.get_string(1))
+		var named: RegExMatch = (
+			pattern.search(line)
+			if line.begins_with("[ext_resource ") and not line.contains(' uid="')
+			else null
+		)
+		var uid: String = "" if named == null else reference_uid(named.get_string(1))
 		if not uid.is_empty():
-			lines[at] = line.replace(' path="', uid + ' path="')
+			line = line.replace(' path="', uid + ' path="')
 			changed = true
+		var _added: bool = kept.append(line)
+	lines = kept
 	if not changed:
 		return OK
 	var file: FileAccess = FileAccess.open(file_path, FileAccess.WRITE)

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

@@ -137,13 +137,26 @@ func connect_animation_states(args: Dictionary) -> Dictionary:
 	sm.add_transition(StringName(from_state), StringName(to_state), transition)
 	if not sm.has_transition(StringName(from_state), StringName(to_state)):
 		return scene.refuse("The state machine did not take the transition.")
+	_tell_the_tree(sm)
 	var files: Dictionary = found[2]
-	return _finish(
-		scene,
-		Callable(),
-		files,
-		{ "ok": true, "from": from_state, "to": to_state, "advanceMode": advance_mode }
-	)
+	var made: Dictionary = {
+		"ok": true,
+		"from": from_state,
+		"to": to_state,
+		"transitionType": transition_type,
+		"advanceMode": advance_mode,
+	}
+	if not advance_condition.is_empty():
+		made["advanceCondition"] = advance_condition
+	return _finish(scene, Callable(), files, made)
+
+
+## Has the AnimationTree playing [param sm] list its parameters again. Adding or removing a
+## transition does not say the tree changed, so the save kept the parameters from before it: a
+## condition's parameter was written by the next call to change the machine, and a removed one's
+## stayed until then.
+static func _tell_the_tree(sm: AnimationNodeStateMachine) -> void:
+	var _told: Error = sm.emit_signal(&"tree_changed")
 
 
 ## Why [param sm] cannot take a transition from [param from_state] to [param to_state], or "".
@@ -270,6 +283,7 @@ func disconnect_animation_states(args: Dictionary) -> Dictionary:
 	sm.remove_transition(StringName(from_state), StringName(to_state))
 	if sm.has_transition(StringName(from_state), StringName(to_state)):
 		return scene.refuse("The state machine did not let go of the transition.")
+	_tell_the_tree(sm)
 	var files: Dictionary = found[2]
 	return _finish(
 		scene, Callable(), files, { "ok": true, "removed": { "from": from_state, "to": to_state } }

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

@@ -109,6 +109,9 @@ func add_animation_track(args: Dictionary) -> Dictionary:
 	if anim.track_get_type(track_idx) == Animation.TYPE_VALUE:
 		var mode: int = anim.value_track_get_update_mode(track_idx)
 		answer["update"] = GdhAnimationReads.UPDATE_MODE_NAMES.get(mode, str(mode))
+		var blended: int = anim.track_get_interpolation_type(track_idx)
+		answer["interpolation"] = GdhAnimationReads.INTERPOLATION_NAMES.get(blended, str(blended))
+		answer["loopWrap"] = anim.track_get_interpolation_loop_wrap(track_idx)
 	if built[3]:
 		answer["existingTrack"] = true
 	var replaced: Array = built[5]
@@ -165,6 +168,7 @@ func _add_track(
 	var kind: Animation.TrackType = Animation.TYPE_VALUE
 	var path: NodePath = NodePath(target_path)
 	var update: int = -1
+	var interpolation: int = -1
 	if track_type == "property":
 		var prop_name: String = str(track.get("property", ""))
 		if prop_name.is_empty():
@@ -175,6 +179,11 @@ func _add_track(
 		)
 		if named != null:
 			update = GdhRead.as_int(named)
+		var blended: Variant = GdhAnimationReads.INTERPOLATION_NAMES.find_key(
+			str(track.get("interpolation", ""))
+		)
+		if blended != null:
+			interpolation = GdhRead.as_int(blended)
 		var values: Array = _key_values(target, prop_name, keyframes)
 		if not values[0]:
 			return _not_added(str(values[1]))
@@ -196,6 +205,12 @@ func _add_track(
 				misfit = _key_misfit(target, method_name, arguments, index)
 		method_found = target.has_method(method_name)
 		kind = Animation.TYPE_METHOD
+		# A method key is called at its time and never blended, so neither has anything to set.
+		for blending: String in ["interpolation", "loopWrap"]:
+			if track.has(blending):
+				return _not_added(
+					"track.%s is for property tracks; a method key is not blended." % blending
+				)
 	else:
 		return _not_added(
 			(
@@ -250,6 +265,10 @@ func _add_track(
 			_as_the_editor_makes(anim, track_idx, player, target)
 	if update >= 0:
 		anim.value_track_set_update_mode(track_idx, update as Animation.UpdateMode)
+	if interpolation >= 0:
+		anim.track_set_interpolation_type(track_idx, interpolation as Animation.InterpolationType)
+	if track.has("loopWrap"):
+		anim.track_set_interpolation_loop_wrap(track_idx, GdhRead.as_bool(track["loopWrap"]))
 	for index: int in keyframes.size():
 		var keyframe: Dictionary = keyframes[index]
 		if anim.track_insert_key(track_idx, GdhRead.as_float(keyframe["time"]), keys[index]) < 0:

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

@@ -718,6 +718,15 @@ func set_node_properties(args: Dictionary) -> Dictionary:
 		if property != "name" and property in node and not named.has(property):
 			named.append(property)
 	var source: String = scene.values_from(node, old_path)
+	# Read before the write, which frees the node.
+	var unsaved: Array[String] = []
+	for declared: Dictionary in node.get_property_list():
+		var declared_name: String = str(declared.get("name", ""))
+		if (
+			named.has(declared_name)
+			and not GdhRead.as_int(declared.get("usage", 0)) & PROPERTY_USAGE_STORAGE
+		):
+			unsaved.append(declared_name)
 	var carried: GdhPaths = GdhPaths.new()
 	var _rewritten: int = carried.carry(
 		scene,
@@ -751,7 +760,7 @@ func set_node_properties(args: Dictionary) -> Dictionary:
 		answer["droppedNodes"] = dropped["nodes"]
 	_note_put_back(answer, scene, id, new_path)
 	_note_loads_as(answer, scene, new_path)
-	_note_left_out(answer, scene.written_pack, new_path, named, source)
+	_note_left_out(answer, scene.written_pack, new_path, named, unsaved, source)
 	if new_path != old_path:
 		answer.merge(GdhKin.follow(scene_path, old_path, new_path, carried))
 	return answer
@@ -793,9 +802,15 @@ static func _note_put_back(answer: Dictionary, scene: GdhSceneFile, id: int, at:
 
 ## Notes under notStored each of [param named] the file saved from [param pack] does not set on the
 ## node at [param at]: a set gave it the value the node has without it, so the packer leaves it out,
-## as the editor does, and it follows [param source], or its default, from then on.
+## as the editor does, and it follows [param source], or its default, from then on. [param unsaved]
+## are those of them the node never stores by name.
 static func _note_left_out(
-	answer: Dictionary, pack: PackedScene, at: String, named: Array[String], source: String
+	answer: Dictionary,
+	pack: PackedScene,
+	at: String,
+	named: Array[String],
+	unsaved: Array[String],
+	source: String
 ) -> void:
 	var stored: Dictionary = {}
 	var state: SceneState = pack.get_state()
@@ -803,9 +818,13 @@ static func _note_left_out(
 		if str(state.get_node_path(index)).trim_prefix("./") == at:
 			for property: int in state.get_node_property_count(index):
 				stored[str(state.get_node_property_name(index, property))] = true
+	# A property the file never holds by name, as a Control's position, which its offsets hold, is
+	# stored when what changed with it is.
+	var also: Dictionary = answer.get("alsoChanged", {})
+	var held_with_it: bool = also.keys().any(func(other: Variant) -> bool: return stored.has(other))
 	var left: Array[String] = []
 	for asked: String in named:
-		if not stored.has(asked):
+		if not stored.has(asked) and not (held_with_it and unsaved.has(asked)):
 			left.append(asked)
 	if left.is_empty():
 		return

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

@@ -160,7 +160,7 @@ func _hover(viewport: Viewport, point: Vector2) -> void:
 	var inside: Vector2 = container.get_global_transform_with_canvas().affine_inverse() * point
 	if container.stretch:
 		inside /= container.stretch_shrink
-	for child: Node in container.get_children():
+	for child: Node in container.get_children(true):
 		var shown: SubViewport = child as SubViewport
 		if shown != null and not shown.gui_disable_input:
 			_hover(shown, shown.get_final_transform().affine_inverse() * inside)
@@ -179,7 +179,7 @@ func _drop(viewport: Viewport, until: int) -> void:
 	var over: Control = instance_from_id(top) as Control
 	var container: SubViewportContainer = over as SubViewportContainer
 	if container != null:
-		for child: Node in container.get_children():
+		for child: Node in container.get_children(true):
 			var shown: SubViewport = child as SubViewport
 			if shown != null:
 				_drop(shown, 0)
@@ -264,7 +264,7 @@ func _pressed_at(viewport: Viewport, point: Vector2) -> Node:
 	var inside: Vector2 = container.get_global_transform_with_canvas().affine_inverse() * point
 	if container.stretch:
 		inside /= container.stretch_shrink
-	for child: Node in container.get_children():
+	for child: Node in container.get_children(true):
 		var shown: SubViewport = child as SubViewport
 		if shown != null and not shown.gui_disable_input:
 			var within: Node = _pressed_at(
@@ -277,9 +277,11 @@ func _pressed_at(viewport: Viewport, point: Vector2) -> Node:
 
 ## The controls [param node] holds that the engine keeps as roots of [param node]'s viewport: drawn
 ## on their own, or with no control above them. Not into another viewport, a window or a
-## SubViewport, whose controls are that one's.
+## SubViewport, whose controls are that one's. Internal children count, as they do for the engine,
+## though get_children leaves them out unless asked: a layer added with INTERNAL_MODE_BACK was
+## passed over, and the press predicted for the control under it.
 static func _gather_roots(node: Node, roots: Array[Control]) -> void:
-	for child: Node in node.get_children():
+	for child: Node in node.get_children(true):
 		if child is Viewport:
 			continue
 		var control: Control = child as Control
@@ -331,8 +333,8 @@ func _at(item: CanvasItem, point: Vector2, holder: Transform2D) -> Control:
 	var control: Control = item as Control
 	var local: Vector2 = matrix.affine_inverse() * point
 	if control == null or not control.is_clipping_contents() or _has_point(control, local):
-		for index: int in range(item.get_child_count() - 1, -1, -1):
-			var child: CanvasItem = item.get_child(index) as CanvasItem
+		for index: int in range(item.get_child_count(true) - 1, -1, -1):
+			var child: CanvasItem = item.get_child(index, true) as CanvasItem
 			if child == null or child.top_level:
 				continue
 			var found: Control = _at(child, point, matrix)

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

@@ -61,9 +61,16 @@ func get_tree(params: Dictionary) -> Dictionary:
 		return reached
 	var root: Node = reached["node"]
 
+	# A game whose first scene hands over to another shows a tree that names neither, so which
+	# scene is showing was guessed from the project's documentation.
+	var scene: Node = _host.get_tree().current_scene
+	var showing: Variant = null
+	if scene != null:
+		showing = { "path": str(scene.get_path()), "file": scene.scene_file_path }
 	return {
 		"type": "tree",
 		"root": _serialize_node_tree(root, 0, max_depth, include_properties, named),
+		"current_scene": showing,
 	}
 
 

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

@@ -17,6 +17,11 @@ const MOST_FRAMES: int = 600
 ## How long a wait for words leaves between looks, as a multiple of what the last look took: nine
 ## gives looking about a tenth of the time.
 const LOOKS_APART: int = 9
+## The longest a wait for words holds one of the game's frames while it looks, in microseconds: a
+## look over a screen too large to read in that time carries on in the next frame from where it
+## stopped. Read whole, a look over an interface of about 1,000 labels held a frame for 28ms every
+## few dozen, which a game logging its own frame times took for a hitch of its own.
+const LOOK_SLICE_USEC: int = 2000
 ## How a property wait compares what it reads with the value: equality by default, and order for a
 ## number that steps rather than lands, as a day counter on a fast clock goes from 31 to 34 between
 ## two looks and a wait for 32 never sees it.
@@ -785,9 +790,12 @@ static func _declared_slot(holder: Variant, named: String) -> Dictionary:
 ## looking takes about a tenth of the time. Every frame on a hall of 3,500 nodes held the game at a
 ## sixth of its frame rate, and its clock, which advances by the frame's delta, lost three quarters
 ## of its time, so a wait for a date timed out on a clock that turned a day every thirty seconds.
-## The answer says how many frames the wait spanned, how many looks it took and how long they took
-## between them, which is how a caller sees what it cost and whether the game lost its speed to the
-## looks or to something else.
+## Each look is read a slice at a time, [constant LOOK_SLICE_USEC] to a frame, so the frames it runs
+## in keep their length; the last is read whole, since the wait answers on it.
+##
+## The answer says how many frames the wait spanned, how many looks it took, how long they took
+## between them and the longest they held one frame, which is how a caller sees what it cost and
+## whether the game lost its speed, or a frame its length, to the looks or to something else.
 func _wait_until_said(
 	node_path: String, said: String, timeout_ms: int, include_hidden: bool
 ) -> Dictionary:
@@ -795,18 +803,29 @@ func _wait_until_said(
 	var frames: int = 0
 	var looks: int = 0
 	var looked_usec: int = 0
+	var held_usec: int = 0
 	var next_look: int = 0
 	var looked_at_frame: int = 0
 	var found: bool = false
+	var look: GdhLook = null
+	var look_began: int = 0
 	while true:
-		if Time.get_ticks_usec() >= next_look:
-			var looking: int = Time.get_ticks_usec()
-			found = _anything_says(node_path, said, include_hidden)
-			looks += 1
-			var took: int = Time.get_ticks_usec() - looking
-			looked_usec += took
-			next_look = Time.get_ticks_usec() + took * LOOKS_APART
+		if look == null and Time.get_ticks_usec() >= next_look:
+			look = GdhLook.new(_under(node_path), said, include_hidden)
+			look_began = Time.get_ticks_usec()
+		if look != null:
+			var held: int = look.go_on(LOOK_SLICE_USEC)
+			looked_usec += held
+			held_usec = maxi(held_usec, held)
 			looked_at_frame = frames
+			if look.done:
+				looks += 1
+				found = look.found
+				# From where the look began, since the frames it was read across are the game's:
+				# counted from its end, a look spread over a third of a second waited out its nine
+				# lengths after that, and a wait on 3,500 nodes looked four times in two seconds.
+				next_look = look_began + look.took_usec * (LOOKS_APART + 1)
+				look = null
 		if found or Time.get_ticks_msec() - started >= timeout_ms:
 			break
 		await _host.get_tree().process_frame
@@ -815,14 +834,18 @@ func _wait_until_said(
 	# never having come. Taken once a whole frame has run since the last look, which is two frame
 	# starts: a first look that outlasted the timeout otherwise left none, so the wait answered with
 	# the game not having run at all, and a command sent during that look not yet read.
+	var heard: bool = found
 	if not found:
 		while frames - looked_at_frame < 2:
 			await _host.get_tree().process_frame
 			frames += 1
-		var last: int = Time.get_ticks_usec()
-		found = _anything_says(node_path, said, include_hidden)
+		var last: GdhLook = GdhLook.new(_under(node_path), said, include_hidden)
+		var held: int = last.go_on(-1)
 		looks += 1
-		looked_usec += Time.get_ticks_usec() - last
+		looked_usec += held
+		held_usec = maxi(held_usec, held)
+		found = last.found
+		heard = last.heard
 
 	var answer: Dictionary = {
 		"type": "condition",
@@ -834,10 +857,11 @@ func _wait_until_said(
 		"frames": frames,
 		"looks": looks,
 		"looking_ms": looked_usec / 1000.0,
+		"longest_hold_ms": held_usec / 1000.0,
 	}
 	# Words that are there and cannot be read look, from a wait that ran out, like words that never
 	# came.
-	if not found and not include_hidden and _anything_says(node_path, said, true):
+	if not found and heard:
 		answer["unseen_note"] = (
 			(
 				"Something under %s says it, but is hidden or drawn outside the viewport or a "
@@ -849,22 +873,8 @@ func _wait_until_said(
 	return answer
 
 
-## Whether anything under [param node_path] says [param said], the node itself included, and where
-## the player can read it unless hidden ones are wanted too. Matched as a find and a click match
-## `says`, a glob over the whole text when it has `*` or `?`: read as literal words, a glob a click
-## had just pressed by was waited on for the whole timeout with its label on screen, and answered as
-## words never arriving.
-func _anything_says(node_path: String, said: String, include_hidden: bool) -> bool:
-	var root: Node = _host.get_tree().root.get_node_or_null(node_path)
-	if root == null:
-		return false
-	var pending: Array[Node] = [root]
-	while not pending.is_empty():
-		var node: Node = pending.pop_back()
-		if GdhSays.says(node, said) and (include_hidden or GdhQueries.readable(node)):
-			return true
-		pending.append_array(node.get_children(true))
-	return false
+func _under(node_path: String) -> Node:
+	return _host.get_tree().root.get_node_or_null(node_path)
 
 
 ## Remembers that a signal fired and what it carried, for a wait that polls rather than
@@ -942,6 +952,56 @@ class GdhTrace:
 			dropped += 1
 
 
+## One look for whether anything under a node says some words, the node itself included, and where
+## the player can read it unless hidden ones are wanted too. Matched as a find and a click match
+## `says`, a glob over the whole text when it has `*` or `?`: read as literal words, a glob a click
+## had just pressed by was waited on for the whole timeout with its label on screen, and answered as
+## words never arriving.
+class GdhLook:
+	extends RefCounted
+	## Whether a node that counts says the words.
+	var found: bool = false
+	## Whether any node says them, hidden or not: words that are there and cannot be read look,
+	## from a wait that ran out, like words that never came.
+	var heard: bool = false
+	var done: bool = false
+	## How long the look has taken over every frame it has run in.
+	var took_usec: int = 0
+	var _said: String
+	var _include_hidden: bool
+	## Untyped, since a node waiting here can be freed between two frames of the look.
+	var _pending: Array = []
+
+	func _init(root: Node, said: String, include_hidden: bool) -> void:
+		_said = said
+		_include_hidden = include_hidden
+		if root != null:
+			_pending.append(root)
+
+	## Reads on until the look is done or [param budget_usec] has passed, -1 for no limit, and
+	## answers how long it read.
+	func go_on(budget_usec: int) -> int:
+		var from: int = Time.get_ticks_usec()
+		while not _pending.is_empty():
+			if budget_usec >= 0 and Time.get_ticks_usec() - from >= budget_usec:
+				break
+			var next: Variant = _pending.pop_back()
+			if not is_instance_valid(next):
+				continue
+			var node: Node = next
+			if GdhSays.says(node, _said):
+				heard = true
+				if _include_hidden or GdhQueries.readable(node):
+					found = true
+					_pending.clear()
+					break
+			_pending.append_array(node.get_children(true))
+		done = _pending.is_empty()
+		var read: int = Time.get_ticks_usec() - from
+		took_usec += read
+		return read
+
+
 ## A signal recorded from when it was armed until it is collected.
 class GdhWatch:
 	extends RefCounted

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

@@ -163,7 +163,7 @@ static func pressable_words(from: Node, open: Callable, most: int) -> String:
 			if offered.size() == most:
 				return ", ".join(offered) + ", and more"
 			offered.append(quoted)
-		var children: Array[Node] = node.get_children()
+		var children: Array[Node] = node.get_children(true)
 		for index: int in range(children.size() - 1, -1, -1):
 			pending.push_front(children[index])
 	return ", ".join(offered)

package/build/godot/operations/animation_reads.gd

@@ -16,6 +16,22 @@ const UPDATE_MODE_NAMES: Dictionary[int, String] = {
 	Animation.UPDATE_DISCRETE: "discrete",
 	Animation.UPDATE_CAPTURE: "capture",
 }
+const INTERPOLATION_NAMES: Dictionary[int, String] = {
+	Animation.INTERPOLATION_NEAREST: "nearest",
+	Animation.INTERPOLATION_LINEAR: "linear",
+	Animation.INTERPOLATION_CUBIC: "cubic",
+	Animation.INTERPOLATION_LINEAR_ANGLE: "linear_angle",
+	Animation.INTERPOLATION_CUBIC_ANGLE: "cubic_angle",
+}
+## The track types whose keys are blended between, so how they are and whether a looping animation
+## blends its last key into its first say how the track moves.
+const INTERPOLATED_TYPES: Array[int] = [
+	Animation.TYPE_VALUE,
+	Animation.TYPE_POSITION_3D,
+	Animation.TYPE_ROTATION_3D,
+	Animation.TYPE_SCALE_3D,
+	Animation.TYPE_BLEND_SHAPE,
+]
 const TRACK_TYPE_NAMES: Dictionary[int, String] = {
 	Animation.TYPE_VALUE: "property",
 	Animation.TYPE_POSITION_3D: "position_3d",
@@ -174,6 +190,10 @@ static func _track(anim: Animation, track: int, values: GdhSerialisation) -> Dic
 	if kind == Animation.TYPE_VALUE:
 		var mode: int = anim.value_track_get_update_mode(track)
 		shaped["update"] = UPDATE_MODE_NAMES.get(mode, str(mode))
+	if kind in INTERPOLATED_TYPES:
+		var interpolation: int = anim.track_get_interpolation_type(track)
+		shaped["interpolation"] = INTERPOLATION_NAMES.get(interpolation, str(interpolation))
+		shaped["loopWrap"] = anim.track_get_interpolation_loop_wrap(track)
 	var keyframes: Array[Dictionary] = []
 	var methods: Dictionary = {}
 	for key: int in anim.track_get_key_count(track):

package/build/godot/operations/dependencies.gd

@@ -530,6 +530,20 @@ static func _comment_of(line: String) -> String:
 
 # How a line that names the resource by path uses it.
 func _path_reference_kind(line: String, file_path: String) -> String:
+	var placed: String = _placed_kind(line, file_path)
+	if not placed.is_empty():
+		return placed
+	var trimmed: String = GdhPatterns.without_annotations(line)
+	if "preload(" in trimmed:
+		return "preload"
+	if "load(" in trimmed:
+		return "load"
+	return "path"
+
+
+# The kind a reference on [param line] has by the file it is in or by how the line starts, or ""
+# when neither says.
+static func _placed_kind(line: String, file_path: String) -> String:
 	match file_path.get_file():
 		"project.godot":
 			return "setting"
@@ -546,11 +560,31 @@ func _path_reference_kind(line: String, file_path: String) -> String:
 		return "ext_resource"
 	if trimmed.begins_with("#include"):
 		return "include"
-	if "preload(" in trimmed:
+	return ""
+
+
+# The kind of the reference [param found] is in [param content], read from [param path], by the
+# call its path is handed to rather than by the line, which can name a second file another way: a
+# path only written in a string, which nothing in the file may load, read as a load.
+static func _forward_kind(content: String, found: RegExMatch, path: String) -> String:
+	var matched: String = found.get_string()
+	if matched.begins_with("preload("):
 		return "preload"
-	if "load(" in trimmed:
+	if matched.begins_with("load("):
 		return "load"
-	return "path"
+	var start: int = found.get_start()
+	var line_start: int = content.rfind("\n", start) + 1
+	var line_end: int = content.find("\n", start)
+	var line: String = content.substr(
+		line_start, (content.length() if line_end == -1 else line_end) - line_start
+	)
+	var before: String = content.substr(line_start, start - line_start).rstrip("\"'")
+	if before.ends_with("preload("):
+		return "preload"
+	if before.ends_with("load("):
+		return "load"
+	var placed: String = _placed_kind(line, path)
+	return "path" if placed.is_empty() else placed
 
 
 func _regex_escaped(text: String) -> String:
@@ -633,8 +667,14 @@ func _depend(dep_info: Dictionary, current_depth: int, walk: GdhDependencyWalk)
 	# tree answered that file as a dependency of itself.
 	if dep_path in walk.path_stack:
 		var cycle: Array[String] = walk.path_stack.slice(walk.path_stack.find(dep_path))
-		cycle.append(dep_path)
-		if not cycle in walk.circular_references:
+		# Kept by a key that is the same wherever the walk entered the cycle: compared as written,
+		# one cycle met from two of its files was listed twice, and comparing each against every
+		# cycle found so far grew with the square of their number, sixteen thousand on three
+		# hundred scripts typed by each other's class names.
+		var key: String = _cycle_key(cycle)
+		if not walk.cycles_seen.has(key):
+			walk.cycles_seen[key] = true
+			cycle.append(dep_path)
 			walk.circular_references.append(cycle)
 		dep_info["circular"] = true
 		return false
@@ -660,6 +700,16 @@ func _depend(dep_info: Dictionary, current_depth: int, walk: GdhDependencyWalk)
 	return walked["cut"]
 
 
+## [param cycle], the files of one cycle in the order the walk met them, turned to start at the
+## first of them in sorting order, so the cycle met from any of its files keys the same.
+static func _cycle_key(cycle: Array[String]) -> String:
+	var first: int = 0
+	for at: int in cycle.size():
+		if cycle[at] < cycle[first]:
+			first = at
+	return "\n".join(PackedStringArray(cycle.slice(first) + cycle.slice(0, first)))
+
+
 ## What [param path] names, each file once, as the entries the tree lists it by; read once a walk.
 func _references(path: String, walk: GdhDependencyWalk) -> Array[Dictionary]:
 	if walk.references.has(path):
@@ -688,12 +738,13 @@ func _references(path: String, walk: GdhDependencyWalk) -> Array[Dictionary]:
 			for m: RegExMatch in regex.search_all(content):
 				var written: String = _resolved(_referenced_path(m.get_string()), path)
 				var dep_path: String = str(moved.get(written, written))
+				var kind: String = _forward_kind(content, m, path)
 
 				# A uid the project does not know names no file, and loading it fails: passed over
 				# as no res:// path, a script's load of one went unsaid while the game printed
 				# "Unrecognized UID" at that line.
 				if dep_path.begins_with("uid://"):
-					_name(deps, path, dep_path, {})
+					_name(deps, path, dep_path, { "kind": kind })
 					continue
 				if not dep_path.begins_with("res://"):
 					continue
@@ -709,7 +760,9 @@ func _references(path: String, walk: GdhDependencyWalk) -> Array[Dictionary]:
 				if not walk.include_built_in and dep_path.begins_with("res://."):
 					continue
 
-				var named_by: Dictionary = { "stale_path": written } if dep_path != written else {}
+				var named_by: Dictionary = { "kind": kind }
+				if dep_path != written:
+					named_by["stale_path"] = written
 				if unknown.has(dep_path):
 					named_by["unknown_uid"] = unknown[dep_path]
 				_name(deps, path, dep_path, named_by)
@@ -730,8 +783,8 @@ func _references(path: String, walk: GdhDependencyWalk) -> Array[Dictionary]:
 
 # Adds [param dep_path] to [param deps], what [param path] depends on, once however many times it
 # is named. [param named_by] is the class or autoload name it was named by, as by_class or
-# by_autoload, and the path written when the engine loads another, as stale_path; empty for a path
-# that is the file.
+# by_autoload, or for a path its kind, with the path written when the engine loads another as
+# stale_path.
 func _name(deps: Array[Dictionary], path: String, dep_path: String, named_by: Dictionary) -> void:
 	if dep_path == path:
 		return
@@ -962,6 +1015,9 @@ class GdhDependencyWalk:
 
 	var circular_references: Array
 
+	## Each cycle in circular_references, by [method _cycle_key].
+	var cycles_seen: Dictionary[String, bool] = {}
+
 	func _init(p_max_depth: int, p_include_built_in: bool, p_circular_references: Array) -> void:
 		max_depth = p_max_depth
 		include_built_in = p_include_built_in