gdharness 1.3.34 → 1.3.36

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

@@ -4,6 +4,9 @@ extends RefCounted
 ## here and sent from runtime_input.gd, which keeps where the pointer is.
 
 const GdhRead = preload("reading.gd")
+const GdhScreen = preload("runtime_screen.gd")
+const GdhTargets = preload("runtime_targets.gd")
+const GdhValues = preload("runtime_values.gd")
 
 
 ## A point the tool schema sends as two flat numbers. Answers a Vector2, or the String that says
@@ -14,6 +17,84 @@ static func read_point(params: Dictionary, x_key: String, y_key: String) -> Vari
 	return Vector2(GdhRead.as_float(params[x_key]), GdhRead.as_float(params[y_key]))
 
 
+## The point a click names in [param node]'s own space, null when it names none, or the String
+## refusing it: a 3D node is clicked where it is drawn, and an item found by its words, a tab or a
+## row, where the control draws it.
+##
+## For a control that draws its parts itself and hit-tests them in _gui_input, whose centre was all
+## a click could press; in a native window, where the game's window pixels do not reach, nothing
+## else could press the rest.
+static func point_in(params: Dictionary, node: Node, node_path: String, has_item: bool) -> Variant:
+	if not params.has("x") and not params.has("y"):
+		return null
+	if node is Node3D:
+		return (
+			"%s is a 3D node, clicked where it is drawn; x and y name a point in a Control's own space"
+			% node_path
+		)
+	if has_item:
+		return (
+			(
+				"the words name an item %s draws, which is pressed where it is drawn, and x and y a point in it:"
+				+ " give one of them"
+			)
+			% node_path
+		)
+	return read_point(params, "x", "y")
+
+
+## The node a mouse_click, mouse_motion or mouse_drag names its points in, as {"node", "path"}, an
+## empty Dictionary for the game's window, or the String refusing it.
+##
+## A point in a node's own space is the only way to press part of a control in a native window,
+## where the game's window pixels do not reach: a game that draws its buttons itself and hit-tests
+## them in _gui_input had nothing a click could aim at but the control's centre.
+static func aim_of(params: Dictionary, root: Window) -> Variant:
+	var path: String = str(params.get("nodePath", ""))
+	if path.is_empty():
+		return {}
+	var standing: Dictionary = GdhValues.node_at(root, path)
+	if standing.has("message"):
+		return standing["message"]
+	var node: Node = standing["node"]
+	if node is CanvasItem or node is Viewport:
+		return {"node": node, "path": path}
+	return (
+		"%s is a %s, and the points are in a Control's, a Node2D's or a Window's own space"
+		% [path, node.get_class()]
+	)
+
+
+## Where [param local], in the space of the node [param aim] names, arrives: {"viewport", "position"},
+## the viewport the pointer reaches it through and the point in that viewport's pixels, which is what
+## an event sent there names. A Window's space is its own pixels, as the game's window pixels are the
+## root's; a canvas item's is its own, the one it draws and reads _gui_input in.
+static func carried(aim: Dictionary, local: Vector2, root: Window) -> Dictionary:
+	var node: Node = aim.get("node", root)
+	var reached: Dictionary = {}
+	if node is Viewport:
+		var viewport: Viewport = node
+		reached = GdhScreen.reach(viewport, viewport.get_final_transform().affine_inverse() * local)
+	else:
+		var item: CanvasItem = node
+		reached = GdhScreen.reach(item.get_viewport(), item.get_global_transform_with_canvas() * local)
+	var arriving: Viewport = reached["viewport"]
+	var point: Vector2 = reached["point"]
+	return {"viewport": arriving, "position": arriving.get_final_transform() * point}
+
+
+## What a pointer answer says of where [param points] went in [param viewport]: the node they were
+## named in, the window when it is not the game's own, and any of them outside its viewport. Read
+## before the first event, since a release can close the window it went to.
+static func where(aim: Dictionary, viewport: Viewport, points: Array[Vector2]) -> Dictionary:
+	var said: Dictionary = outside_noted({}, viewport, points)
+	if aim.has("path"):
+		said["path"] = aim["path"]
+	if viewport != viewport.get_tree().root:
+		said["window"] = str(viewport.get_path())
+	return said
+
+
 ## The points of a drag: x, y, then each of via, then toX, toY. Answers the String saying what is
 ## wrong instead, since a point left out would otherwise read as the window's corner.
 static func stroke_of(params: Dictionary) -> Variant:
@@ -66,9 +147,10 @@ static func mask_of(button: int) -> int:
 
 
 ## A button event carries the buttons held once it has happened: the pressed one among them, the
-## released one out. A wheel step is a button with no mask, as it is from a real mouse.
+## released one out. A wheel step is a button with no mask, as it is from a real mouse. [param held]
+## is what was held before it, which Input knows for the game's window.
 static func button_event(
-	position: Vector2, button: int, pressed: bool, double: bool
+	position: Vector2, button: int, pressed: bool, double: bool, held: int = -1
 ) -> InputEventMouseButton:
 	var event: InputEventMouseButton = InputEventMouseButton.new()
 	event.position = position
@@ -76,7 +158,8 @@ static func button_event(
 	event.button_index = button as MouseButton
 	event.pressed = pressed
 	event.double_click = double
-	var held: int = Input.get_mouse_button_mask()
+	if held < 0:
+		held = Input.get_mouse_button_mask()
 	var own: int = mask_of(button)
 	event.button_mask = (held | own) if pressed else (held & ~own)
 	return event
@@ -90,12 +173,15 @@ static func button_event(
 ## content scale and any letterbox offset, so the rect is taken into window pixels first.
 static func outside_noted(answer: Dictionary, viewport: Viewport, points: Array[Vector2]) -> Dictionary:
 	var shown: Rect2 = viewport.get_final_transform() * viewport.get_visible_rect()
+	var which: String = (
+		"the window's" if viewport == viewport.get_tree().root else "%s's" % viewport.get_path()
+	)
 	for point: Vector2 in points:
 		if not shown.has_point(point):
 			answer["outside_viewport"] = (
 				(
-					"%s is outside the window's viewport, %s in window pixels, so no control there receives"
-					% [point, shown]
+					"%s is outside %s viewport, %s in window pixels, so no control there receives"
+					% [point, which, shown]
 				)
 				+ " it; the game's _input and _unhandled_input still do."
 			)
@@ -140,3 +226,40 @@ static func button_of(raw: Variant) -> int:
 	# number past the two extra buttons names nothing a mask bit can be made for.
 	var number: int = GdhRead.as_int(raw, -1)
 	return number if number >= MOUSE_BUTTON_LEFT and number <= MOUSE_BUTTON_XBUTTON2 else -1
+
+
+## Why [param control] would take no click a player gave it, or "" when it would.
+##
+## The last two answered landed, since the pointer reaches the control, while the press did nothing,
+## measured on 4.7.2: a disabled button keeps its mouse filter and ignores the press, and a control
+## that does not process while the game is paused is hovered and never handed the event.
+## A control whose pointer a `mouse_behavior_recursive` above it has turned off is passed through to
+## what is underneath, which answered `landed: false` with nothing saying why. [param paused] is
+## whether the game is.
+static func takes_no_click(control: Control, node_path: String, paused: bool) -> String:
+	if not control.is_visible_in_tree():
+		return "%s is not visible%s, so nothing can click it" % [node_path, GdhTargets.why_hidden(control)]
+	var button: BaseButton = control as BaseButton
+	if button != null and button.disabled:
+		return "%s is disabled, so clicking it presses nothing" % node_path
+	var turned_off: Control = GdhTargets.pointer_turned_off_by(control)
+	if turned_off != null:
+		var on: String = "itself" if turned_off == control else str(turned_off.get_path())
+		return (
+			(
+				"%s takes no pointer input, since mouse_behavior_recursive is disabled on %s,"
+				+ " so clicking it presses nothing"
+			)
+			% [node_path, on]
+		)
+	if not control.can_process():
+		var why: String = GdhTargets.why_it_does_not_process(control, node_path)
+		var over: Node = GdhTargets.drawn_over(control)
+		var cover: String = "" if over == null else "; %s is drawn over it" % over.get_path()
+		if paused:
+			return (
+				"the game is paused and %s does not process while it is (%s), so clicking it does nothing%s"
+				% [node_path, why, cover]
+			)
+		return "%s does not process (%s), so clicking it does nothing%s" % [node_path, why, cover]
+	return ""

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

@@ -3,6 +3,8 @@ extends RefCounted
 ## Where a point in some viewport is on the game's own screen, for a click to be sent there and for
 ## an answer to say where something is drawn.
 
+const GdhHover = preload("runtime_hover.gd")
+
 
 ## The viewport a pointer at [param point], in [param viewport]'s own coordinates, arrives through,
 ## and where it is there: {"viewport", "point"}.
@@ -106,3 +108,108 @@ static func shown_part(control: Control) -> Variant:
 			return null
 		part = part.intersection(clip)
 	return part
+
+
+## Whether [param centre] is somewhere a click can reach it: inside the viewport, and inside every
+## ScrollContainer between the control and the root, each of which clips what it holds.
+static func in_sight(control: Control, viewport: Viewport, centre: Vector2) -> bool:
+	return viewport.get_visible_rect().has_point(centre) and clipped_by(control, centre) == null
+
+
+## The ScrollContainer between [param control] and its viewport that clips [param centre] away from
+## it, or null when none does. Not past the viewport: one holding a dialog is in another space.
+static func clipped_by(control: Control, centre: Vector2) -> ScrollContainer:
+	var walking: Node = control.get_parent()
+	while walking != null and not (walking is Viewport):
+		var holder: ScrollContainer = walking as ScrollContainer
+		# Carried into the same space the centre is in, which is the canvas rather than the
+		# container's own: the two are only the same while nothing above it is transformed.
+		if holder != null:
+			var seen: Rect2 = holder.get_global_transform_with_canvas() * Rect2(Vector2.ZERO, holder.size)
+			if not seen.has_point(centre):
+				return holder
+		walking = walking.get_parent()
+	return null
+
+
+## Scrolls whatever is holding [param control] until it is on screen, and answers whether the view
+## moved.
+##
+## Innermost container first and outwards, a frame apart. A container moves what it holds on the
+## next layout pass rather than inside the call, and the next one out works out where the control is
+## from where it is drawn, so asked in the same frame it scrolled to where the control had been.
+## Moved means a scroll value changed: a container asked to show what it already shows moves
+## nothing, and answering true for it said the view had moved when it had not. Only the containers in
+## the control's own viewport: one holding a dialog scrolls the page behind it, not the dialog.
+static func scroll_into_view(control: Control, tree: SceneTree) -> bool:
+	var moved: bool = false
+	var walking: Variant = control.get_parent()
+	while walking != null and not (walking is Viewport):
+		var step: Node = walking
+		var holder: ScrollContainer = step as ScrollContainer
+		if holder != null:
+			var before: Vector2i = Vector2i(holder.scroll_horizontal, holder.scroll_vertical)
+			holder.ensure_control_visible(control)
+			if Vector2i(holder.scroll_horizontal, holder.scroll_vertical) != before:
+				moved = true
+				await tree.process_frame
+				# A panel that rebuilds itself can go in the frame this waited.
+				if not is_instance_valid(control) or not is_instance_valid(holder):
+					return moved
+		walking = step.get_parent()
+	return moved
+
+
+## Whether a pointer on its way out through [param out], the steps [method steps_out] answers, gets
+## past the interface in every viewport, as {"landed", "hovered"}: the path of the control that took
+## it, or of the one under it that let it by, or null. [param hover] answers what is hovered.
+##
+## In the viewport the node is drawn in, a control under the pointer takes it unless it and every
+## control holding it let the pointer pass. In each viewport outside that one, the pointer has to be
+## over what shows the one inside: the SubViewportContainer, with nothing drawn over it, or inside
+## the embedded window. Read in the first viewport alone, a click beside a container that is smaller
+## than what it shows, or under a panel drawn over the container, answered landed.
+static func through_the_interface(out: Array[Dictionary], hover: GdhHover) -> Dictionary:
+	var first_under: Variant = null
+	for step: Dictionary in out:
+		var viewport: Viewport = step["viewport"]
+		var through: Variant = step["through"]
+		var hovered: Control = hover.hovered_in(viewport)
+		if through is Window:
+			var window: Window = through
+			var point: Vector2 = step["point"]
+			if not Rect2(window.position, window.size).has_point(point):
+				return {"landed": false, "hovered": _path_or_null(hovered)}
+			continue
+		if through is SubViewportContainer:
+			if hovered != through:
+				return {"landed": false, "hovered": _path_or_null(hovered)}
+			continue
+		if hovered != null and not _passes_on(hovered):
+			return {"landed": false, "hovered": str(hovered.get_path())}
+		if hovered != null and first_under == null:
+			first_under = str(hovered.get_path())
+	return {"landed": true, "hovered": first_under}
+
+
+## Whether a pointer over [param control] goes on past the interface: a control that lets it pass
+## hands it to the one holding it, and one that stops it takes it, up to a control drawn on its own
+## or something that is not a control. Measured on 4.7.2: a HUD over the room letting the pointer
+## pass answered not landed while the game's own input took the press. A script on a control that
+## lets it pass can still take the event for itself, which nothing outside it can see.
+static func _passes_on(control: Control) -> bool:
+	var walk: Node = control
+	while walk is Control:
+		var at: Control = walk
+		if at.get_mouse_filter_with_override() == Control.MOUSE_FILTER_STOP:
+			return false
+		if at.top_level:
+			break
+		walk = at.get_parent()
+	return true
+
+
+static func _path_or_null(node: Node) -> Variant:
+	if node == null:
+		return null
+	return str(node.get_path())

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

@@ -173,11 +173,12 @@ static func control_saying(root: Node, root_path: String, wanted: String, which:
 
 	var under: String = "" if root_path == "/root" else " under %s" % root_path
 	if targets.is_empty():
+		var from: Node = reached["node"]
 		return {
 			"type": "error",
 			"message":
 			(
-				'no control on screen%s says "%s", so nothing was clicked%s%s%s%s'
+				'no control on screen%s says "%s", so nothing was clicked%s%s%s%s%s'
 				% [
 					under,
 					wanted,
@@ -185,6 +186,7 @@ static func control_saying(root: Node, root_path: String, wanted: String, which:
 					_outside_note(outside, root),
 					_covered_note(covered, cover),
 					_open_menu_note(root, wanted),
+					_offered_note(from, drawn, areas),
 				]
 			)
 		}
@@ -437,6 +439,18 @@ static func _passed_over(best: int, others: Array[int], one: bool) -> String:
 
 
 ## What to add to a refusal that found nothing on screen, when words matched controls out of sight.
+static func _offered_note(from: Node, drawn: Array[Node], areas: Array[Rect2]) -> String:
+	var open: Callable = func(button: Control) -> bool:
+		var aim: Vector2 = button.size * 0.5
+		return (
+			GdhQueries.shown(button)
+			and not _off_screen(button, aim)
+			and _cover_of(button, drawn, areas, aim) == null
+		)
+	var words: String = GdhWords.pressable_words(from, open, LISTED_CANDIDATES)
+	return "" if words.is_empty() else "; the buttons on screen say %s" % words
+
+
 static func _hidden_note(hidden: int) -> String:
 	if hidden == 0:
 		return ""

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

@@ -227,6 +227,8 @@ func _collect(id: int, timeout_ms: int) -> Dictionary:
 		"args": _values.serialize(watch.catcher.args),
 		"elapsed_ms": Time.get_ticks_msec() - started,
 	}
+	if watch.catcher.fired:
+		answer["fired_after_ms"] = watch.catcher.fired_after_ms
 	if before:
 		answer["fired_before_wait"] = true
 	return answer
@@ -848,10 +850,16 @@ class GdhSignalCatcher:
 	## How many times it fired; [member args] holds what the first carried.
 	var times: int = 0
 	var args: Array = []
+	## Milliseconds from when this began listening to the first emission, -1 before one. A wait
+	## collecting a watch measured only itself, so a call made between the arming and the wait left
+	## nothing saying how long after it the signal came.
+	var fired_after_ms: int = -1
+	var _armed_at: int = Time.get_ticks_msec()
 
 	func _on_fired(...carried: Array) -> void:
 		if not fired:
 			args = carried
+			fired_after_ms = Time.get_ticks_msec() - _armed_at
 		fired = true
 		times += 1
 

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

@@ -144,6 +144,28 @@ static func draws_a_list(node: Node) -> bool:
 	return node is TabBar or node is MenuBar or node is ItemList or node is PopupMenu or node is Tree
 
 
+## The words of the enabled buttons under [param from], quoted, each once and in the order they are
+## drawn, that [param open] says a player could press: at most [param most], then "and more". What a
+## refusal of words nothing on screen says offers instead: a click for "Settings" named nothing,
+## though Play, Options and Quit were all there.
+static func pressable_words(from: Node, open: Callable, most: int) -> String:
+	var offered: Array[String] = []
+	var pending: Array[Node] = [from]
+	while not pending.is_empty():
+		var node: Node = pending.pop_front()
+		var button: BaseButton = node as BaseButton
+		var words: String = "" if button == null or button.disabled else said_by(button).strip_edges()
+		var quoted: String = '"%s"' % words
+		if not words.is_empty() and not offered.has(quoted) and open.call(button):
+			if offered.size() == most:
+				return ", ".join(offered) + ", and more"
+			offered.append(quoted)
+		var children: Array[Node] = node.get_children()
+		for index: int in range(children.size() - 1, -1, -1):
+			pending.push_front(children[index])
+	return ", ".join(offered)
+
+
 static func _keep(line: String, into: Array[String]) -> void:
 	var trimmed: String = line.strip_edges()
 	if not trimmed.is_empty():

package/build/godot/operations/animation_reads.gd

@@ -131,6 +131,22 @@ static func _summary(anim: Animation) -> Dictionary:
 	}
 
 
+## [param seconds], a key's time, as the shortest decimal holding the same 32-bit float. A scene keeps
+## key times as 32-bit floats, so a key put at 0.7 read back as 0.699999988079071.
+static func key_time(seconds: float) -> float:
+	var held: float = PackedFloat32Array([seconds])[0]
+	for places: int in range(0, 10):
+		var shorter: float = String.num(held, places).to_float()
+		if PackedFloat32Array([shorter])[0] == held:
+			return shorter
+	return held
+
+
+## Whether two times are one key's: the same 32-bit float, as a scene stores them.
+static func same_time(first: float, second: float) -> bool:
+	return PackedFloat32Array([first])[0] == PackedFloat32Array([second])[0]
+
+
 static func _track(anim: Animation, track: int, values: GdhSerialisation) -> Dictionary:
 	var kind: int = anim.track_get_type(track)
 	var path: NodePath = anim.track_get_path(track)
@@ -143,7 +159,7 @@ static func _track(anim: Animation, track: int, values: GdhSerialisation) -> Dic
 	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)}
