gdharness 1.2.25 → 1.2.27

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

@@ -0,0 +1,294 @@
+extends RefCounted
+
+## What the running game tells a screen reader: its accessibility tree, as UI Automation reads it.
+##
+## The engine builds the tree only when something asks for it, and nothing on gdharness's desktop
+## does, so a game's NOTIFICATION_ACCESSIBILITY_UPDATE never came and what its controls expose could
+## not be checked. The engine offers no way to read the tree back, so the question is put the way a
+## screen reader puts it: a UI Automation client started by the game lands on the game's own desktop,
+## its first question makes the engine build the tree, and what it reads is what a screen reader is
+## told, names left empty included.
+
+const Read = preload("reading.gd")
+
+## How long the client keeps walking the tree for it to settle: the engine answers the first question
+## with its windows alone and fills them in over the next frames.
+const SETTLE_MS: int = 8000
+## How long a window with nothing in it is walked before the client stops: a game building its tree
+## fills the window within a few frames of being asked, and one building none never does.
+const EMPTY_MS: int = 4000
+## How long the client may take beyond that, starting PowerShell and loading UI Automation included,
+## before it is stopped and the call answers that it did not finish.
+const START_MS: int = 15000
+## Deep enough for any interface a game builds, and inside the hundred levels ConvertTo-Json stops
+## at, which are two to a level of the tree.
+const MOST_LEVELS: int = 40
+
+## The client, as PowerShell, with $Handles, $Out, $SettleMs, $EmptyMs and $MostLevels set before it. Each
+## element answers what UI Automation names its role, its name, its value where it has one, its
+## bounds in the window's pixels, and the actions a screen reader is offered on it.
+const WALK: String = r"""
+$ErrorActionPreference = 'Stop'
+function Answer($value) {
+  [System.IO.File]::WriteAllText($Out, (ConvertTo-Json -InputObject $value -Depth 100 -Compress))
+}
+try {
+  Add-Type -AssemblyName UIAutomationClient, UIAutomationTypes
+  $walker = [System.Windows.Automation.TreeWalker]::RawViewWalker
+  function Patterned($element, $name) {
+    $pattern = ("System.Windows.Automation.$($name)Pattern" -as [type])::Pattern
+    $found = $null
+    if ($element.TryGetCurrentPattern($pattern, [ref]$found)) { return $found }
+    return $null
+  }
+  function Describe($element, $ox, $oy, $depth) {
+    $c = $element.Current
+    $role = $c.ControlType.ProgrammaticName -replace '^ControlType[.]', ''
+    $role = ($role -creplace '(?<=[a-z])(?=[A-Z])', '_').ToLowerInvariant()
+    $node = [ordered]@{ role = $role; name = $c.Name }
+    if ($c.HelpText) { $node.description = $c.HelpText }
+    $r = $c.BoundingRectangle
+    if (-not $r.IsEmpty) {
+      $node.bounds = [ordered]@{ x = [int]($r.X - $ox); y = [int]($r.Y - $oy) }
+      $node.bounds.width = [int]$r.Width
+      $node.bounds.height = [int]$r.Height
+    }
+    $actions = @()
+    if (Patterned $element 'Invoke') { $actions += 'click' }
+    $p = Patterned $element 'Toggle'
+    if ($p) { $actions += 'toggle'; $node.toggled = "$($p.Current.ToggleState)".ToLowerInvariant() }
+    $p = Patterned $element 'ExpandCollapse'
+    if ($p) {
+      $actions += 'expand_collapse'
+      $node.expanded = "$($p.Current.ExpandCollapseState)".ToLowerInvariant()
+    }
+    $p = Patterned $element 'SelectionItem'
+    if ($p) { $actions += 'select'; $node.selected = $p.Current.IsSelected }
+    $p = Patterned $element 'Value'
+    if ($p) {
+      $node.value = $p.Current.Value
+      if (-not $p.Current.IsReadOnly) { $actions += 'set_value' }
+    }
+    $p = Patterned $element 'RangeValue'
+    if ($p) {
+      $node.value = $p.Current.Value
+      $node.range = @($p.Current.Minimum, $p.Current.Maximum)
+      if (-not $p.Current.IsReadOnly) { $actions += 'set_value' }
+    }
+    if (Patterned $element 'ScrollItem') { $actions += 'scroll_into_view' }
+    if ($c.IsKeyboardFocusable) { $actions += 'focus' }
+    $node.actions = $actions
+    if ($c.HasKeyboardFocus) { $node.focused = $true }
+    if (-not $c.IsEnabled) { $node.disabled = $true }
+    if ($c.IsOffscreen) { $node.offscreen = $true }
+    $children = @()
+    if ($depth -lt $MostLevels) {
+      $child = $walker.GetFirstChild($element)
+      while ($null -ne $child) {
+        $children += , (Describe $child $ox $oy ($depth + 1))
+        $child = $walker.GetNextSibling($child)
+      }
+    }
+    $node.children = $children
+    return $node
+  }
+  function Count($node) {
+    $n = 1
+    foreach ($child in $node.children) { $n += Count $child }
+    return $n
+  }
+  $windows = @()
+  foreach ($handle in $Handles) {
+    $root = [System.Windows.Automation.AutomationElement]::FromHandle([IntPtr][long]$handle)
+    $deadline = [DateTime]::UtcNow.AddMilliseconds($SettleMs)
+    $empty = [DateTime]::UtcNow.AddMilliseconds($EmptyMs)
+    # The window's corner is read on every walk: before the engine builds its tree the window is
+    # its frame, and after it the client area inside it, so a corner read once placed everything
+    # by the frame's.
+    $r = $root.Current.BoundingRectangle
+    $tree = Describe $root $r.X $r.Y 0
+    $last = Count $tree
+    # Walked again until two walks in a row agree, since the first question is what makes the
+    # engine build the tree, which arrives over the frames after it.
+    while ([DateTime]::UtcNow -lt $deadline) {
+      Start-Sleep -Milliseconds 150
+      $r = $root.Current.BoundingRectangle
+      $tree = Describe $root $r.X $r.Y 0
+      $count = Count $tree
+      if ($count -gt 1 -and $count -eq $last) { break }
+      if ($count -eq 1 -and [DateTime]::UtcNow -gt $empty) { break }
+      $last = $count
+    }
+    $windows += , $tree
+  }
+  Answer @{ windows = $windows }
+} catch {
+  Answer @{ error = "$_" }
+}
+"""
+
+var _host: Node
+
+
+func _init(host: Node) -> void:
+	_host = host
+
+
+## The game's windows as a screen reader is told them, each a tree of elements.
+func get_accessibility(_params: Dictionary) -> Dictionary:
+	if DisplayServer.get_name() == "headless":
+		return _refused(
+			(
+				"A headless run has no window, so a screen reader is told nothing: start the run with"
+				+ " headless: false."
+			)
+		)
+	if OS.get_name() != "Windows":
+		return _refused(
+			(
+				(
+					"The tree is read through UI Automation, the interface a Windows screen reader uses, and this"
+					+ " game runs on %s, whose screen readers ask it through another"
+				)
+				% OS.get_name()
+			)
+		)
+	var handles: Array[String] = []
+	var ids: Array[int] = []
+	for id: int in DisplayServer.get_window_list():
+		var handle: int = DisplayServer.window_get_native_handle(DisplayServer.WINDOW_HANDLE, id)
+		if handle != 0:
+			handles.append(str(handle))
+			ids.append(id)
+
+	var out: String = OS.get_temp_dir().path_join(
+		"gdharness-accessibility-%d-%d.json" % [OS.get_process_id(), Time.get_ticks_usec()]
+	)
+	var script: String = (
+		(
+			"$Handles = @(%s)\n$Out = '%s'\n$SettleMs = %d\n$EmptyMs = %d\n$MostLevels = %d\n"
+			% [", ".join(handles), out.replace("'", "''"), SETTLE_MS, EMPTY_MS, MOST_LEVELS]
+		)
+		+ WALK
+	)
+	# The system's own PowerShell by its path, so a powershell.exe earlier on PATH is not what runs.
+	var shell: String = OS.get_environment("SystemRoot").path_join(
+		"System32/WindowsPowerShell/v1.0/powershell.exe"
+	)
+	var pid: int = (
+		OS
+		. create_process(
+			shell,
+			[
+				"-NoProfile",
+				"-NonInteractive",
+				"-EncodedCommand",
+				Marshalls.raw_to_base64(script.to_utf16_buffer()),
+			]
+		)
+	)
+	if pid <= 0:
+		return _refused("PowerShell could not be started from %s to read the tree" % shell)
+	# Waited out a frame at a time rather than blocking: the client's questions are answered on the
+	# game's main thread, which a blocking wait would hold, and neither side would move.
+	var deadline: int = Time.get_ticks_msec() + SETTLE_MS + START_MS
+	while OS.is_process_running(pid):
+		if Time.get_ticks_msec() > deadline:
+			var _killed: Error = OS.kill(pid)
+			return _refused(
+				"UI Automation had not read the tree after %d ms, so it was stopped" % (SETTLE_MS + START_MS)
+			)
+		await _host.get_tree().process_frame
+
+	var text: String = FileAccess.get_file_as_string(out)
+	# Not checked: a file that is not there was never written, which the answer below says.
+	var _removed: Error = DirAccess.remove_absolute(out)
+	var read: Variant = Read.json_or_null(text)
+	if not read is Dictionary:
+		return _refused("UI Automation answered nothing readable: %s" % text.left(500))
+	var answer: Dictionary = read
+	if answer.has("error"):
+		return _refused("UI Automation could not read the game's windows: %s" % str(answer["error"]))
+
+	var windows: Array = answer.get("windows", [])
+	var elements: int = 0
+	var unnamed: int = 0
+	for at: int in windows.size():
+		var window: Dictionary = windows[at]
+		window["window_id"] = ids[at] if at < ids.size() else -1
+		elements += _count(window)
+		unnamed += _unnamed_text(window)
+	var result: Dictionary = {"windows": windows, "elements": elements}
+	if elements <= windows.size():
+		var setting: String = _setting()
+		# The command line's --accessibility is consumed by the engine and not handed on, so only
+		# the setting and a screen reader can say the tree is built; otherwise an empty window is
+		# most likely a game that builds none.
+		# 1 is a screen reader running, 0 none and -1 a platform that cannot say.
+		var read_aloud: bool = setting == "auto" and DisplayServer.accessibility_screen_reader_active() == 1
+		if setting != "always" and not read_aloud:
+			return _refused(
+				(
+					(
+						"UI Automation found nothing in the game's windows: the engine builds the tree a screen"
+						+ " reader reads only with accessibility/general/accessibility_support at Always Active,"
+						+ " or at Auto with a screen reader running when it starts, and this project's is %s."
+						+ ' Start the run with engineArgs ["--accessibility", "always"].'
+					)
+					% setting
+				)
+			)
+		result["_note"] = (
+			"The windows hold nothing a screen reader is told: Controls are in the tree, and Node2D and"
+			+ " Node3D are not unless the game creates elements for them."
+		)
+	elif unnamed > 0:
+		# Seen on a game naming its lines with accessibility_update_set_name: the text was there in
+		# the game and empty to the screen reader.
+		result["_note"] = (
+			(
+				"%d text element(s) on screen have no name, so a screen reader reads them as nothing. Static"
+				+ " text is read from its value, DisplayServer.accessibility_update_set_value, and a name"
+				+ " set on it is not read."
+			)
+			% unnamed
+		)
+	return result
+
+
+## The project's accessibility mode, as the command line's --accessibility names them.
+static func _setting() -> String:
+	match Read.as_int(ProjectSettings.get_setting("accessibility/general/accessibility_support", 0), 0):
+		1:
+			return "always"
+		2:
+			return "disabled"
+	return "auto"
+
+
+static func _count(element: Dictionary) -> int:
+	var total: int = 1
+	var children: Array = element.get("children", [])
+	for child: Variant in children:
+		if child is Dictionary:
+			var inner: Dictionary = child
+			total += _count(inner)
+	return total
+
+
+## Text elements with bounds and no name. A window also holds a nameless text element with no bounds
+## that no node of the game made, in every scene tried, which is left out.
+static func _unnamed_text(element: Dictionary) -> int:
+	var total: int = 0
+	if element.get("role") == "text" and str(element.get("name", "")).is_empty() and element.has("bounds"):
+		total += 1
+	var children: Array = element.get("children", [])
+	for child: Variant in children:
+		if child is Dictionary:
+			var inner: Dictionary = child
+			total += _unnamed_text(inner)
+	return total
+
+
+static func _refused(message: String) -> Dictionary:
+	return {"type": "error", "message": message}

