gdharness 1.3.11 → 1.3.13

package/build/godot/addons/gdharness_tests/share.gd

@@ -0,0 +1,289 @@
+class_name GdhShare
+extends RefCounted
+## Plays a bench's runs here, or this engine's share of them under `gdharness spread`, and hands
+## back every run's outcome in run order.
+##
+## A bench whose run `i` depends on `i` alone (its seed worked out from the index, nothing carried
+## from one run to the next) calls [method outcomes] for each arm with the number of runs and a
+## callable playing run `i`. Run on its own, the scene plays every run here, as it always did. Under
+## `gdharness spread`, each worker engine plays every Nth run from its own index and leaves what each
+## run answered; then one more engine runs the scene to gather, and there [method outcomes] plays
+## nothing and answers every run's outcome, read back as the type it went in as. The bench folds them
+## in run order either way, so a spread table is the same table to the last digit, floats included.
+##
+## An outcome is a plain value: a number, a string, a vector, or an array or dictionary of them. An
+## object cannot be handed from one engine to another, so one is refused with an error.
+
+## What `gdharness spread` tells a worker: which of how many it is.
+const SHARE: String = "--gdh-share="
+## What it tells the engine gathering: how many workers left outcomes.
+const GATHER: String = "--gdh-share-gather="
+## Where the workers leave their outcomes, an absolute path, since each engine has its own `user://`.
+const INTO: String = "--gdh-share-dir="
+## What a worker prints as it goes, which `gdharness spread` reads to say how far each has got.
+const PROGRESS: String = "gdharness share: %s %d of %d runs"
+
+static var _learnt: bool = false
+static var _index: int = -1
+static var _workers: int = 0
+static var _gathering: int = 0
+static var _directory: String = ""
+static var _arms: Dictionary[String, bool] = {}
+static var _read: bool = false
+static var _unread: String = ""
+static var _found: Dictionary[String, Dictionary] = {}
+static var _found_runs: Dictionary[String, int] = {}
+
+
+## Whether this engine is one of the workers of a spread run, which prints no table.
+static func working() -> bool:
+	_learn()
+	return _index >= 0
+
+
+## Whether this engine is the one gathering a spread run's outcomes.
+static func gathering() -> bool:
+	_learn()
+	return _gathering > 0
+
+
+## The runs of [param runs] this engine plays: every one on its own, its share as a worker (every
+## Nth from its own index, so each worker draws long runs and short ones alike), and none when it
+## gathers.
+static func dealt(runs: int) -> PackedInt32Array:
+	_learn()
+	var played: PackedInt32Array = []
+	if gathering():
+		return played
+	var step: int = _workers if working() else 1
+	for at: int in range(maxi(_index, 0), runs, step):
+		var _added: bool = played.append(at)
+	return played
+
+
+## Every outcome of the arm [param arm]'s [param runs] runs, in run order: played here by
+## [param play], which is called with a run's index, or gathered from the workers. A worker plays
+## its share, leaves the outcomes for the engine gathering, and answers an empty array.
+static func outcomes(arm: String, runs: int, play: Callable) -> Array:
+	_learn()
+	if _arms.has(arm):
+		push_error("GdhShare: the arm %s was played twice in one run; give each arm its own name" % arm)
+		return []
+	_arms[arm] = true
+	if gathering():
+		return _gathered(arm, runs)
+
+	var by_index: Dictionary[int, Variant] = {}
+	var share: PackedInt32Array = dealt(runs)
+	var every: int = maxi(ceili(share.size() / 10.0), 1)
+	for at: int in range(share.size()):
+		var run: int = share[at]
+		var outcome: Variant = play.call(run)
+		var wrong: String = _not_plain(outcome)
+		if not wrong.is_empty():
+			push_error(
+				(
+					"GdhShare: run %d of %s answered %s, which cannot be handed from one engine to another"
+					% [run, arm, wrong]
+				)
+			)
+		by_index[run] = outcome
+		if working() and ((at + 1) % every == 0 or at + 1 == share.size()):
+			print(PROGRESS % [arm, at + 1, share.size()])
+
+	if working():
+		_leave(arm, runs, by_index)
+		return []
+	var ordered: Array = []
+	for run: int in range(runs):
+		ordered.append(by_index[run])
+	return ordered
+
+
+## [param counted], each a dictionary of whole numbers, added up key by key; a key named in
+## [param largest] keeps the largest instead. Adding and taking the largest come out the same in
+## any order, which is what lets a bench fold its runs however it likes.
+static func added(
+	counted: Array, largest: PackedStringArray = PackedStringArray()
+) -> Dictionary[String, int]:
+	var total: Dictionary[String, int] = {}
+	for outcome: Variant in counted:
+		if not outcome is Dictionary:
+			push_error("GdhShare.added: an outcome is %s, not a dictionary" % type_string(typeof(outcome)))
+			continue
+		var counts: Dictionary = outcome
+		for key: Variant in counts:
+			var named: String = str(key)
+			var count: Variant = counts[key]
+			if not count is int:
+				push_error(
+					"GdhShare.added: %s is %s, not a whole number" % [named, type_string(typeof(count))]
+				)
+				continue
+			var now: int = count
+			if not total.has(named):
+				total[named] = now
+			elif largest.has(named):
+				total[named] = maxi(total[named], now)
+			else:
+				total[named] += now
+	return total
+
+
+## Leaves one arm's outcomes, then the line saying so, which `gdharness spread` checks the share
+## against; the outcomes first, so a line is never there without them.
+static func _leave(arm: String, runs: int, by_index: Dictionary[int, Variant]) -> void:
+	var left: Dictionary = {"arm": arm, "runs": runs, "outcomes": by_index}
+	if not _appended("worker-%d.bin" % _index, func(file: FileAccess) -> bool: return file.store_var(left)):
+		return
+	var said: String = JSON.stringify({"arm": arm, "runs": runs, "played": by_index.size()})
+	var _noted: bool = _appended(
+		"worker-%d.arms" % _index, func(file: FileAccess) -> bool: return file.store_line(said)
+	)
+
+
+## Appends to [param name] in the share directory with [param write], answering whether it did.
+static func _appended(name: String, write: Callable) -> bool:
+	var path: String = _directory.path_join(name)
+	var file: FileAccess = FileAccess.open(
+		path, FileAccess.READ_WRITE if FileAccess.file_exists(path) else FileAccess.WRITE
+	)
+	if file == null:
+		push_error("GdhShare: cannot write %s: %s" % [path, error_string(FileAccess.get_open_error())])
+		return false
+	file.seek_end()
+	var wrote: bool = write.call(file)
+	file.close()
+	if not wrote:
+		push_error("GdhShare: cannot write %s" % path)
+	return wrote
+
+
+static func _gathered(arm: String, runs: int) -> Array:
+	_read_workers()
+	if not _unread.is_empty():
+		push_error(_unread)
+		return []
+	if not _found.has(arm):
+		push_error(
+			(
+				(
+					"GdhShare: no worker played the arm %s, so this run went another way than theirs; "
+					+ "which arms a bench plays must depend on its command line alone"
+				)
+				% arm
+			)
+		)
+		return []
+	if _found_runs[arm] != runs:
+		push_error(
+			(
+				"GdhShare: the workers played %d runs of %s, and this run asks for %d"
+				% [_found_runs[arm], arm, runs]
+			)
+		)
+		return []
+	var held: Dictionary = _found[arm]
+	var ordered: Array = []
+	for run: int in range(runs):
+		if not held.has(run):
+			push_error("GdhShare: no worker played run %d of %s" % [run, arm])
+			return []
+		ordered.append(held[run])
+	var said: String = JSON.stringify({"arm": arm, "runs": runs, "played": runs})
+	var _noted: bool = _appended(
+		"gathered.arms", func(file: FileAccess) -> bool: return file.store_line(said)
+	)
+	return ordered
+
+
+static func _read_workers() -> void:
+	if _read:
+		return
+	_read = true
+	for worker: int in range(_gathering):
+		var path: String = _directory.path_join("worker-%d.bin" % worker)
+		var file: FileAccess = FileAccess.open(path, FileAccess.READ)
+		if file == null:
+			_unread = "GdhShare: cannot read %s: %s" % [path, error_string(FileAccess.get_open_error())]
+			return
+		while file.get_position() < file.get_length():
+			_unread = _took(file.get_var(), path)
+			if not _unread.is_empty():
+				file.close()
+				return
+		file.close()
+
+
+## Adds one arm a worker left to what has been found, answering why it cannot, or empty.
+static func _took(left: Variant, path: String) -> String:
+	if not left is Dictionary:
+		return "GdhShare: %s holds something other than a worker's outcomes" % path
+	var record: Dictionary = left
+	var arm_said: Variant = record.get("arm")
+	var runs_said: Variant = record.get("runs")
+	var outcomes_said: Variant = record.get("outcomes")
+	if not (arm_said is String and runs_said is int and outcomes_said is Dictionary):
+		return "GdhShare: %s holds something other than a worker's outcomes" % path
+	var arm: String = arm_said
+	var runs: int = runs_said
+	var played: Dictionary = outcomes_said
+	if _found_runs.has(arm) and _found_runs[arm] != runs:
+		return (
+			"GdhShare: the workers disagree on how many runs %s has: %d and %d"
+			% [arm, _found_runs[arm], runs]
+		)
+	_found_runs[arm] = runs
+	var held: Dictionary = _found.get_or_add(arm, {})
+	for run: Variant in played:
+		if held.has(run):
+			return "GdhShare: run %s of %s was played by two workers" % [str(run), arm]
+		held[run] = played[run]
+	return ""
+
+
+static func _learn() -> void:
+	if _learnt:
+		return
+	_learnt = true
+	for given: String in OS.get_cmdline_user_args():
+		if given.begins_with(SHARE):
+			var halves: PackedStringArray = given.trim_prefix(SHARE).split("/")
+			if halves.size() == 2 and halves[0].is_valid_int() and halves[1].is_valid_int():
+				_index = halves[0].to_int()
+				_workers = halves[1].to_int()
+			if _index < 0 or _index >= _workers:
+				push_error("GdhShare: %s names no worker; it takes <index>/<workers>" % given)
+				_index = -1
+		elif given.begins_with(GATHER):
+			_gathering = given.trim_prefix(GATHER).to_int()
+		elif given.begins_with(INTO):
+			_directory = given.trim_prefix(INTO)
+	if (_index >= 0 or _gathering > 0) and _directory.is_empty():
+		push_error("GdhShare: a spread engine was given no %s<directory> to share outcomes in" % INTO)
+
+
+## What in [param value] cannot be written by one engine and read by another, or empty.
+static func _not_plain(value: Variant) -> String:
+	match typeof(value):
+		TYPE_OBJECT:
+			return "an object"
+		TYPE_CALLABLE:
+			return "a callable"
+		TYPE_SIGNAL:
+			return "a signal"
+		TYPE_RID:
+			return "a resource id"
+		TYPE_ARRAY:
+			var items: Array = value
+			for item: Variant in items:
+				var wrong: String = _not_plain(item)
+				if not wrong.is_empty():
+					return wrong
+		TYPE_DICTIONARY:
+			var pairs: Dictionary = value
+			for key: Variant in pairs:
+				var wrong: String = _not_plain(key) + _not_plain(pairs[key])
+				if not wrong.is_empty():
+					return wrong
+	return ""

