gdharness 1.1.5 → 1.1.7

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

@@ -80,10 +80,13 @@ func _init_tools() -> void:
 		"list_connections": [_scene_tools, "list_connections"],
 		"rescan_filesystem": [_scene_tools, "rescan_filesystem"],
 		"scan_status": [_scene_tools, "scan_status"],
+		"reimport_files": [_scene_tools, "reimport_files"],
 		"global_classes": [_class_tools, "global_classes"],
 		"reload_script": [_class_tools, "reload_script"],
 		# Settings, for a caller that asked the editor rather than the file on disk
 		"get_project_setting": [_settings_tools, "get_project_setting"],
+		"adopt_project_settings": [_settings_tools, "adopt_project_settings"],
+		"adopt_audio_bus_layout": [_settings_tools, "adopt_audio_bus_layout"],
 		# Resource tools
 		"create_resource": [_resource_tools, "create_resource"],
 		"modify_resource": [_resource_tools, "modify_resource"],

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

@@ -24,6 +24,10 @@ var _scans_completed: int = 0
 ## whether that write can still be coming.
 var _scan_finished_at_msec: int = -1
 
+## How many reimports asked for through [method reimport_files] have finished. Counted here rather
+## than off `resources_reimported`, which a scan's own import emits as well.
+var _reimports_completed: int = 0
+
 
 func set_editor_plugin(plugin: EditorPlugin) -> void:
 	_editor_plugin = plugin
@@ -701,4 +705,44 @@ func scan_status(_args: Dictionary) -> Dictionary:
 		"importing": filesystem.is_importing(),
 		"sinceScanFinishedMs":
 		-1 if _scan_finished_at_msec < 0 else Time.get_ticks_msec() - _scan_finished_at_msec,
+		"reimportsCompleted": _reimports_completed,
+	}
+
+
+## Reimport the files named under `paths`, whatever their state, the way the editor's Reimport
+## button does, and report whether the reimport was started.
+##
+## Started on the next frame rather than run here: the editor imports on its main thread, and a
+## reimport of a few hundred scenes outlasts the wait on any one command. The caller waits for
+## `reimportsCompleted` in [method scan_status] to move past `reimportsCompletedBefore`. Declined
+## while the editor scans or imports, since `reimport_files` refuses to run inside an import.
+func reimport_files(args: Dictionary) -> Dictionary:
+	if not _editor_plugin:
+		return {"ok": false, "error": "Editor plugin unavailable"}
+	var paths: Array[String] = []
+	var given: Variant = args.get("paths", [])
+	if given is Array:
+		for path: Variant in given:
+			paths.append(str(path))
+	if paths.is_empty():
+		return {"ok": false, "error": "reimport_files needs paths"}
+	var filesystem: EditorFileSystem = EditorInterface.get_resource_filesystem()
+	var busy: bool = filesystem.is_scanning() or filesystem.is_importing()
+	if not busy:
+		_reimport.call_deferred(PackedStringArray(paths))
+	return {
+		"ok": true,
+		"started": not busy,
+		"scanning": filesystem.is_scanning(),
+		"importing": filesystem.is_importing(),
+		"reimportsCompletedBefore": _reimports_completed,
 	}
+
+
+func _reimport(paths: PackedStringArray) -> void:
+	var filesystem: EditorFileSystem = EditorInterface.get_resource_filesystem()
+	# A scan can begin between the answer and this frame, and its import would refuse this one.
+	while filesystem.is_scanning() or filesystem.is_importing():
+		await get_tree().process_frame
+	filesystem.reimport_files(paths)
+	_reimports_completed += 1

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

@@ -1,7 +1,8 @@
 @tool
 extends Node
 
-## Project settings read from the open editor, for a caller that asked for the editor's answer.
+## Project settings read from the open editor, for a caller that asked for the editor's answer, and
+## taken up by it after a write to the file.
 ##
 ## The same question answered headless starts an engine, loads project.godot from disk and exits.
 ## This answers from the ProjectSettings the editor already has, which costs nothing and is not the