+		var keyframe: Dictionary = {"time": key_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

package/build/godot/operations/classdb_queries.gd

@@ -310,6 +310,10 @@ func _not_found(wanted: String, declared: Dictionary, answers_own: bool = false)
 	for name: String in close:
 		if name.to_lower().similarity(wanted.to_lower()) < best - CLOSE_TO_THE_BEST:
 			continue
+		# Similarity counts shared letter pairs, so a word the two names share passes it: NoSuchClass
+		# was offered ClassDB. A spelling is a few letters off, a swap of two among them.
+		if _edits(name.to_lower(), wanted.to_lower()) > maxi(2, floori(wanted.length() / 3.0)):
+			continue
 		if declared.has(name):
 			own.append(name)
 		else:
@@ -347,6 +351,18 @@ func _not_found(wanted: String, declared: Dictionary, answers_own: bool = false)
 	)
 
 
+## How many letters must be put in, taken out or changed to make [param from] into [param to].
+static func _edits(from: String, to: String) -> int:
+	var above: PackedInt32Array = PackedInt32Array(range(to.length() + 1))
+	for row: int in range(1, from.length() + 1):
+		var here: PackedInt32Array = PackedInt32Array([row])
+		for column: int in range(1, to.length() + 1):
+			var changed: int = above[column - 1] + (0 if from[row - 1] == to[column - 1] else 1)
+			var _added: bool = here.append(mini(changed, mini(above[column] + 1, here[column - 1] + 1)))
+		above = here
+	return above[to.length()]
+
+
 # One member of a class by name, wherever in its ancestry it is declared.
 #
 # The question a member is asked by name for is "does this engine have it, and what does it take":