package/build/godot/addons/gdharness_tests/share.gd.uid

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

package/build/godot/addons/gdharness_tests/suites.gd

@@ -0,0 +1,34 @@
+extends Node
+
+## gdUnit4 suites run inside a played scene, which the engine's script profiler sees and a script
+## run with `-s` never does. `editor_run start` given `suites` plays this scene with
+## [constant RUNNER] naming the runner `gdharness test` uses, where the server ships it, followed by
+## that runner's own arguments. The runner is loaded from there rather than kept in this addon,
+## since it extends gdUnit4's classes and a project without gdUnit4 must still compile the addon.
+
+const RUNNER: String = "--gdh-runner"
+
+
+func _ready() -> void:
+	var asked: PackedStringArray = OS.get_cmdline_user_args()
+	var at: int = asked.find(RUNNER)
+	var path: String = asked[at + 1] if at >= 0 and at + 1 < asked.size() else ""
+	var listed: GDScript = null
+	if not path.is_empty() and FileAccess.file_exists(path):
+		listed = load(path) as GDScript
+	if listed == null:
+		push_error(
+			(
+				(
+					"gdharness suites: no runner at '%s'. This scene is played by editor_run start with suites,"
+					+ " which names the runner after %s; it does nothing played any other way."
+				)
+				% [path, RUNNER]
+			)
+		)
+		get_tree().quit(1)
+		return
+	var runner: Node = listed.call("started", asked.slice(at + 2))
+	# The runner holds its own script past the engine's shutdown by this path.
+	runner.set("own_path", path)
+	add_child(runner)