@@ -56,3 +57,51 @@ func _settings_under(prefix: String) -> Dictionary:
 
 	found.sort_custom(func(a: Dictionary, b: Dictionary) -> bool: return a["setting"] < b["setting"])
 	return {"ok": true, "prefix": prefix, "count": found.size(), "settings": found}
+
+
+## Takes the named settings from project.godot as it is on disk, after something else wrote it.
+##
+## The editor loads the file once, at startup. Written from outside, it goes on holding the old
+## values, answers them when asked, and writes them back over the new ones the next time it saves
+## the project settings. A setting gone from the file goes back to its default, or goes altogether
+## when the engine declares none, as an autoload does once it is removed.
+func adopt_project_settings(args: Dictionary) -> Dictionary:
+	var file: ConfigFile = ConfigFile.new()
+	var loaded: Error = file.load("res://project.godot")
+	if loaded != OK:
+		return {"ok": false, "error": "Could not read project.godot: " + error_string(loaded)}
+	var adopted: Array[String] = []
+	var named: Variant = args.get("settings", [])
+	if not named is Array:
+		return {"ok": false, "error": "settings must be a list of setting names"}
+	var settings: Array = named
+	for entry: Variant in settings:
+		var setting: String = str(entry)
+		var at: int = setting.find("/")
+		if at <= 0:
+			continue
+		var section: String = setting.substr(0, at)
+		var key: String = setting.substr(at + 1)
+		if file.has_section_key(section, key):
+			ProjectSettings.set_setting(setting, file.get_value(section, key))
+		elif ProjectSettings.property_can_revert(setting):
+			ProjectSettings.set_setting(setting, ProjectSettings.property_get_revert(setting))
+		else:
+			ProjectSettings.set_setting(setting, null)
+		adopted.append(setting)
+	return {"ok": true, "adopted": adopted}
+
+
+## Loads the bus layout the project names into the editor's audio server, after something else
+## wrote it: the editor holds the layout it loaded and saves that one when its audio panel changes.
+func adopt_audio_bus_layout(_args: Dictionary) -> Dictionary:
+	var path: String = str(
+		ProjectSettings.get_setting("audio/buses/default_bus_layout", "res://default_bus_layout.tres")
+	)
+	var layout: AudioBusLayout = ResourceLoader.load(
+		path, "AudioBusLayout", ResourceLoader.CACHE_MODE_REPLACE
+	)
+	if layout == null:
+		return {"ok": false, "error": "Could not load the bus layout at " + path}
+	AudioServer.set_bus_layout(layout)
+	return {"ok": true, "layout": path}

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

@@ -13,13 +13,13 @@ func _init(host: Node) -> void:
 
 
 func capture_screenshot(params: Dictionary) -> Dictionary:
-	return _capture(_host.get_tree().root, params)
+	return await _capture(_host.get_tree().root, params)
 
 
 func capture_viewport(params: Dictionary) -> Dictionary:
 	var viewport_path: String = str(params.get("viewportPath", ""))
 	if viewport_path.is_empty():
-		return capture_screenshot(params)
+		return await capture_screenshot(params)
 
 	var standing: Dictionary = Values.node_at(_host.get_tree().root, viewport_path)
 	if standing.has("message"):
@@ -28,7 +28,7 @@ func capture_viewport(params: Dictionary) -> Dictionary:
 	if not node is Viewport:
 		return {"type": "error", "message": "Node is not a Viewport: " + viewport_path}
 	var viewport: Viewport = node
-	return _capture(viewport, params)
+	return await _capture(viewport, params)
 
 
 ## The server names the file, so a game cannot point it at a path of its own choosing; a call
@@ -66,6 +66,13 @@ func _capture(viewport: Viewport, params: Dictionary) -> Dictionary:
 			),
 		}
 
+	# The game announces itself before its first frame, and until a frame has been drawn the texture
+	# holds nothing the game drew: blank on one machine, solid white on another, which a caller took
+	# for the game flashing white on boot. Measured on 4.7.2 with both renderers, only the first
+	# processed frame reads it so; the next one holds the scene.
+	while Engine.get_frames_drawn() == 0:
+		await _host.get_tree().process_frame
+
 	var viewport_texture: ViewportTexture = viewport.get_texture()
 	if viewport_texture == null:
 		return {"type": "error", "message": "No viewport texture available"}