package/build/godot/operations/dependencies.gd

@@ -123,12 +123,18 @@ func get_dependencies(params: Dictionary) -> Dictionary:
 
 
 ## Every file a scene or resource of the project loads through an ext_resource that is not there,
-## by its path or its uid, each with the files loading it. Only those: a script naming a path in
-## its code may be asking whether the file exists, and the shipped addons check for files they
-## write, so every project was told its addons referred to files that are missing. A script's
-## preloads are the compile's to judge.
+## by its path or its uid, and every one a script hands load() as written, each with the files
+## loading it. Not any path a script names: one may be asking whether the file exists, and the
+## shipped addons check for files they write, so every project was told its addons referred to
+## files that are missing. A load() of a file the script also asks exists() about is left out for
+## the same reason, and a script's preloads are the compile's to judge.
 func missing_references() -> Array[Dictionary]:
 	var missing: Dictionary = {}
+	for file: String in _files.find_files("res://", ".gd"):
+		for path: String in _loaded_and_missing(file):
+			var naming: Array = missing.get_or_add(path, [])
+			if not file in naming:
+				naming.append(file)
 	for file: String in _files.find_files_with_extensions("res://", GdhResourceFiles.TEXT_RESOURCE_KINDS):
 		var content: String = FileAccess.get_file_as_string(file)
 		var moved: Dictionary = _moved_by_uid(content)