package/build/godot/addons/gdharness_tests/suites.gd.uid

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

package/build/godot/addons/gdharness_tests/suites.tscn

@@ -0,0 +1,6 @@
+[gd_scene format=3 uid="uid://c8vtk4rm1ynho"]
+
+[ext_resource type="Script" uid="uid://bq3n7xkd2wfs0" path="res://addons/gdharness_tests/suites.gd" id="1_suites"]
+
+[node name="GdhSuites" type="Node"]
+script = ExtResource("1_suites")

package/build/godot/addons/gdharness_tests/tweens.gd

@@ -0,0 +1,24 @@
+class_name GdhTweens
+extends RefCounted
+## Moves the tree's animations on by a time the case chooses, rather than waiting for them.
+##
+## A case that waits a real timer of an animation's length races the animation: the tree runs its
+## timers before its tweens, so on a busy machine the timer fires ahead of the last step and the
+## case reads a fade short of its end. Stepping the tweens reads the slide or the fade exactly
+## where the case asks.
+
+## A frame at sixty a second.
+const FRAME: float = 1.0 / 60.0
+
+
+## Steps every tween the tree is processing by [param seconds], as frames that long would.
+static func step(tree: SceneTree, seconds: float) -> void:
+	for running: Tween in tree.get_processed_tweens():
+		var _stepped: bool = running.custom_step(seconds)
+
+
+## [method step] [param seconds] and one frame more, for a case about what an animation leaves once
+## it is over: a step that ends exactly where the last tweener does leaves a callback after it
+## waiting for time it has not been given.
+static func past(tree: SceneTree, seconds: float) -> void:
+	step(tree, seconds + FRAME)

