gdharness 1.3.6 → 1.3.8

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

@@ -152,7 +152,7 @@ static func not_of_kind(
 	if not found.is_empty():
 		told += ' The node at "%s" is %s, not %s.' % [node_path, with_article(found), with_article(kind)]
 	if holders.is_empty():
-		return told + " The scene holds no %s." % kind
+		return told + " The scene holds no %s; scene_node add with nodeType %s puts one in it." % [kind, kind]
 	var quoted: PackedStringArray = []
 	for holder: String in holders.slice(0, NAMED_CHILDREN):
 		var _quoted: bool = quoted.append('"%s"' % holder)

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

@@ -170,17 +170,18 @@ func restart_editor(_args: Dictionary) -> Dictionary:
 			)
 		}
 
-	var unsaved: Dictionary = _save_everything()
-	if not unsaved.is_empty():
-		return unsaved
+	var saving: Dictionary = _save_everything()
+	if not saving.has("saved"):
+		return saving
 
 	# Deferred so this answer is on its way out before the editor goes.
 	EditorInterface.restart_editor.call_deferred(true)
 
-	return {"ok": true, "restarting": true, "saved": true}
+	return {"ok": true, "restarting": true, "saved": saving["saved"]}
 
 
-## Saves every open scene, answering a refusal naming what is still unsaved, or {}.
+## Saves every open scene, answering a refusal naming what is still unsaved, or the scenes that had
+## changes and were saved, under `saved`.
 ##
 ## Read back rather than assumed: save_all_scenes answers nothing and passes over a scene that has
 ## never been saved, which has no path to go to, so an untitled scene was lost with the editor while
@@ -188,10 +189,11 @@ func restart_editor(_args: Dictionary) -> Dictionary:
 static func _save_everything() -> Dictionary:
 	if EditorInterface.is_playing_scene():
 		EditorInterface.stop_playing_scene()
+	var changed: PackedStringArray = EditorInterface.get_unsaved_scenes()
 	EditorInterface.save_all_scenes()
 	var left: PackedStringArray = EditorInterface.get_unsaved_scenes()
 	if left.is_empty():
-		return {}
+		return {"ok": true, "saved": changed}
 	var named: Array[String] = []
 	for scene: String in left:
 		named.append(scene if not scene.is_empty() else "a scene that has never been saved")
@@ -221,14 +223,14 @@ static func _save_everything() -> Dictionary:
 ## Saved first, exactly as the restart above saves. The editor is going either way, and unsaved
 ## scenes are not this tool's to lose.
 func quit_editor(_args: Dictionary) -> Dictionary:
-	var unsaved: Dictionary = _save_everything()
-	if not unsaved.is_empty():
-		return unsaved
+	var saving: Dictionary = _save_everything()
+	if not saving.has("saved"):
+		return saving
 
 	# Deferred so this answer is on its way out before the editor goes.
 	_leave.call_deferred()
 
-	return {"ok": true, "quitting": true, "saved": true}
+	return {"ok": true, "quitting": true, "saved": saving["saved"]}
 
 
 ## What the editor said as it started each of its servers, and the debug adapter started again when

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

@@ -285,6 +285,17 @@ func modify_resource(args: Dictionary) -> Dictionary:
 	var resource: Resource = ResourceLoader.load(res_path, "", ResourceLoader.CACHE_MODE_IGNORE)
 	if resource == null:
 		return {"ok": false, "error": "%s did not load as a resource." % res_path}
+	# A scene's own properties are its packed bundle, so a property named for a scene is one of its
+	# nodes', and "PackedScene has no property" left the caller looking for the tool that sets it.
+	if resource is PackedScene:
+		return {
+			"ok": false,
+			"error":
+			(
+				"%s is a scene: scene_node set changes one node's properties, the root's at nodePath \".\"."
+				% res_path
+			)
+		}
 
 	var properties: Dictionary = _parse_properties_dict(args.get("properties", ""))
 	var refused: String = _properties.write_all(resource, properties)

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