package/build/godot/addons/gdharness_runtime/runtime_accessibility.gd.uid

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

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

@@ -10,10 +10,12 @@ extends Node
 ## wanted. Both directions of the socket carry one JSON object per line. Every request names an
 ## id and the reply carries it back.
 
+const Accessibility = preload("runtime_accessibility.gd")
 const Capture = preload("runtime_capture.gd")
 const Changes = preload("runtime_changes.gd")
 const ErrorReport = preload("error_report.gd")
 const InputCommands = preload("runtime_input.gd")
+const Pad = preload("runtime_pad.gd")
 const Queries = preload("runtime_queries.gd")
 const Read = preload("reading.gd")
 const Typing = preload("runtime_typing.gd")
@@ -85,8 +87,10 @@ var _queries: Queries = Queries.new(self, values)
 var _changes: Changes = Changes.new(self, values)
 var _input: InputCommands = InputCommands.new(self, values)
 var _typing: Typing = Typing.new(self)
+var _pad: Pad = Pad.new(self)
 var _capture: Capture = Capture.new(self, values)
 var _waits: Waits = Waits.new(self, values)
+var _accessibility: Accessibility = Accessibility.new(self)
 
 var _server: TCPServer
 var _clients: Array[StreamPeerTCP] = []
@@ -128,6 +132,7 @@ func _init() -> void:
 		"set_property": _changes.set_property,
 		"call_method": _changes.call_method,
 		"get_metrics": _queries.get_metrics,
+		"get_accessibility": _accessibility.get_accessibility,
 		"capture_screenshot": _capture.capture_screenshot,
 		"capture_viewport": _capture.capture_viewport,
 		"inject_action": _input.inject_action,
@@ -135,6 +140,8 @@ func _init() -> void:
 		"inject_text": _typing.inject_text,
 		"inject_mouse_click": _input.inject_mouse_click,
 		"inject_mouse_motion": _input.inject_mouse_motion,
+		"inject_joypad_button": _pad.inject_joypad_button,
+		"inject_joypad_motion": _pad.inject_joypad_motion,
 		"click": _input.click,
 		"choose": _typing.choose,
 		"wait_frames": _waits.wait_frames,

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

@@ -0,0 +1,150 @@
+extends RefCounted
+
+## What reaches the running game the way a controller reaches it: a button pressed and a stick or
+## trigger moved, as the events a pad sends.
+##
+## The events themselves rather than the actions bound to them: a game reading the pad in _input or
+## _unhandled_input looks for InputEventJoypadButton and InputEventJoypadMotion, and an action
+## reached it as an InputEventAction it never reads, so a controller layout could only be driven by
+## calling the game's own methods. The engine still fires the actions bound to a button from these.
+
+const Read = preload("reading.gd")
+
+## Controller buttons by the names Godot gives them, for a caller naming one rather than numbering it.
+const JOY_BUTTONS: Dictionary[String, int] = {
+	"a": JOY_BUTTON_A,
+	"b": JOY_BUTTON_B,
+	"x": JOY_BUTTON_X,
+	"y": JOY_BUTTON_Y,
+	"back": JOY_BUTTON_BACK,
+	"guide": JOY_BUTTON_GUIDE,
+	"start": JOY_BUTTON_START,
+	"left_stick": JOY_BUTTON_LEFT_STICK,
+	"right_stick": JOY_BUTTON_RIGHT_STICK,
+	"left_shoulder": JOY_BUTTON_LEFT_SHOULDER,
+	"right_shoulder": JOY_BUTTON_RIGHT_SHOULDER,
+	"dpad_up": JOY_BUTTON_DPAD_UP,
+	"dpad_down": JOY_BUTTON_DPAD_DOWN,
+	"dpad_left": JOY_BUTTON_DPAD_LEFT,
+	"dpad_right": JOY_BUTTON_DPAD_RIGHT,
+	"misc1": JOY_BUTTON_MISC1,
+	"paddle1": JOY_BUTTON_PADDLE1,
+	"paddle2": JOY_BUTTON_PADDLE2,
+	"paddle3": JOY_BUTTON_PADDLE3,
+	"paddle4": JOY_BUTTON_PADDLE4,
+	"touchpad": JOY_BUTTON_TOUCHPAD,
+}
+
+## Stick and trigger axes by the names Godot gives them.
+const JOY_AXES: Dictionary[String, int] = {
+	"left_x": JOY_AXIS_LEFT_X,
+	"left_y": JOY_AXIS_LEFT_Y,
+	"right_x": JOY_AXIS_RIGHT_X,
+	"right_y": JOY_AXIS_RIGHT_Y,
+	"trigger_left": JOY_AXIS_TRIGGER_LEFT,
+	"trigger_right": JOY_AXIS_TRIGGER_RIGHT,
+}
+
+var _host: Node
+
+
+func _init(host: Node) -> void:
+	_host = host
+
+
+## Presses a controller button, and lets go of it again unless asked to hold it, as a key press does:
+## a button left down is a press that never ends, and everything reading it goes on seeing it.
+func inject_joypad_button(params: Dictionary) -> Dictionary:
+	var given: Variant = params.get("button", null)
+	var button: int = _named_or_numbered(given, JOY_BUTTONS, JOY_BUTTON_MAX)
+	if button < 0:
+		return {"type": "error", "message": _not_one_of("button", given, JOY_BUTTONS, JOY_BUTTON_MAX)}
+	var device: int = Read.as_int(params.get("device", 0), 0)
+	var held: bool = Read.as_bool(params.get("pressed", true), true)
+	var whole: bool = not params.has("pressed")
+
+	Input.parse_input_event(_button(button, device, whole or held))
+	if whole:
+		# A frame between the halves, as a key has, so a game that acts on the press and one that
+		# acts on the release each get a frame to do it in.
+		await _host.get_tree().process_frame
+		Input.parse_input_event(_button(button, device, false))
+		await _host.get_tree().process_frame
+
+	return {
+		"type": "input_injected",
+		"input_type": "joypad_button",
+		"button": button,
+		"button_name": _name_of(button, JOY_BUTTONS),
+		"device": device,
+		"pressed": held and not whole,
+		"whole": whole,
+	}
+
+
+## Moves a stick or trigger axis to a value, where it stays until another motion moves it, as a
+## stick held over does.
+func inject_joypad_motion(params: Dictionary) -> Dictionary:
+	var given: Variant = params.get("axis", null)
+	var axis: int = _named_or_numbered(given, JOY_AXES, JOY_AXIS_MAX)
+	if axis < 0:
+		return {"type": "error", "message": _not_one_of("axis", given, JOY_AXES, JOY_AXIS_MAX)}
+	if not params.has("value"):
+		return {"type": "error", "message": "joypad_motion needs value, where the axis is, -1 to 1"}
+	var value: float = Read.as_float(params.get("value"), 0.0)
+	if value < -1.0 or value > 1.0:
+		return {
+			"type": "error", "message": "value %s is outside -1 to 1, the whole travel of an axis" % value
+		}
+	var device: int = Read.as_int(params.get("device", 0), 0)
+
+	var event: InputEventJoypadMotion = InputEventJoypadMotion.new()
+	event.axis = axis as JoyAxis
+	event.axis_value = value
+	event.device = device
+	Input.parse_input_event(event)
+
+	return {
+		"type": "input_injected",
+		"input_type": "joypad_motion",
+		"axis": axis,
+		"axis_name": _name_of(axis, JOY_AXES),
+		"value": value,
+		"device": device,
+	}
+
+
+static func _button(button: int, device: int, down: bool) -> InputEventJoypadButton:
+	var event: InputEventJoypadButton = InputEventJoypadButton.new()
+	event.button_index = button as JoyButton
+	event.pressed = down
+	event.device = device
+	return event
+
+
+## [param given] as one of [param names], or as a number below [param count], or -1 for neither.
+static func _named_or_numbered(given: Variant, names: Dictionary[String, int], count: int) -> int:
+	if given is String:
+		var named: String = given
+		return Read.as_int(names.get(named.strip_edges().to_lower(), -1), -1)
+	if given is int or given is float:
+		var number: int = Read.as_int(given, -1)
+		return number if number >= 0 and number < count else -1
+	return -1
+
+
+static func _not_one_of(
+	argument: String, given: Variant, names: Dictionary[String, int], count: int
+) -> String:
+	return (
+		"%s %s is not one: give its name, one of %s, or its number, 0 to %d"
+		% [argument, JSON.stringify(given), ", ".join(PackedStringArray(names.keys())), count - 1]
+	)
+
+
+## The name [param number] goes by in [param names], or empty for a number with none.
+static func _name_of(number: int, names: Dictionary[String, int]) -> String:
+	for named: String in names:
+		if names[named] == number:
+			return named
+	return ""

package/build/godot/addons/gdharness_runtime/runtime_pad.gd.uid

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

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

@@ -718,6 +718,11 @@ func get_metrics(params: Dictionary) -> Dictionary:
 		"render_total_objects": Performance.get_monitor(Performance.RENDER_TOTAL_OBJECTS_IN_FRAME),
 		"render_total_primitives": Performance.get_monitor(Performance.RENDER_TOTAL_PRIMITIVES_IN_FRAME),
 		"render_total_draw_calls": Performance.get_monitor(Performance.RENDER_TOTAL_DRAW_CALLS_IN_FRAME),
+		# The GPU's half of the game's memory, in bytes, which memory_static does not count: a game
+		# committing 2.3 GB answered 298 MB there, and the rest could not be asked about.
+		"render_video_mem_used": Performance.get_monitor(Performance.RENDER_VIDEO_MEM_USED),
+		"render_texture_mem_used": Performance.get_monitor(Performance.RENDER_TEXTURE_MEM_USED),
+		"render_buffer_mem_used": Performance.get_monitor(Performance.RENDER_BUFFER_MEM_USED),
 	}
 
 	if metrics.is_empty():

package/build/godot/operations/import_pipeline.gd

@@ -46,6 +46,9 @@ const IMPORTER_VERSIONS: Dictionary[String, int] = {"scene": 1, "animation_libra
 ## The VRAM compression formats a project can ask for, each behind its
 ## `rendering/textures/vram_compression/import_<format>` setting.
 const VRAM_FORMATS: Array[String] = ["s3tc_bptc", "etc2_astc"]
+## Options keyed by OpenType tags, by the importer that holds them. The engine keys them by the tag as
+## an int, which a caller can also name, as "liga" for ligatures.
+const OPENTYPE_OPTIONS: Dictionary[String, Array] = {"font_data_dynamic": ["opentype_features"]}
 const EDITOR_DIRECTORY: String = "res://.godot/editor"
 const EDITOR_CACHE_PREFIX: String = "filesystem_cache"
 
@@ -177,6 +180,7 @@ func set_import_options(params: Dictionary) -> Dictionary:
 		return _log.failure("Failed to parse import file: " + str(err))
 
 	# Every option checked before any is written, so a refused one leaves the sidecar as it was.
+	var importer: String = str(config.get_value("remap", "importer", ""))
 	var fitted_values: Dictionary = {}
 	var refused: Array[String] = []
 	for key: Variant in options:
@@ -184,6 +188,13 @@ func set_import_options(params: Dictionary) -> Dictionary:
 		var held: Variant = config.get_value("params", name, null)
 		var given: Variant = _values.deserialize_value(options[key])
 		var value: Variant = _as_option(_values.fitted(options[key], typeof(held)), held)
+		if value is Dictionary:
+			var entries: Dictionary = value
+			var keyed: Dictionary = _keyed_as_option(name, entries, held, importer)
+			if keyed.has("refused"):
+				refused.append(str(keyed["refused"]))
+				continue
+			value = keyed["value"]
 		# A number the option cannot hold whole is refused rather than truncated: 2.5 fitted to an
 		# enum option became 2, which is another setting.
 		var lossy: bool = (
@@ -227,6 +238,87 @@ static func _as_option(given: Variant, held: Variant) -> Variant:
 	return given
 
 
+## [param given] with the keys and values a dictionary option holds as ints made ints again.
+##
+## JSON names every key as a string and every number as a float, so a font's opentype_features was
+## written as {"1818847073": 0.0}. The importer hands that to FontFile.opentype_feature_overrides,
+## which keys features by their tag as an int, so the call reported success and the font kept its
+## ligatures. A key is an int where the importer keys the option by OpenType tags, or where every key
+## the option holds already is one; a value is an int where every value held is, or for a tag.
+## Answers the dictionary under value, or why it cannot be written under refused.
+static func _keyed_as_option(name: String, given: Dictionary, held: Variant, importer: String) -> Dictionary:
+	var tag_options: Array = OPENTYPE_OPTIONS.get(importer, [])
+	var tagged: bool = name in tag_options
+	var numbered_keys: bool = tagged or _all_ints(held, true)
+	var whole_values: bool = tagged or _all_ints(held, false)
+	if not numbered_keys and not whole_values:
+		return {"value": given}
+	var keyed: Dictionary = {}
+	for key: Variant in given:
+		var as_key: Variant = key
+		if numbered_keys:
+			as_key = _int_key(key, tagged)
+			if as_key == null:
+				var wanted: String = (
+					'OpenType tags, by name such as "liga" or as the number TextServer.name_to_tag gives'
+					if tagged
+					else "ints"
+				)
+				return {
+					"refused": "%s is keyed by %s, and %s is not one" % [name, wanted, JSON.stringify(key)]
+				}
+		var value: Variant = given[key]
+		if whole_values and value is float:
+			var number: float = value
+			if number == floorf(number):
+				value = int(number)
+		keyed[as_key] = value
+	return {"value": keyed}
+
+
+## [param key] as an int key, or null when it is not one: a whole number, written as a number or as
+## a string of digits, or where [param tagged], an OpenType tag's four characters.
+static func _int_key(key: Variant, tagged: bool) -> Variant:
+	if key is int:
+		return key
+	if key is float:
+		var number: float = key
+		if number != floorf(number):
+			return null
+		return int(number)
+	if not key is String:
+		return null
+	var text: String = key
+	if text.is_valid_int():
+		return text.to_int()
+	# Exactly four printable characters, since the engine reads a longer name by its first four and
+	# "ligatures" would quietly become "liga".
+	if tagged and text.length() == 4 and _printable(text):
+		return TextServerManager.get_primary_interface().name_to_tag(text)
+	return null
+
+
+static func _printable(text: String) -> bool:
+	for i: int in text.length():
+		var code: int = text.unicode_at(i)
+		if code < 0x20 or code > 0x7e:
+			return false
+	return true
+
+
+## Whether [param held] is a dictionary that is not empty and whose keys, or values, are all ints.
+static func _all_ints(held: Variant, keys: bool) -> bool:
+	if not held is Dictionary:
+		return false
+	var dictionary: Dictionary = held
+	if dictionary.is_empty():
+		return false
+	for item: Variant in dictionary.keys() if keys else dictionary.values():
+		if not item is int:
+			return false
+	return true
+
+
 # The names of the project's export presets, in the order export_presets.cfg holds them.
 static func _preset_names() -> Array[String]:
 	var names: Array[String] = []

package/build/godot/operations/input_actions.gd

@@ -2,6 +2,7 @@ extends RefCounted
 
 const Read = preload("reading.gd")
 const Log = preload("logger.gd")
+const ProjectFile = preload("project_file.gd")
 
 # The key names a caller may write, and what the engine calls them.
 const KEY_NAMES: Dictionary = {
@@ -172,7 +173,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("input/" + action_name, action)
-	var err: Error = ProjectSettings.save()
+	var err: Error = ProjectFile.save()
 	if err != OK:
 		return _log.failure("Failed to save project.godot: " + error_string(err))
 
@@ -205,7 +206,7 @@ func remove_input_action(params: Dictionary) -> Dictionary:
 			)
 		)
 	ProjectSettings.set_setting(setting, null)
-	var err: Error = ProjectSettings.save()
+	var err: Error = ProjectFile.save()
 	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

@@ -2,6 +2,7 @@ extends RefCounted
 
 const Patterns = preload("patterns.gd")
 const Log = preload("logger.gd")
+const ProjectFile = preload("project_file.gd")
 
 var _log: Log
 
@@ -171,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 ProjectSettings.save()
+		return ProjectFile.save()
 
 	# 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 ProjectSettings.save()
+	return ProjectFile.save()