package/build/godot/addons/gdharness_tests/tweens.gd.uid

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

package/build/godot/addons/gdharness_tests/wait.gd

@@ -0,0 +1,53 @@
+class_name GdhWait
+extends RefCounted
+## Waits out what the game is doing by asking every frame whether it is done, never by a timer.
+##
+## A timer of an animation's length and a margin is a race the animation loses on a busy machine:
+## the engine counts a tween's time in the frames' deltas, and a frame that waits on other engines
+## arrives late, so the timer ends with the tween still running. Asking once a frame holds however
+## slowly the frames come. The bound is on the clock only so that something that never ends fails
+## the case by name instead of holding the run until its silence ends it.
+
+## How long [method until] and [method still] wait by default, in milliseconds.
+const MOST_MS: int = 30000
+
+## Frames in a row with no tween running before [method still] counts the tree as still. A layout
+## often starts its slide a frame after the change that asks for it, so the frame straight after
+## had no tween yet and passed for still.
+const QUIET_FRAMES: int = 3
+
+
+## Whether [param done] answered true within [param most_ms], asked now and then once a frame.
+static func until(tree: SceneTree, done: Callable, most_ms: int = MOST_MS) -> bool:
+	var began: int = Time.get_ticks_msec()
+	while not done.call():
+		if Time.get_ticks_msec() - began > most_ms:
+			return false
+		await tree.process_frame
+	return true
+
+
+## Whether the tree ran no tween for [param quiet_frames] frames in a row within [param most_ms].
+static func still(tree: SceneTree, quiet_frames: int = QUIET_FRAMES, most_ms: int = MOST_MS) -> bool:
+	var began: int = Time.get_ticks_msec()
+	var quiet: int = 0
+	while quiet < quiet_frames:
+		if Time.get_ticks_msec() - began > most_ms:
+			return false
+		await tree.process_frame
+		quiet = quiet + 1 if not running(tree) else 0
+	return true
+
+
+## [param count] frames of the tree, waited one at a time.
+static func frames(tree: SceneTree, count: int) -> void:
+	for _frame: int in range(count):
+		await tree.process_frame
+
+
+## Whether any tween under [param tree] is running.
+static func running(tree: SceneTree) -> bool:
+	for tween: Tween in tree.get_processed_tweens():
+		if tween.is_running():
+			return true
+	return false