package/build/godot/operations/godot_operations.gd

@@ -118,8 +118,6 @@ func _run(operation: String, params: Dictionary) -> Dictionary:
 			payload = ImportPipeline.new(_log).get_import_options(params)
 		"set_import_options":
 			payload = ImportPipeline.new(_log).set_import_options(params)
-		"reimport_resource":
-			payload = ImportPipeline.new(_log).reimport_resource(params)
 		"list_export_presets":
 			payload = ImportPipeline.new(_log).list_export_presets(params)
 		"validate_project":

package/build/godot/operations/import_pipeline.gd

@@ -4,17 +4,45 @@ const Read = preload("reading.gd")
 const FileWalk = preload("file_walk.gd")
 const Log = preload("logger.gd")
 
+## What the engine imports with no tool outside it, for finding what has not been imported yet;
+## everything imported already is found by its sidecar whatever its extension.
 const IMPORTABLE_EXTENSIONS: Array[String] = [
-	"png", "jpg", "jpeg", "webp", "svg", "wav", "mp3", "ogg", "ttf", "otf", "glb", "gltf", "fbx", "obj"
+	"png",
+	"jpg",
+	"jpeg",
+	"webp",
+	"svg",
+	"bmp",
+	"tga",
+	"exr",
+	"hdr",
+	"dds",
+	"ktx",
+	"wav",
+	"mp3",
+	"ogg",
+	"ttf",
+	"otf",
+	"ttc",
+	"otc",
+	"woff",
+	"woff2",
+	"pfb",
+	"pfm",
+	"fnt",
+	"font",
+	"glb",
+	"gltf",
+	"fbx",
+	"obj",
+	"dae",
 ]
-
-## How many resources a scene's dependencies are followed through before the walk stops: a scene's
-## materials and what they use are a handful, and a project that references its way around a cycle
-## is not walked for ever.
-const DEPENDENCY_WALK_LIMIT: int = 200
+const EDITOR_DIRECTORY: String = "res://.godot/editor"
+const EDITOR_CACHE_PREFIX: String = "filesystem_cache"
 
 var _log: Log
 var _files: FileWalk = FileWalk.new()
+var _sidecar_md5s: Variant = null
 
 
 func _init(p_log: Log) -> void:
@@ -34,7 +62,9 @@ func get_import_status(params: Dictionary) -> Dictionary:
 	)
 
 	var resources: Array[Dictionary] = []
-	var summary: Dictionary = {"total": 0, "needs_reimport": 0, "up_to_date": 0, "missing_source": 0}
+	var summary: Dictionary = {
+		"total": 0, "needs_reimport": 0, "failed": 0, "up_to_date": 0, "missing_source": 0
+	}
 
 	if not resource_path.is_empty():
 		var full_path: String = resource_path
@@ -45,7 +75,17 @@ func get_import_status(params: Dictionary) -> Dictionary:
 		resources.append(status)
 		_tally(summary, status)
 	else:
+		# Sources by extension, for what has never been imported, and sidecars, for what was imported
+		# from a type the list does not name and for a sidecar whose source is gone.
+		var found: Dictionary[String, bool] = {}
 		for res_path: String in _files.find_files_with_extensions("res://", IMPORTABLE_EXTENSIONS):
+			found[res_path] = true
+		for sidecar: String in _files.find_files_with_extensions("res://", ["import"]):
+			found[sidecar.trim_suffix(".import")] = true
+		var paths: Array[String] = []
+		paths.assign(found.keys())
+		paths.sort()
+		for res_path: String in paths:
 			var status: Dictionary = _import_status_of(res_path, res_path + ".import")
 
 			if include_up_to_date or status["status"] != "up_to_date":
@@ -96,7 +136,6 @@ func set_import_options(params: Dictionary) -> Dictionary:
 		resource_path = "res://" + resource_path
 
 	var options: Dictionary = params.get("options", {})