@@ -152,7 +152,7 @@ static func not_of_kind(
 	if not found.is_empty():
 		told += ' The node at "%s" is %s, not %s.' % [node_path, with_article(found), with_article(kind)]
 	if holders.is_empty():
-		return told + " The scene holds no %s." % kind
+		return told + " The scene holds no %s; scene_node add with nodeType %s puts one in it." % [kind, kind]
 	var quoted: PackedStringArray = []
 	for holder: String in holders.slice(0, NAMED_CHILDREN):
 		var _quoted: bool = quoted.append('"%s"' % holder)

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

@@ -67,6 +67,13 @@ const SCRIPT_FLAGS: PackedStringArray = ["-s", "--script"]
 ## Serve a script run anyway, for somebody driving a `-s` script rather than a game.
 const SCRIPT_RUNS_SETTING: String = "gdharness/runtime/serve_script_runs"
 
+## The `res://` folders of scenes that are not the game, such as a bench: a run started on one is
+## not served. Kept in step with `QUIET_SCENES_SETTING` in src/setup.ts.
+const QUIET_SCENES_SETTING: String = "gdharness/runtime/quiet_scenes_under"
+
+## What the engine takes a bare argument for as the scene to run, by its extension.
+const SCENE_EXTENSIONS: PackedStringArray = ["tscn", "scn", "escn", "res", "tres"]
+
 ## The variable the editor addon puts into its own environment, which every game the editor plays
 ## inherits: it says which editor played this game, so a server can tell the editor's game from
 ## another of the same project that some other server started. Kept in step with
@@ -123,6 +130,9 @@ var _commands: Dictionary = {}
 var _loaded_version: String = _read_marker(VERSION_MARKER)
 var _loaded_digest: String = _read_marker(DIGEST_MARKER)
 var _profile_received: bool = false
+## Whether whatever started this game asked for a profile from its start, read before the variable
+## is taken out of the environment.
+var _profiled_from_start: bool = false
 var _close_asked: bool = false
 var _close_frames: int = 0
 var _profiler_calibrated: bool = false
@@ -200,7 +210,9 @@ static func _window_dimension(axis: String, fallback: int) -> int:
 func _wait_for_the_profiler() -> void:
 	if OS.get_environment(PROFILE_FROM_START).is_empty():
 		return
-	# Read once: a process this game starts inherits its environment and must not wait as well.
+	_profiled_from_start = true
+	# Read once: a process this game starts inherits its environment and must not wait as well, nor
+	# be served as a profiled run where a quiet scene would not be, as a bench's workers are.
 	OS.unset_environment(PROFILE_FROM_START)
 	if not EngineDebugger.is_active():
 		return
@@ -446,6 +458,15 @@ func _start_server() -> void:
 		_enabled = false
 		return
 
+	# Nor a scene the project says is not the game. A bench is handed to the engine as a scene, the
+	# way a screen is, so it announced as the game for as long as it ran, and so did every worker
+	# engine it started, all under the project's own path. One started to be profiled from its start
+	# is served all the same, since only this addon hands the totals back as it quits.
+	var prefixes: Variant = ProjectSettings.get_setting(QUIET_SCENES_SETTING, PackedStringArray())
+	if not _profiled_from_start and not quiet_scene_in(OS.get_cmdline_args(), prefixes).is_empty():
+		_enabled = false
+		return
+
 	_server = TCPServer.new()
 	# listen() defaults bind_address to "*", which exposes the game to the whole network.
 	var bind_address: String = str(ProjectSettings.get_setting(BIND_ADDRESS_SETTING, DEFAULT_BIND_ADDRESS))
@@ -474,6 +495,29 @@ func _start_server() -> void:
 		print(listening)
 
 
+## The scene [param given] names for the engine to run, as a `res://` path, when it lies under one of
+## [param prefixes]; otherwise empty. The engine takes any bare argument ending in a scene's
+## extension for the scene, relative to the project or absolute, so each is read as it would.
+static func quiet_scene_in(given: PackedStringArray, prefixes: Variant) -> String:
+	# A PackedStringArray as project.godot writes one, or an Array of strings as a hand might.
+	var folders: PackedStringArray = []
+	if prefixes is PackedStringArray:
+		folders = prefixes
+	elif prefixes is Array:
+		var listed: Array = prefixes
+		for prefix: Variant in listed:
+			if prefix is String:
+				var _kept: bool = folders.append(str(prefix))
+	for argument: String in given:
+		if argument.begins_with("-") or not SCENE_EXTENSIONS.has(argument.get_extension().to_lower()):
+			continue
+		var scene: String = ProjectSettings.localize_path(argument)
+		for folder: String in folders:
+			if not folder.is_empty() and scene.begins_with(folder):
+				return scene
+	return ""
+
+
 ## Whether the engine was told to run a script rather than the game.
 func _script_run() -> bool:
 	var given: PackedStringArray = OS.get_cmdline_args()

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

@@ -10,6 +10,9 @@ const GdhScreen = preload("runtime_screen.gd")
 ## How far zoom enlarges at most. Sixteen makes a 3-pixel ring 48 pixels across, past any need to
 ## see it, and a 200-pixel region 3200, past the size anybody reads a picture at.
 const ZOOM_MOST: int = 16
+## Measured on a downstream game's 1280x720 frame: its interface text and pixel art read as they do
+## in the PNG, at a fifth of the PNG's size.
+const JPEG_QUALITY: float = 0.8
 
 var _host: Node
 var _values: GdhValues
@@ -385,16 +388,28 @@ func _capture(viewport: Viewport, params: Dictionary, with_windows: bool = false
 				% screenshot_path.get_base_dir()
 			)
 		)