package/build/godot/addons/gdharness_tests/wait.gd.uid

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

package/build/godot/loader/loader.gd

@@ -0,0 +1,28 @@
+extends Node
+## Brings gdharness's runtime up in a debug build that has its addon, and does nothing anywhere else.
+##
+## `project.godot` names this file rather than the addon's script. `addons/` is often not committed
+## and exports leave it out, so an entry naming the addon boots a fresh clone or an exported build
+## with a missing script. `gdharness setup` writes this file, and `gdharness doctor` says when it is
+## not the one that gdharness ships. The runtime refuses a `-s` script run by itself unless
+## `gdharness/runtime/serve_script_runs` is on, so that is left to it.
+
+## Loaded by path as it runs rather than preloaded: a preload resolves when this script is parsed,
+## and in a build without the addon that is the missing script this file is here to avoid.
+const RUNTIME: String = "res://addons/gdharness_runtime/runtime_autoload.gd"
+
+
+func _ready() -> void:
+	if not OS.is_debug_build() or not ResourceLoader.exists(RUNTIME):
+		return
+	var script: GDScript = load(RUNTIME) as GDScript
+	if script == null:
+		return
+	var made: Object = script.new()
+	var runtime: Node = made as Node
+	if runtime == null:
+		return
+	# Under this node rather than beside it: the root refuses a child while it is still adding the
+	# autoloads, and a deferred add would bring the runtime up only after the main scene's _ready.
+	# Added now, it announces before the main scene runs, as it does when an entry names it.
+	add_child(runtime)

package/build/godot/operations/class_cache.gd

@@ -26,7 +26,7 @@ func refresh_class_cache(_params: Dictionary) -> Dictionary:
 
 	var entries: Array = []
 	var skipped: Array[Dictionary] = []
-	for path: String in _files.find_files("res://", ".gd"):
+	for path: String in _files.find_files("res://", ".gd", true):
 		var entry: Dictionary = _entry_for(path, skipped)
 		if not entry.is_empty():
 			entries.append(entry)

package/build/godot/operations/file_walk.gd

@@ -77,10 +77,13 @@ func is_installed_by_gdharness(path: String) -> bool:
 	return FileAccess.file_exists(path + ".gdharness-version")
 
 
-# Files under `path` whose name ends with `extension`, which is passed with its dot.
-func find_files(path: String, extension: String) -> Array[String]:
+# Files under `path` whose name ends with `extension`, which is passed with its dot. An addon
+# gdharness installed is walked into when [param with_ours] is set, for a caller rebuilding what
+# the engine itself would: the engine lists the global classes of every addon, and a list rebuilt
+# without ours dropped the one class the tests addon declares.
+func find_files(path: String, extension: String, with_ours: bool = false) -> Array[String]:
 	var files: Array[String] = []
-	if is_stepped_over(path) or is_installed_by_gdharness(path):
+	if is_stepped_over(path) or (not with_ours and is_installed_by_gdharness(path)):
 		return files
 
 	var dir: DirAccess = DirAccess.open(path)
@@ -92,7 +95,7 @@ func find_files(path: String, extension: String) -> Array[String]:
 
 		while file_name != "":
 			if dir.current_is_dir() and not file_name.begins_with("."):
-				files.append_array(find_files(path + file_name + "/", extension))
+				files.append_array(find_files(path + file_name + "/", extension, with_ours))
 			elif file_name.ends_with(extension):
 				files.append(path + file_name)
 

package/build/godot/operations/input_actions.gd

@@ -191,7 +191,7 @@ func add_input_action(params: Dictionary) -> Dictionary:
 	# Through ProjectSettings so the file is saved the way the editor saves it, header and
 	# every other line kept; a ConfigFile of project.godot drops the comments on the way out.
 	ProjectSettings.set_setting(setting, action)
-	var err: Error = GdhProjectFile.save()
+	var err: Error = GdhProjectFile.save([setting])
 	if err != OK:
 		return _log.failure("Failed to save project.godot: " + error_string(err))
 
@@ -297,7 +297,7 @@ func remove_input_action(params: Dictionary) -> Dictionary:
 			)
 		)
 	ProjectSettings.set_setting(setting, null)
-	var err: Error = GdhProjectFile.save()
+	var err: Error = GdhProjectFile.save([setting])
 	if err != OK:
 		return _log.failure("Failed to save project.godot: " + error_string(err))
 	return {"action_name": action_name, "removed": true}

package/build/godot/operations/plugins.gd

@@ -172,11 +172,11 @@ static func _names_of(paths: Array[String]) -> Array[String]:
 func _save_enabled_paths(paths: Array[String]) -> Error:
 	if paths.is_empty():
 		ProjectSettings.set_setting("editor_plugins/enabled", null)
-		return GdhProjectFile.save()
+		return GdhProjectFile.save(["editor_plugins/enabled"])
 
 	# Kept in an Array[String] and converted here, because appending to a packed array answers with
 	# whether it worked and a project holding return_value_discarded at error level will not compile
 	# a script that drops that answer. The conversion is what matters: an Array[String] handed to
 	# set_setting is written as Array[String]([...]), which the editor does not read as a plugin list.
 	ProjectSettings.set_setting("editor_plugins/enabled", PackedStringArray(paths))
-	return GdhProjectFile.save()
+	return GdhProjectFile.save(["editor_plugins/enabled"])

package/build/godot/operations/project_config.gd

@@ -47,9 +47,11 @@ func set_project_setting(params: Dictionary) -> Dictionary:
 		old_value = ProjectSettings.get_setting(setting_path)
 	# A setting the engine registers is there with its default whether or not project.godot sets it,
 	# so has_setting alone called the description of a project that had never set one an old value.
-	# At its default, the file does not set it: the engine drops a key at its default when it saves.
+	# Whether it is new is the file's to say: one at its default has a line only where the project
+	# wrote it out on purpose.
 	var default_value: Variant = ProjectSettings.property_get_revert(setting_path)
 	var was_default: bool = had_value and default_value != null and old_value == default_value
+	var in_file: bool = GdhProjectFile.sets(setting_path)
 
 	var wanted: int = _wanted_type(setting_path, old_value if had_value else null)
 	# A value of fields or a colour's html code is fitted as a property write fits it, so a value one
@@ -68,12 +70,18 @@ func set_project_setting(params: Dictionary) -> Dictionary:
 		var number: float = final_value
 		if number == floorf(number) and absf(number) < 9.0e15:
 			final_value = int(number)
+	# A tag that could not be built is still the dictionary it arrived as, and a setting nothing
+	# declares took it as one: the file was given the tag key by key, beside an answer of success.
+	if final_value is Dictionary:
+		var held: Dictionary = final_value
+		if held.has("_type"):
+			return _log.failure(_unbuilt(setting_path, held))
 
 	var answer: Dictionary = {
 		"setting_path": setting_path,
 		"old_value": _values.serialize_value(old_value) if had_value else null,
 		"new_value": _values.serialize_value(final_value),
-		"was_new": not had_value or was_default,
+		"was_new": not in_file,
 		"was_default": was_default,
 		"saved": true,
 	}
@@ -82,7 +90,7 @@ func set_project_setting(params: Dictionary) -> Dictionary:
 	if had_value and typeof(old_value) == typeof(final_value) and old_value == final_value:
 		answer["saved"] = false
 		answer["unchanged"] = true
-		if was_default:
+		if was_default and not in_file:
 			answer["note"] = (
 				(
 					"%s is already this setting's default, which project.godot holds no line for:"
@@ -122,7 +130,7 @@ func set_project_setting(params: Dictionary) -> Dictionary:
 			said += ("; project_import reimport makes the translation files from " + ", ".join(made))
 		answer["note"] = (str(answer["note"]) + " " if answer.has("note") else "") + said + "."
 	ProjectSettings.set_setting(setting_path, final_value)
-	var err: Error = GdhProjectFile.save()
+	var err: Error = GdhProjectFile.save([setting_path])
 	if err != OK:
 		return _log.failure("Failed to save project.godot: " + error_string(err))
 	return answer
@@ -180,8 +188,9 @@ func unset_project_setting(params: Dictionary) -> Dictionary:
 		"setting_path": setting_path,
 		"default_value": _values.serialize_value(default_value) if default_value != null else null,
 	}
-	# A setting at the engine's default has no line to take out, as the engine leaves it out of the file.
-	if not held or (default_value != null and value == default_value):
+	# Read off the file rather than the value: a setting at its default usually has no line, as the
+	# engine leaves it out, but a project can hold one written out on purpose.
+	if not held or not GdhProjectFile.sets(setting_path):
 		answer["removed"] = false
 		answer["saved"] = false
 		answer["note"] = "project.godot does not set %s, so there was nothing to take out." % setting_path
@@ -190,7 +199,7 @@ func unset_project_setting(params: Dictionary) -> Dictionary:
 	# The default rather than null for a setting the engine declares: null takes the declaration away
 	# as well, and a value at its default is left out of the file all the same.
 	ProjectSettings.set_setting(setting_path, default_value)
-	var err: Error = GdhProjectFile.save()
+	var err: Error = GdhProjectFile.save([setting_path])
 	if err != OK:
 		return _log.failure("Failed to save project.godot: " + error_string(err))
 	answer["removed"] = true
@@ -266,6 +275,24 @@ static func _cannot_hold(setting_path: String, wanted: int, value: Variant) -> S
 	return "%s, and %s (%s) cannot become one.%s" % [declared, JSON.stringify(value), given, remedy]
 
 
+## Why [param tagged], a value whose tag could not be built, was not written to [param setting_path],
+## and how a value of that tag is written.
+static func _unbuilt(setting_path: String, tagged: Dictionary) -> String:
+	var tag: String = str(tagged["_type"])
+	var refused: String = (
+		"The value for %s is tagged %s and could not be read as one, so nothing was written."
+		% [setting_path, JSON.stringify(tag)]
+	)
+	var shapes: Array = GdhShapes.REQUIRED.get(tag, [])
+	if shapes.is_empty():
+		return refused + " A setting cannot hold a %s written as a tag." % tag
+	var keys: Array = shapes[0]
+	var parts: Array[String] = ['"_type": "%s"' % tag]
+	for key: Variant in keys:
+		parts.append('"%s": %s' % [key, "[...]" if tag.begins_with("Packed") and key == "value" else "..."])
+	return refused + " One is written as {%s}." % ", ".join(parts)
+
+
 # Add an autoload singleton
 func add_autoload(params: Dictionary) -> Dictionary:
 	var name: String = str(params.get("name", ""))
@@ -313,7 +340,7 @@ func add_autoload(params: Dictionary) -> Dictionary:
 			"saved": false
 		}
 	ProjectSettings.set_setting(setting, entry)
-	var err: Error = GdhProjectFile.save()
+	var err: Error = GdhProjectFile.save([setting])
 	if err != OK:
 		return _log.failure("Failed to save project.godot: " + error_string(err))
 
@@ -339,7 +366,7 @@ func remove_autoload(params: Dictionary) -> Dictionary:
 
 	var old_value: String = str(ProjectSettings.get_setting(setting))
 	ProjectSettings.set_setting(setting, null)
-	var err: Error = GdhProjectFile.save()
+	var err: Error = GdhProjectFile.save([setting])
 	if err != OK:
 		return _log.failure("Failed to save project.godot: " + error_string(err))
 
@@ -401,7 +428,7 @@ func set_main_scene(params: Dictionary) -> Dictionary:
 	var old_main_scene: String = str(ProjectSettings.get_setting("application/run/main_scene", ""))
 
 	ProjectSettings.set_setting("application/run/main_scene", scene_path)
-	var err: Error = GdhProjectFile.save()
+	var err: Error = GdhProjectFile.save(["application/run/main_scene"])
 
 	if err != OK:
 		return _log.failure("Failed to save project settings: " + str(err))