-	var do_reimport: bool = Read.as_bool(params.get("reimport", true), true)
 
 	_log.info("Setting import options for: " + resource_path)
 
@@ -115,56 +154,28 @@ func set_import_options(params: Dictionary) -> Dictionary:
 	var updated_keys: Array[String] = []
 	for key: Variant in options:
 		var name: String = str(key)
-		config.set_value("params", name, options[key])
+		var value: Variant = _as_option(options[key], config.get_value("params", name, null))
+		config.set_value("params", name, value)
 		updated_keys.append(name)
-		_log.debug("Set " + name + " = " + str(options[key]))
+		_log.debug("Set " + name + " = " + str(value))
 
 	err = config.save(import_file_path)
 	if err != OK:
 		return _log.failure("Failed to save import file: " + str(err))
 
-	var result: Dictionary = {
-		"resource_path": resource_path, "updated_options": updated_keys, "reimport_triggered": do_reimport
-	}
-
-	# A headless engine has no importer to run, so the .import file is as far as this goes.
-	if do_reimport:
-		result["note"] = "Import file updated. Run the editor or use 'reimport_resource' to apply changes."
-
-	return result
-
-
-# Reimport a resource or all resources
-func reimport_resource(params: Dictionary) -> Dictionary:
-	var resource_path: String = str(params.get("resource_path", ""))
-	var force: bool = Read.as_bool(params.get("force", false))
-
-	_log.info(
-		(
-			"Reimporting"
-			+ (" resource: " + resource_path if not resource_path.is_empty() else " all modified resources")
-		)
-	)
-
-	# A full reimport is editor work; headless can only report what the state is.
-	var result: Dictionary = {
-		"status": "requested",
-		"resource_path": resource_path if not resource_path.is_empty() else "all",
-		"force": force,
-		"note": "Reimport in headless mode is limited. For full reimport, open the project in the editor."
-	}
-
-	if not resource_path.is_empty():
-		var full_path: String = resource_path
-		if not full_path.begins_with("res://"):
-			full_path = "res://" + full_path
-
-		if not FileAccess.file_exists(full_path):
-			return _log.failure("Resource file does not exist: " + full_path)
+	# The reimport that applies them is the server's, through the editor or the engine's import.
+	return {"resource_path": resource_path, "updated_options": updated_keys}
 
-		result["current_status"] = _import_status_of(full_path, full_path + ".import")["status"]
 
-	return result
+## [param given] as the option holds it. Every JSON number arrives as a float, and an enum option
+## such as compress/mode written as 1.0 is kept that way by the import, so a whole number becomes
+## an int unless the option already holds a float.
+static func _as_option(given: Variant, held: Variant) -> Variant:
+	if given is float and not held is float:
+		var number: float = given
+		if number == floorf(number):
+			return int(number)
+	return given
 
 
 # List export presets
@@ -372,7 +383,7 @@ func _import_status_of(resource_path: String, import_file_path: String) -> Dicti
 		return {
 			"path": resource_path,
 			"status": "missing_source",
-			"import_file_exists": false,
+			"import_file_exists": FileAccess.file_exists(import_file_path),
 			"source_exists": false
 		}
 
@@ -381,6 +392,7 @@ func _import_status_of(resource_path: String, import_file_path: String) -> Dicti
 		return {
 			"path": resource_path,
 			"status": "needs_reimport",
+			"reason": "it has not been imported",
 			"import_file_exists": false,
 			"source_exists": true
 		}
@@ -389,33 +401,85 @@ func _import_status_of(resource_path: String, import_file_path: String) -> Dicti
 		"path": resource_path, "status": "up_to_date", "import_file_exists": true, "source_exists": true
 	}
 