-	var save_error: Error = image.save_png(screenshot_path)
+	var answer: Dictionary = saved(image, screenshot_path)
+	answer.merge(described)
+	return answer
+
+
+## [param image] saved as a PNG at [param png_path], and as a JPEG beside it, which the server sends
+## instead when it is the smaller: a rendered frame is several times smaller as one, and every
+## picture sent stays in the caller's session. Not for a picture with transparency, which a JPEG
+## would flatten.
+static func saved(image: Image, png_path: String) -> Dictionary:
+	var save_error: Error = image.save_png(png_path)
 	if save_error != OK:
 		return {"type": "error", "message": "Failed to save screenshot as PNG: " + str(save_error)}
-
 	var answer: Dictionary = {
 		"type": "screenshot_file",
 		"format": "png",
 		"width": image.get_width(),
 		"height": image.get_height(),
-		"path": screenshot_path
+		"path": png_path
 	}
-	answer.merge(described)
+	if image.detect_alpha() == Image.ALPHA_NONE:
+		var jpeg_path: String = png_path.get_basename() + ".jpg"
+		if image.save_jpg(jpeg_path, JPEG_QUALITY) == OK:
+			answer["jpegPath"] = jpeg_path
 	return answer

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

@@ -524,7 +524,9 @@ static func _not_a_method_to_call(holder: Object, named: String, called: String)
 				% [called, named]
 			)
 		method = GdhPaths.method_of(named)
-	return "" if holder.has_method(method) else "%s has no method %s" % [called, method]
+	if holder.has_method(method):
+		return ""
+	return GdhPaths.with_methods_offered("%s has no method %s" % [called, method], holder, method)
 
 
 ## Whether a call's `properties` asks for its result to be read: true, or a list of names.

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

@@ -9,7 +9,7 @@ extends RefCounted
 ## platform when the pointer crosses into the window, sets it. An injected event never crosses
 ## anything, and on gdharness's own desktop no pointer ever enters a window, so nothing was hovered.
 ## A BaseButton takes a mouse press only while hovered, so every click on a button in such a window
-## was dropped while the press itself was routed to it. Reported from Tall Tales Inn, whose strip
+## was dropped while the press itself was routed to it. Reported from Game C, whose strip
 ## window holds its first-run question, and traced through Godot 4.7.2's source.
 ##
 ## What is supplied is what the engine does once the window has been entered: the control its own

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

@@ -157,6 +157,7 @@ func inject_action(params: Dictionary) -> Dictionary:
 		return {"type": "error", "message": holding}
 	var frames: int = holding
 
+	var focused: String = _focus_owner()
 	_say_action(action, whole or held, strength)
 	var lasted: Variant = null
 	if whole:
@@ -166,15 +167,34 @@ func inject_action(params: Dictionary) -> Dictionary:
 		_say_action(action, false, strength)
 		await _host.get_tree().process_frame
 