@@ -158,6 +164,42 @@ func missing_references() -> Array[Dictionary]:
 	return found
 
 
+## The files [param script] loads with load() or ResourceLoader.load() by a path written in the call
+## that are not on disk. A load called on another object, such as a ConfigFile's, reads a file that
+## object's owner may write, so only the bare call and the ResourceLoader's count. A path the script
+## names anywhere else, asking whether it exists, writing it or removing it, is one it looks after
+## itself, and a `load(` inside a string is not a call: read across lines, one in a string literal
+## took the rest of the file up to the next quote as a path.
+func _loaded_and_missing(script: String) -> Array[String]:
+	var loaded: Array[String] = []
+	var named: Dictionary = {}
+	for line: String in FileAccess.get_file_as_string(script).split("\n"):
+		var code: String = GdhPatterns.without_comment(line)
+		if not code.contains("load("):
+			for literal: String in _string_literals(code):
+				named[_resolved(literal, script)] = true
+			continue
+		var calls: Dictionary = {}
+		for loading: RegExMatch in (
+			GdhPatterns.compiled("(?:(?<![\\w.])|ResourceLoader\\.)load\\(\\s*(?=[\"'])").search_all(code)
+		):
+			calls[loading.get_end()] = true
+		for literal: RegExMatch in GdhPatterns.compiled(STRING_LITERAL).search_all(code):
+			var single: String = literal.get_string(2)
+			var path: String = _resolved(literal.get_string(1) if single.is_empty() else single, script)
+			if calls.has(literal.get_start()):
+				loaded.append(path)
+			else:
+				named[path] = true
+	var missing: Array[String] = []
+	for path: String in loaded:
+		if not path.begins_with("res://") or path.begins_with("res://.") or path.get_extension().is_empty():
+			continue
+		if not named.has(path) and not FileAccess.file_exists(path) and not missing.has(path):
+			missing.append(path)
+	return missing
+
+
 ## The files project.godot's settings name that are not on disk: an autoload, a registered
 ## translation, an icon, an enabled plugin. Not the main scene, which has a check of its own, and
 ## the engine reports each of the rest on every boot.

package/build/godot/operations/editor_tools.gd

@@ -86,11 +86,11 @@ static func run(params: Dictionary) -> Dictionary:
 		if not GdhSceneUids.by_path.is_empty():
 			answered["namedByPath"] = (
 				(
-					"What this saved names %s by path rather than by uid. A uid in a file's own header is "
-					+ "resolved through the project's uid cache, which holds none for %s yet, as with a "
-					+ "file made since the project was last scanned, and a uid it does not hold would "
-					+ "warn on every load. project_import refresh_uids scans the project, and writes "
-					+ "after it name %s by uid."
+					"What this saved names %s by path rather than by uid, which loads the same. A uid in a "
+					+ "file's own header is resolved through the project's uid cache, which holds none for "
+					+ "%s yet, as with a file made since the project was last scanned, so a uid written "
+					+ "now would warn on every load. project_import refresh_uids scans the project, and "
+					+ "writes after it name %s by uid."
 				)
 				% [
 					", ".join(GdhSceneUids.by_path),

package/build/godot/operations/gdscript_authoring.gd

@@ -116,7 +116,10 @@ func create_gdscript(params: Dictionary) -> Dictionary:
 	# answered for a file whose header says otherwise, so those are read off the text instead.
 	if parses:
 		answer["extends"] = _base_named(written)
-		answer["class_name"] = str(written.get_global_name())
+		var declared: String = str(written.get_global_name())
+		answer["class_name"] = null
+		if not declared.is_empty():
+			answer["class_name"] = declared
 	else:
 		answer.merge(_header_written(script_content))
 	return answer
@@ -134,9 +137,10 @@ static func _not_gdscript(path: String, doing: String) -> String:
 
 
 ## The class_name and extends [param text] declares at its margin, as written. A script with no
-## extends extends RefCounted.
+## extends extends RefCounted, and one with no class_name answers null for it, as an absent name
+## does everywhere else rather than as a name that is empty.
 static func _header_written(text: String) -> Dictionary:
-	var header: Dictionary = {"extends": "RefCounted", "class_name": ""}
+	var header: Dictionary = {"extends": "RefCounted", "class_name": null}
 	for line: String in text.split("\n"):
 		# An inner class's extends is indented, and is not the script's.
 		if line.begins_with(" ") or line.begins_with("\t"):