+	# The checks are the ones EditorFileSystem::_test_for_reimport makes, in its order, so a resource
+	# reads as needing an import exactly when the editor's next scan would import it.
+	var sidecar: ConfigFile = ConfigFile.new()
+	var stale: Dictionary = (
+		_stale("its import file cannot be read")
+		if sidecar.load(import_file_path) != OK
+		else _sidecar_staleness(resource_path, import_file_path, sidecar)
+	)
+	var kept: bool = str(sidecar.get_value("remap", "importer", "")) in ["keep", "skip"]
+	if stale.is_empty() and not kept:
+		stale = _import_staleness(resource_path, sidecar)
+	status.merge(stale, true)
+	return status
+
+
+static func _stale(reason: String) -> Dictionary:
+	return {"status": "needs_reimport", "reason": reason}
+
+
+## What the editor reads off the sidecar before looking at the import: an answer for a stale or
+## failed resource, empty otherwise.
+func _sidecar_staleness(resource_path: String, import_file_path: String, sidecar: ConfigFile) -> Dictionary:
+	# The editor compares the sidecar with the one it last imported from before reading anything in
+	# it, so an option set without a reimport is imported on its next scan, and not before.
+	var imported_from: String = _imported_sidecar_md5s().get(resource_path, "")
+	if not imported_from.is_empty() and FileAccess.get_md5(import_file_path) != imported_from:
+		return _stale("its import file changed after it was imported, as setting an option does")
+
+	# A failed import is never tried again on its own: the editor skips it to avoid a loop of
+	# reimports, so it stays failed after its source is fixed until something asks for a reimport.
+	var valid: Variant = sidecar.get_value("remap", "valid", true)
+	if valid is bool and not valid:
+		return {
+			"status": "failed",
+			"reason": "its last import failed, and the editor does not try a failed import again on its own",
+		}
+	return {}
+
+
+## Whether the import itself is still the one its sidecar and source describe: an answer for a
+## stale resource, empty for a current one.
+static func _import_staleness(resource_path: String, sidecar: ConfigFile) -> Dictionary:
+	if not sidecar.has_section_key("remap", "uid"):
+		return _stale("its import file has no uid, which the import writes")
+
 	# The sidecar alone does not say the import is there: deleting the outputs under
 	# .godot/imported is the ordinary way to force one, and a resource whose output is gone was
 	# answered as current, which is what a reimport is then skipped on.
-	var outputs: Array[String] = _outputs_of(import_file_path)
+	var outputs: Array[String] = _outputs_of(sidecar)
 	var missing: Array[String] = []
 	for output: String in outputs:
 		if not FileAccess.file_exists(output):
 			missing.append(output)
 	if not missing.is_empty():
-		status["status"] = "needs_reimport"
-		status["reason"] = "its imported output is not on disk"
-		status["missing_outputs"] = missing
-		return status
+		var gone: Dictionary = _stale("its imported output is not on disk")
+		gone["missing_outputs"] = missing
+		return gone
+
+	var source_file: String = str(sidecar.get_value("deps", "source_file", ""))
+	if not source_file.is_empty() and source_file != resource_path:
+		return _stale("its import file was written for " + source_file)
 
 	# By content, as the editor judges it: the hash of the source the import recorded, against the
 	# file. By time, an installer that rewrote 31 images byte for byte made every one read as changed,
 	# and the editor, which compares the hash, rightly imported none of them.
-	var recorded: String = _recorded_source_md5(resource_path)
-	var changed: bool = (
-		FileAccess.get_md5(resource_path) != recorded
-		if not recorded.is_empty()
-		else FileAccess.get_modified_time(resource_path) > FileAccess.get_modified_time(import_file_path)
-	)
-	if changed:
-		status["status"] = "needs_reimport"
-		status["reason"] = "the source changed after it was imported"
-		return status
+	var recorded: Dictionary = _recorded_md5s(resource_path)
+	var recorded_source: String = recorded.get("source_md5", "")
+	if recorded_source.is_empty():
+		return _stale("its import recorded no hash of its source")
+	if FileAccess.get_md5(resource_path) != recorded_source:
+		return _stale("the source changed after it was imported")
+
+	var recorded_outputs: String = recorded.get("dest_md5", "")
+	if (
+		not outputs.is_empty()
+		and not recorded_outputs.is_empty()
+		and _md5_of_all(outputs) != recorded_outputs
+	):
+		return _stale("its imported output changed after it was imported")
 
 	# A scene built without an image it names: it loads each one as it imports, so one imported
 	# before the image was is built without it. Read off what the imported scene depends on, not off
@@ -429,28 +493,102 @@ func _import_status_of(resource_path: String, import_file_path: String) -> Dicti
 	# with one using other images entirely, which is the scene it was meant to build.
 	var without: Array[String] = []
 	var images: Array[String] = _images_of(resource_path)
-	if not images.is_empty() and not _shaped_by_a_script(import_file_path):
+	if not images.is_empty() and not _shaped_by_a_script(sidecar):
 		var depended: Dictionary[String, bool] = _depended_on(resource_path)
 		for image: String in images:
 			if FileAccess.file_exists(image + ".import") and not depended.has(image):
 				without.append(image)
-	if not without.is_empty():
-		status["status"] = "needs_reimport"
-		status["reason"] = "it was imported without images it uses, which were not imported yet"
-		status["imported_without"] = without
-	return status
+	if without.is_empty():
+		return {}
+	var built: Dictionary = _stale("it was imported without images it uses, which were not imported yet")
+	built["imported_without"] = without
+	return built
 
 
-## The hash of its source that [param resource_path]'s last import recorded, or "" when there is no
-## record: the editor keeps it beside the outputs, under the same base name with [code].md5[/code].
-static func _recorded_source_md5(resource_path: String) -> String:
+## The hashes [param resource_path]'s last import recorded, [code]source_md5[/code] of its source
+## and [code]dest_md5[/code] of its outputs, empty when there is no record: the editor keeps them
+## beside the outputs, under the same base name with [code].md5[/code].
+static func _recorded_md5s(resource_path: String) -> Dictionary:
 	var record: String = (
 		"res://.godot/imported/%s-%s.md5" % [resource_path.get_file(), resource_path.md5_text()]
 	)
 	var config: ConfigFile = ConfigFile.new()
 	if config.load(record) != OK:
+		return {}
+	return {
+		"source_md5": str(config.get_value("", "source_md5", "")),
+		"dest_md5": str(config.get_value("", "dest_md5", "")),
+	}
+
+
+## One md5 over the contents of [param paths] in turn, as [code]FileAccess::get_multiple_md5[/code]
+## computes the [code]dest_md5[/code] an import records.
+static func _md5_of_all(paths: Array[String]) -> String:
+	var hashing: HashingContext = HashingContext.new()
+	if hashing.start(HashingContext.HASH_MD5) != OK:
+		return ""
+	for path: String in paths:
+		var file: FileAccess = FileAccess.open(path, FileAccess.READ)
+		if file == null:
+			continue
+		while not file.eof_reached():
+			var chunk: PackedByteArray = file.get_buffer(32768)
+			if chunk.is_empty():
+				break
+			if hashing.update(chunk) != OK:
+				return ""
+	return hashing.finish().hex_encode()
+
+
+## The md5 of each resource's sidecar as the editor last imported it, keyed by path, from the cache
+## the editor writes under .godot/editor; empty when there is no cache or it cannot be read.
+func _imported_sidecar_md5s() -> Dictionary:
+	if _sidecar_md5s != null:
+		return _sidecar_md5s
+	var found: Dictionary = {}
+	_sidecar_md5s = found
+	var cache: String = _editor_cache_path()
+	var file: FileAccess = null if cache.is_empty() else FileAccess.open(cache, FileAccess.READ)
+	if file == null:
+		return found
+	# The first line is the import settings version; then a "::<dir>::<time>" line opens each
+	# directory, and each file line is nine fields split by "::", the last holding the file's
+	# dependencies, which may contain the splitter. The eighth field is "<>"-separated, with the
+	# sidecar's md5 sixth.
+	var directory: String = "res://"
+	var first: bool = true
+	while not file.eof_reached():
+		var line: String = file.get_line().strip_edges()
+		if first:
+			first = false
+			continue
+		if line.is_empty():
+			continue
+		if line.begins_with("::"):
+			var opened: PackedStringArray = line.split("::")
+			if opened.size() == 3:
+				directory = opened[1]
+			continue
+		var fields: PackedStringArray = line.split("::", true, 8)
+		if fields.size() < 9:
+			continue
+		var slices: PackedStringArray = fields[7].split("<>")
+		if slices.size() >= 7 and not slices[5].is_empty():
+			found[directory.path_join(fields[0])] = slices[5]
+	return found
+
+
+## The editor's filesystem cache, the newest version of it when an engine upgrade has left an older
+## one beside it, or "" when the project has none. Its name carries a format version that the
+## engine raises when the layout changes: 4.7.2 writes filesystem_cache10.
+static func _editor_cache_path() -> String:
+	var newest: int = -1
+	if not DirAccess.dir_exists_absolute(EDITOR_DIRECTORY):
 		return ""
-	return str(config.get_value("", "source_md5", ""))
+	for name: String in DirAccess.get_files_at(EDITOR_DIRECTORY):
+		if name.begins_with(EDITOR_CACHE_PREFIX) and name.trim_prefix(EDITOR_CACHE_PREFIX).is_valid_int():
+			newest = maxi(newest, name.trim_prefix(EDITOR_CACHE_PREFIX).to_int())
+	return "" if newest < 0 else EDITOR_DIRECTORY.path_join(EDITOR_CACHE_PREFIX + str(newest))
 
 
 ## The path of one entry [method ResourceLoader.get_dependencies] lists, past any uid and type.
@@ -459,41 +597,32 @@ static func _path_of(entry: String) -> String:
 	return entry if at < 0 else entry.substr(at + 2)
 
 
-## Every path [param resource_path] depends on, through the resources it depends on in turn, as far
-## as [constant DEPENDENCY_WALK_LIMIT] resources; a set, keyed by path.
+## Every path [param resource_path] depends on, through the resources it depends on in turn; a set,
+## keyed by path.
 static func _depended_on(resource_path: String) -> Dictionary[String, bool]:
 	var found: Dictionary[String, bool] = {}
 	var pending: Array[String] = [resource_path]
-	var walked: int = 0
-	while not pending.is_empty() and walked < DEPENDENCY_WALK_LIMIT:
+	# Every path is followed once, which ends the walk and survives a cycle; a cap or a list of
+	# extensions would leave out a material behind a long chain or in a saved .mesh.
+	while not pending.is_empty():
 		var next: String = pending.pop_back()
-		walked += 1
 		for entry: String in ResourceLoader.get_dependencies(next):
 			var path: String = _path_of(entry)
-			if found.has(path):
-				continue
-			found[path] = true
-			# Only what can hold further references: an image or a sound depends on nothing.
-			if path.get_extension().to_lower() in ["tres", "res", "tscn", "scn", "material"]:
+			if not found.has(path):
+				found[path] = true
 				pending.append(path)
 	return found
 
 
-## Whether the import of the file [param import_file_path] describes runs a post-import script.
-static func _shaped_by_a_script(import_file_path: String) -> bool:
-	var config: ConfigFile = ConfigFile.new()
-	if config.load(import_file_path) != OK:
-		return false
-	return not str(config.get_value("params", "import_script/path", "")).is_empty()
+## Whether the import [param sidecar] describes runs a post-import script.
+static func _shaped_by_a_script(sidecar: ConfigFile) -> bool:
+	return not str(sidecar.get_value("params", "import_script/path", "")).is_empty()
 
 
 ## The files an import wrote, from its sidecar's [code]dest_files[/code]; empty when it lists none.
-static func _outputs_of(import_file_path: String) -> Array[String]:
-	var config: ConfigFile = ConfigFile.new()
+static func _outputs_of(sidecar: ConfigFile) -> Array[String]:
 	var outputs: Array[String] = []
-	if config.load(import_file_path) != OK:
-		return outputs
-	var listed: Variant = config.get_value("deps", "dest_files", [])
+	var listed: Variant = sidecar.get_value("deps", "dest_files", [])
 	if listed is Array:
 		for one: Variant in listed:
 			outputs.append(str(one))