-	return {
-		"type": "input_injected",
-		"input_type": "action",
-		"action": action,
-		"pressed": held and not whole,
-		"whole": whole,
-		"held_frames": GdhValues.held_answer(whole, frames),
-		"held_for": lasted,
-	}
+	return _focus_noted(
+		{
+			"type": "input_injected",
+			"input_type": "action",
+			"action": action,
+			"pressed": held and not whole,
+			"whole": whole,
+			"held_frames": GdhValues.held_answer(whole, frames),
+			"held_for": lasted,
+		},
+		focused
+	)
+
+
+## The path of the Control holding the keyboard focus, or "" when none does. Read before a key or an
+## action goes in, since pressing a focused button can move the focus.
+func _focus_owner() -> String:
+	var holding: Control = _host.get_viewport().gui_get_focus_owner()
+	return "" if holding == null else str(holding.get_path())
+
+
+## [param said] with [param focused], the Control that had the focus, under focused. A key or an action
+## reaches that Control before the game's _unhandled_input, so Space on a focused Button pressed it
+## and the game's own handler counted the key as well, with nothing in the answer saying why.
+static func _focus_noted(said: Dictionary, focused: String) -> Dictionary:
+	if not focused.is_empty():
+		said["focused"] = focused
+	return said
 
 
 func _say_action(action: String, down: bool, strength: float) -> void:
@@ -230,6 +250,7 @@ func inject_key(params: Dictionary) -> Dictionary:
 	# keys are the code points themselves, which is what makes this a mapping and not a table.
 	event.unicode = GdhValues.glyph_of(event.keycode, event.shift_pressed)
 
+	var focused: String = _focus_owner()
 	Input.parse_input_event(event)
 	var lasted: Variant = null
 	if whole:
@@ -239,20 +260,23 @@ func inject_key(params: Dictionary) -> Dictionary:
 		Input.parse_input_event(up)
 		await _host.get_tree().process_frame
 
-	return {
-		"type": "input_injected",
-		"input_type": "key",
-		"held_frames": GdhValues.held_answer(whole, frames),
-		"held_for": lasted,
-		"keycode": event.keycode,
-		"physical_keycode": event.physical_keycode,
-		"shift": event.shift_pressed,
-		"ctrl": event.ctrl_pressed,
-		"alt": event.alt_pressed,
-		"unicode": event.unicode,
-		"pressed": held and not whole,
-		"whole": whole,
-	}
+	return _focus_noted(
+		{
+			"type": "input_injected",
+			"input_type": "key",
+			"held_frames": GdhValues.held_answer(whole, frames),
+			"held_for": lasted,
+			"keycode": event.keycode,
+			"physical_keycode": event.physical_keycode,
+			"shift": event.shift_pressed,
+			"ctrl": event.ctrl_pressed,
+			"alt": event.alt_pressed,
+			"unicode": event.unicode,
+			"pressed": held and not whole,
+			"whole": whole,
+		},
+		focused
+	)
 
 
 ## Clicks a mouse button at a position, and lets go of it again unless asked to hold it.

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

@@ -257,7 +257,7 @@ static func can_read(holder: Variant, named: String) -> bool:
 ## counted as unclean for a read.
 ##
 ## A step written in double quotes is the key inside them, so a key holding a colon is one step:
-## Alchemill keys its stock by namespaced ids, "stock:\"base:dew\"", and split at that colon the
+## Game D keys its stock by namespaced ids, "stock:\"base:dew\"", and split at that colon the
 ## step named a key "base" the map had never had.
 static func _key_in(map: Dictionary, named: String) -> Array:
 	var word: String = key_written(named)
@@ -416,7 +416,7 @@ static func _arity(object: Object, method: String) -> Dictionary:
 static func call_refused(object: Object, method: String, called_as: String, given: int = 0) -> String:
 	var arity: Dictionary = _arity(object, method)
 	if arity.is_empty():
-		return "%s has no method %s" % [called_as, method]
+		return with_methods_offered("%s has no method %s" % [called_as, method], object, method)
 	var least: int = arity["least"]
 	var most: int = arity["most"]
 	var any_more: bool = arity["any_more"]
@@ -454,6 +454,32 @@ static func call_refused(object: Object, method: String, called_as: String, give
 	return ""
 
 
+## [param said], a refusal for [param method], which [param object] lacks, with the methods it has
+## nearest the name, or else those its script declares. The engine's own run to hundreds on a node,
+## so they are offered only when one is near.
+static func with_methods_offered(said: String, object: Object, method: String) -> String:
+	var own: Array[String] = []
+	var attached: Variant = object.get_script()
+	if attached is Script:
+		var script: Script = attached
+		for entry: Dictionary in script.get_script_method_list():
+			var name: String = str(entry.get("name", ""))
+			if not name.is_empty() and not own.has(name):
+				own.append(name)
+	var every: Array[String] = own.duplicate()
+	for entry: Dictionary in object.get_method_list():
+		var name: String = str(entry.get("name", ""))
+		if not every.has(name):
+			every.append(name)
+	var close: PackedStringArray = GdhRead.nearest(method, PackedStringArray(every))
+	if not close.is_empty():
+		return "%s; the nearest it has %s %s" % [said, "is" if close.size() == 1 else "are", ", ".join(close)]
+	if own.is_empty():
+		return said
+	own.sort()
+	return "%s; its script declares %s" % [said, ", ".join(PackedStringArray(own))]
+
+
 ## The entry a script attached to [param object] declares for [param method], or an empty one when
 ## the method is the engine's.
 static func _script_method(object: Object, method: String) -> Dictionary:

package/build/godot/operations/dependencies.gd

@@ -168,6 +168,16 @@ func find_resource_usages(params: Dictionary) -> Dictionary:
 	var by_class: RegEx = null
 	if not class_name_declared.is_empty():
 		by_class = GdhPatterns.compiled("\\b" + _regex_escaped(class_name_declared) + "\\b")
+	# The script of an autoload is used wherever code names the autoload, and asked what uses it,
+	# the answer was its line in project.godot alone, beside the scripts calling it.
+	var autoload_named: String = ""
+	var autoloads: Dictionary = autoloads_declared()
+	for name: String in autoloads:
+		if str(autoloads[name]) == resource_path:
+			autoload_named = name
+	var by_autoload: RegEx = null
+	if not autoload_named.is_empty():
+		by_autoload = GdhPatterns.compiled("\\b" + _regex_escaped(autoload_named) + "\\b")
 	var target: Dictionary = {
 		"path": resource_path,
 		"uid": str(GdhResourceFiles.uid_of(resource_path).get("uid", "")) if exists else ""
@@ -203,7 +213,12 @@ func find_resource_usages(params: Dictionary) -> Dictionary:
 				# Strings are text, so a class named in one is not a use of it.
 				by_its_name = by_class.search(_code_of(line)) != null
 				name_in_comment = not by_its_name and by_class.search(_comment_of(line)) != null
-			if not by_its_path and not by_its_name and not name_in_comment:
+			var by_its_autoload: bool = false
+			if not by_its_path and not by_its_name and code and by_autoload != null:
+				by_its_autoload = by_autoload.search(_code_of(line)) != null
+				if not by_its_autoload and not name_in_comment:
+					name_in_comment = by_autoload.search(_comment_of(line)) != null
+			if not by_its_path and not by_its_name and not by_its_autoload and not name_in_comment:
 				continue
 			var trimmed: String = line.strip_edges()
 			var kind: String = ""
@@ -219,6 +234,8 @@ func find_resource_usages(params: Dictionary) -> Dictionary:
 				kind = "comment"
 			elif by_its_path:
 				kind = _path_reference_kind(line, file_path)
+			elif by_its_autoload:
+				kind = "autoload"
 			else:
 				kind = (
 					"extends"
@@ -244,7 +261,7 @@ func find_resource_usages(params: Dictionary) -> Dictionary:
 	var declared: Variant = null
 	if not class_name_declared.is_empty():
 		declared = class_name_declared
-	return {
+	var answer: Dictionary = {
 		"resource_path": resource_path,
 		"exists": exists,
 		"class_name": declared,
@@ -260,6 +277,9 @@ func find_resource_usages(params: Dictionary) -> Dictionary:
 			"by_kind": by_kind,
 		},
 	}
+	if not autoload_named.is_empty():
+		answer["autoload"] = autoload_named
+	return answer
 
 
 # The class_name a script declares, or empty for a scene, a resource or a script without one.
@@ -477,15 +497,19 @@ func _analyze_resource(path: String, current_depth: int, walk: GdhDependencyWalk
 				if not walk.include_built_in and dep_path.begins_with("res://."):
 					continue
 
-				_depend(deps, path, dep_path, "", current_depth, walk)
+				_depend(deps, path, dep_path, {}, current_depth, walk)
 
 		# A script uses another by its class_name as surely as by a preload, and only the reverse walk
 		# looked for that: asked what a script depends on, the answer left out the script it typed a
-		# variable with, while asking what used that script named this one.
+		# variable with, while asking what used that script named this one. An autoload's global
+		# name is the same kind of use, of the script registered under it.
 		if path.get_extension() == "gd":
 			var classes: Dictionary = classes_declared()
 			for used: String in classes_used_in(content, classes):
-				_depend(deps, path, str(classes[used]), used, current_depth, walk)
+				_depend(deps, path, str(classes[used]), {"by_class": used}, current_depth, walk)
+			var autoloads: Dictionary = autoloads_declared()
+			for used: String in classes_used_in(content, autoloads):
+				_depend(deps, path, str(autoloads[used]), {"by_autoload": used}, current_depth, walk)
 
 	walk.path_stack.pop_back()
 	walk.visited[path] = {"deps": deps, "remaining": remaining}
@@ -493,13 +517,13 @@ func _analyze_resource(path: String, current_depth: int, walk: GdhDependencyWalk
 
 
 # Adds [param dep_path] to [param deps], what [param path] depends on, walked as far as the depth left
-# allows, once however many times it is named. [param by_class] is the class name it was named by,
-# or empty for a path.
+# allows, 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, or empty for a path.
 func _depend(
 	deps: Array[Dictionary],
 	path: String,
 	dep_path: String,
-	by_class: String,
+	named_by: Dictionary,
 	current_depth: int,
 	walk: GdhDependencyWalk
 ) -> void:
@@ -509,8 +533,7 @@ func _depend(
 		if existing.get("path", "") == dep_path:
 			return
 	var dep_info: Dictionary = {"path": dep_path, "exists": FileAccess.file_exists(dep_path)}
-	if not by_class.is_empty():
-		dep_info["by_class"] = by_class
+	dep_info.merge(named_by)
 	if dep_info["exists"] and current_depth + 1 < walk.max_depth:
 		var sub_deps: Array[Dictionary] = _analyze_resource(dep_path, current_depth + 1, walk)
 		if sub_deps.size() > 0:
@@ -518,6 +541,22 @@ func _depend(
 	deps.append(dep_info)
 
 
+## Every autoload the project registers as a global name, with its script. One that is not global
+## is no name code can use.
+static func autoloads_declared() -> Dictionary:
+	var autoloads: Dictionary = {}
+	for property: Dictionary in ProjectSettings.get_property_list():
+		var setting: String = str(property.get("name", ""))
+		if not setting.begins_with("autoload/"):
+			continue
+		var value: String = str(ProjectSettings.get_setting(setting))
+		if value.begins_with("*"):
+			autoloads[setting.trim_prefix("autoload/")] = _resolved(
+				value.trim_prefix("*"), "res://project.godot"
+			)
+	return autoloads
+
+
 ## Every class_name the project's scripts declare, with the script declaring it.
 func classes_declared() -> Dictionary:
 	if _classes_read:
@@ -530,6 +569,18 @@ func classes_declared() -> Dictionary:
 	return _classes_declared
 
 
+## Every class the project's scripts declare with class_name, sorted by name, with the script
+## declaring it. Read from the files rather than the class cache, which only a scan rewrites.
+func list_script_classes(_params: Dictionary) -> Dictionary:
+	var declared: Dictionary = classes_declared()
+	var names: Array = declared.keys()
+	names.sort()
+	var classes: Array[Dictionary] = []
+	for name: Variant in names:
+		classes.append({"name": str(name), "path": str(declared[name])})
+	return {"classes": classes, "count": classes.size()}
+
+
 ## The names in [param classes] that the code in [param content] uses, in the order first used: words
 ## outside strings and comments, so a class named in prose or in a message is not a use of it.
 static func classes_used_in(content: String, classes: Dictionary) -> Array[String]: