gdharness 0.12.16 → 0.12.18

package/build/cli.js

@@ -7467,6 +7467,13 @@ function addonMismatch(addonVersion, serverVersion) {
   }
   return `${both} Restart it with editor_launch restart to pick the new one up.`;
 }
+function markIfStale(answer, addonVersion, serverVersion) {
+  const staleNote = addonMismatch(addonVersion, serverVersion);
+  if (staleNote === undefined || typeof answer !== "object" || answer === null || Array.isArray(answer)) {
+    return answer;
+  }
+  return { ...answer, addonIsStale: true, staleNote };
+}
 var DEBUG_MODE, GODOT_DEBUG_MODE_DEFAULT, SERVER_VERSION, UNVERSIONED = "addon from before versions were reported";
 var init_server_version = __esm(() => {
   init_update_check();
@@ -38328,7 +38335,7 @@ class GodotServer {
       ]);
     }
     try {
-      return this.jsonTextResponse(await this.godotBridge.invokeTool(toolName, args));
+      return this.jsonTextResponse(markIfStale(await this.godotBridge.invokeTool(toolName, args), this.godotBridge.getStatus().addonVersion, SERVER_VERSION));
     } catch (error) {
       return this.createErrorResponse(`The editor answered ${toolName} with an error: ${errorMessage(error)}`);
     }
@@ -39911,7 +39918,9 @@ that is running, and the project on disk. ${TOOL_SPECS.length} tools, named \`do
   running games. There is no ambient project.
 - \`editor_status\` says whether an editor is connected and whether its addon matches the server.
   \`addonIsStale\` means they differ, and \`staleNote\` says which half is behind: an editor that
-  needs restarting, or a server that needs reconnecting in your harness.
+  needs restarting, or a server that needs reconnecting in your harness. Every answer that came
+  from the editor carries the same two when they differ, so a stale addon cannot answer quietly:
+  believe a restart over a diagnostic that arrived with them.
 - Start the game with \`editor_run start\`, never by spawning an engine. The editor plays it, so
   its debugger holds it, which is what gives the \`debug_*\` tools something to talk to. Its answer
   says under \`runtime\` whether the game can be talked to yet; when it cannot, \`mayYetAnnounce\`

package/build/godot/addons/auto_reload/auto_reload.gd

@@ -16,7 +16,12 @@ var _watched_files: Dictionary = {}
 func _enter_tree() -> void:
 	_timer = Timer.new()
 	_timer.wait_time = CHECK_INTERVAL_SECONDS
-	_timer.timeout.connect(_check_for_changes)
+	# int rather than Error: Signal.connect answers with a plain int, where Object.connect answers
+	# with the enum, and a project holding int_as_enum_without_cast at error level refuses the
+	# assignment that conflates them.
+	var watching: int = _timer.timeout.connect(_check_for_changes)
+	if watching != OK:
+		push_error("gdharness: could not start watching for changes on disk")
 	add_child(_timer)
 	_timer.start()
 	_update_watched_files()
@@ -79,7 +84,9 @@ func _check_for_changes() -> void:
 
 func _reload_script(path: String) -> void:
 	print("[gdharness] Script changed on disk, reloading: ", path)
-	ResourceLoader.load(path, "", ResourceLoader.CACHE_MODE_REPLACE)
+	var reloaded: Resource = ResourceLoader.load(path, "", ResourceLoader.CACHE_MODE_REPLACE)
+	if reloaded == null:
+		push_error("gdharness: could not reload " + path + " from disk")
 
 
 func _reload_scene(path: String) -> void:

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

@@ -8,6 +8,8 @@ signal connected
 signal disconnected
 signal tool_requested(request_id: String, tool_name: String, args: Dictionary)
 
+const Read = preload("reading.gd")
+
 const DEFAULT_URL: String = "ws://127.0.0.1:6505/godot"
 ## Written beside the addon by the install, so it names the version this copy came from.
 const VERSION_MARKER: String = "res://addons/gdharness_editor/.gdharness-version"
@@ -88,7 +90,9 @@ func _ready() -> void:
 
 	_reconnect_timer = Timer.new()
 	_reconnect_timer.one_shot = true
-	_reconnect_timer.timeout.connect(_on_reconnect_timer)
+	var waiting: int = _reconnect_timer.timeout.connect(_on_reconnect_timer)
+	if waiting != OK:
+		push_error("gdharness: could not arm the reconnect timer")
 	add_child(_reconnect_timer)
 
 	set_process(true)
@@ -227,9 +231,9 @@ func announced_url() -> String:
 		return ""
 
 	var announcement: Dictionary = said
-	if int(announcement.get("protocol", 0)) != ANNOUNCE_PROTOCOL:
+	if Read.as_int(announcement.get("protocol", 0)) != ANNOUNCE_PROTOCOL:
 		return ""
-	var port: int = int(announcement.get("port", 0))
+	var port: int = Read.as_int(announcement.get("port", 0))
 	if port < 1 or port > 65535:
 		return ""
 	var host: String = str(announcement.get("host", "127.0.0.1"))
@@ -332,7 +336,7 @@ func _serving(setting: String) -> int:
 	var settings: EditorSettings = EditorInterface.get_editor_settings()
 	if settings == null or not settings.has_setting(setting):
 		return 0
-	return int(settings.get_setting(setting))
+	return Read.as_int(settings.get_setting(setting))
 
 
 ## The version marker beside this addon, or "" when the copy was not installed by gdharness.
@@ -434,7 +438,9 @@ func send_tool_result(request_id: String, success: bool, result: Variant = null,
 
 func _send_message(message: Dictionary) -> void:
 	if socket.get_ready_state() == WebSocketPeer.STATE_OPEN:
-		socket.send_text(JSON.stringify(message))
+		var sent: Error = socket.send_text(JSON.stringify(message))
+		if sent != OK:
+			push_error("gdharness: could not send to the server: " + error_string(sent))
 
 
 func is_connected_to_server() -> bool:

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

@@ -23,9 +23,9 @@ func _enter_tree() -> void:
 	add_child(_tool_executor)
 	_tool_executor.set_editor_plugin(self)
 
-	_client.connected.connect(_on_connected)
-	_client.disconnected.connect(_on_disconnected)
-	_client.tool_requested.connect(_on_tool_requested)
+	_listen(_client.connected, _on_connected)
+	_listen(_client.disconnected, _on_disconnected)
+	_listen(_client.tool_requested, _on_tool_requested)
 
 	_setup_status_indicator()
 	_client.connect_to_server()
@@ -53,6 +53,18 @@ func _exit_tree() -> void:
 		_status_label = null
 
 
+# A failed connect is a mistake in this plugin rather than anything the editor did, so it goes to
+# the error stream instead of being dropped: a project holding return_value_discarded at error level
+# refuses to compile a script that throws the answer away.
+func _listen(source: Signal, handler: Callable) -> void:
+	# int rather than Error: Signal.connect answers with a plain int, where Object.connect answers
+	# with the enum, and a project holding int_as_enum_without_cast at error level refuses the
+	# assignment that conflates them.
+	var joined: int = source.connect(handler)
+	if joined != OK:
+		push_error("gdharness: could not listen to " + source.get_name())
+
+
 func _setup_status_indicator() -> void:
 	_status_label = Label.new()
 	_status_label.text = "gdharness: connecting"
@@ -82,7 +94,8 @@ func _on_tool_requested(request_id: String, tool_name: String, args: Dictionary)
 
 	if success:
 		var payload: Dictionary = result.duplicate(true)
-		payload.erase("ok")
+		if not payload.erase("ok"):
+			push_error("gdharness: a tool answered ok without an ok field to remove")
 		_client.send_tool_result(request_id, true, payload, "")
 	else:
 		_client.send_tool_result(request_id, false, null, str(result.get("error", "Unknown error")))

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

@@ -0,0 +1,64 @@
+extends RefCounted
+
+# A value out of a request that arrived as JSON, as the type the caller wants.
+#
+# `int(value)`, `float(value)` and `bool(value)` take a Variant, and a project holding
+# `unsafe_call_argument` at error level will not compile a script that hands one over. The
+# conversion is the same; what changes is that the type is established first, on a typed local, and
+# the conversion happens from that.
+#
+# A copy rather than a preload of the one beside the operations, because an addon is installed as a
+# directory and has to hold everything it uses. Reaching into the runtime addon instead would tie an
+# editor tool to a directory that ships inside exported games.
+#
+# `fallback` answers a value that is there and is null, which is a caller sending JSON null where a
+# number was expected. Absent keys never reach here: the callers pass their own default to
+# `Dictionary.get`, so what arrives is that default.
+
+
+static func as_int(value: Variant, fallback: int = 0) -> int:
+	if value is int:
+		var already: int = value
+		return already
+	if value is float:
+		var real: float = value
+		return int(real)
+	if value is bool:
+		var flag: bool = value
+		return 1 if flag else 0
+	if value is String:
+		var text: String = value
+		return text.to_int()
+	return fallback
+
+
+static func as_float(value: Variant, fallback: float = 0.0) -> float:
+	if value is float:
+		var already: float = value
+		return already
+	if value is int:
+		var whole: int = value
+		return float(whole)
+	if value is bool:
+		var flag: bool = value
+		return 1.0 if flag else 0.0
+	if value is String:
+		var text: String = value
+		return text.to_float()
+	return fallback
+
+
+static func as_bool(value: Variant, fallback: bool = false) -> bool:
+	if value is bool:
+		var already: bool = value
+		return already
+	if value is int:
+		var whole: int = value
+		return whole != 0
+	if value is float:
+		var real: float = value
+		return not is_zero_approx(real)
+	if value is String:
+		var text: String = value
+		return not text.is_empty()
+	return fallback

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

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

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

@@ -3,6 +3,8 @@ extends Node
 
 ## Animations and animation trees, edited in the open editor.
 
+const Read = preload("../reading.gd")
+
 var _editor_plugin: EditorPlugin = null
 
 
@@ -75,12 +77,19 @@ func _parse_value(value: Variant) -> Variant:
 			var t: Variant = fields.get("type", fields.get("_type", ""))
 			match t:
 				"Vector2":
-					return Vector2(fields.get("x", 0), fields.get("y", 0))
+					return Vector2(Read.as_float(fields.get("x", 0)), Read.as_float(fields.get("y", 0)))
 				"Vector3":
-					return Vector3(fields.get("x", 0), fields.get("y", 0), fields.get("z", 0))
+					return Vector3(
+						Read.as_float(fields.get("x", 0)),
+						Read.as_float(fields.get("y", 0)),
+						Read.as_float(fields.get("z", 0))
+					)
 				"Color":
 					return Color(
-						fields.get("r", 1), fields.get("g", 1), fields.get("b", 1), fields.get("a", 1)
+						Read.as_float(fields.get("r", 1), 1.0),
+						Read.as_float(fields.get("g", 1), 1.0),
+						Read.as_float(fields.get("b", 1), 1.0),
+						Read.as_float(fields.get("a", 1), 1.0)
 					)
 	if typeof(value) == TYPE_ARRAY:
 		var result: Array = []
@@ -93,8 +102,9 @@ func _parse_value(value: Variant) -> Variant:
 func _parse_json_maybe(value: Variant) -> Variant:
 	if typeof(value) != TYPE_STRING:
 		return value
-	var parsed: Variant = JSON.parse_string(value)
-	if parsed == null and value != "null":
+	var text: String = value
+	var parsed: Variant = JSON.parse_string(text)
+	if parsed == null and text != "null":
 		return value
 	return parsed
 
@@ -183,9 +193,9 @@ func create_animation(args: Dictionary) -> Dictionary:
 			loop_mode = Animation.LOOP_NONE
 
 	var anim: Animation = Animation.new()
-	anim.length = float(args.get("length", 1.0))
+	anim.length = Read.as_float(args.get("length", 1.0), 1.0)
 	anim.loop_mode = loop_mode
-	anim.step = float(args.get("step", 0.1))
+	anim.step = Read.as_float(args.get("step", 0.1), 0.1)
 
 	var add_err: Error = anim_lib.add_animation(StringName(animation_name), anim)
 	if add_err != OK:
@@ -262,7 +272,11 @@ func add_animation_track(args: Dictionary) -> Dictionary:
 				var parsed_value: Variant = (
 					_parse_json_maybe(raw_value) if typeof(raw_value) == TYPE_STRING else raw_value
 				)
-				anim.track_insert_key(track_idx, float(keyframe.get("time", 0.0)), _parse_value(parsed_value))
+				var placed: int = anim.track_insert_key(
+					track_idx, Read.as_float(keyframe.get("time", 0.0)), _parse_value(parsed_value)
+				)
+				if placed < 0:
+					push_error("gdharness: could not key " + prop_name + " on " + node_path_str)
 
 		"method":
 			var method_node_path: String = str(track.get("nodePath", ""))
@@ -276,10 +290,14 @@ func add_animation_track(args: Dictionary) -> Dictionary:
 				if typeof(entry) != TYPE_DICTIONARY:
 					continue
 				var keyframe: Dictionary = entry
-				var invocation: Dictionary = {
-					"method": method_name, "args": _parse_method_args(keyframe.get("args", []))
-				}
-				anim.track_insert_key(track_idx, float(keyframe.get("time", 0.0)), invocation)
+				var given: Variant = keyframe.get("args", [])
+				var arguments: Array = given if given is Array else []
+				var invocation: Dictionary = {"method": method_name, "args": _parse_method_args(arguments)}
+				var placed: int = anim.track_insert_key(
+					track_idx, Read.as_float(keyframe.get("time", 0.0)), invocation
+				)
+				if placed < 0:
+					push_error("gdharness: could not key " + method_name + " on " + method_node_path)
 
 		_:
 			scene_root.queue_free()

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

@@ -34,7 +34,7 @@ func global_classes(_args: Dictionary) -> Dictionary:
 		return {"ok": false, "error": "Editor plugin unavailable"}
 
 	var filesystem: EditorFileSystem = EditorInterface.get_resource_filesystem()
-	var names: PackedStringArray = []
+	var names: Array[String] = []
 	_walk(filesystem.get_filesystem(), names)
 	names.sort()
 	return {
@@ -45,7 +45,10 @@ func global_classes(_args: Dictionary) -> Dictionary:
 	}
 
 
-func _walk(directory: EditorFileSystemDirectory, into: PackedStringArray) -> void:
+# Array[String] rather than PackedStringArray: appending to a packed array answers with whether it
+# worked, and a project holding return_value_discarded at error level refuses a script that drops
+# that answer. Both reach the caller as the same list of strings.
+func _walk(directory: EditorFileSystemDirectory, into: Array[String]) -> void:
 	if directory == null:
 		return
 	for index: int in range(directory.get_file_count()):

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

@@ -9,6 +9,8 @@ extends Node
 ## tools answer at all.
 
 ## What the display server calls itself when the engine was started with no display at all.
+const Read = preload("../reading.gd")
+
 const HEADLESS_DISPLAY: String = "headless"
 ## Where Godot keeps the port its own debugger listens on for a game it is playing. One setting
 ## for every editor on the machine, and bound only while a game runs.
@@ -158,7 +160,7 @@ func playing_status(_args: Dictionary) -> Dictionary:
 	# play, so the one from when this editor greeted the server is a number it has moved off.
 	var settings: EditorSettings = EditorInterface.get_editor_settings()
 	var debugger: int = (
-		int(settings.get_setting(DEBUGGER_SETTING))
+		Read.as_int(settings.get_setting(DEBUGGER_SETTING))
 		if settings != null and settings.has_setting(DEBUGGER_SETTING)
 		else 0
 	)

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

@@ -3,6 +3,8 @@ extends Node
 
 ## Resource files, shaders, tilesets and themes, written through the open editor.
 
+const Read = preload("../reading.gd")
+
 # Shader templates. Written as real multi-line source rather than escaped one-liners so that
 # what ends up in the .gdshader can be read here. The %s is the shader type.
 const SHADER_EMPTY: String = """shader_type %s;
@@ -75,26 +77,37 @@ func _parse_value(value: Variant) -> Variant:
 			var t: Variant = fields.get("type", fields.get("_type", ""))
 			match t:
 				"Vector2":
-					return Vector2(fields.get("x", 0), fields.get("y", 0))
+					return Vector2(Read.as_float(fields.get("x", 0)), Read.as_float(fields.get("y", 0)))
 				"Vector3":
-					return Vector3(fields.get("x", 0), fields.get("y", 0), fields.get("z", 0))
+					return Vector3(
+						Read.as_float(fields.get("x", 0)),
+						Read.as_float(fields.get("y", 0)),
+						Read.as_float(fields.get("z", 0))
+					)
 				"Color":
 					return Color(
-						fields.get("r", 1), fields.get("g", 1), fields.get("b", 1), fields.get("a", 1)
+						Read.as_float(fields.get("r", 1), 1.0),
+						Read.as_float(fields.get("g", 1), 1.0),
+						Read.as_float(fields.get("b", 1), 1.0),
+						Read.as_float(fields.get("a", 1), 1.0)
 					)
 				"Vector2i":
-					return Vector2i(fields.get("x", 0), fields.get("y", 0))
+					return Vector2i(Read.as_int(fields.get("x", 0)), Read.as_int(fields.get("y", 0)))
 				"Vector3i":
-					return Vector3i(fields.get("x", 0), fields.get("y", 0), fields.get("z", 0))
+					return Vector3i(
+						Read.as_int(fields.get("x", 0)),
+						Read.as_int(fields.get("y", 0)),
+						Read.as_int(fields.get("z", 0))
+					)
 				"Rect2":
 					return Rect2(
-						fields.get("x", 0),
-						fields.get("y", 0),
-						fields.get("width", 0),
-						fields.get("height", 0)
+						Read.as_float(fields.get("x", 0)),
+						Read.as_float(fields.get("y", 0)),
+						Read.as_float(fields.get("width", 0)),
+						Read.as_float(fields.get("height", 0))
 					)
 				"NodePath":
-					return NodePath(fields.get("path", ""))
+					return NodePath(str(fields.get("path", "")))
 	if typeof(value) == TYPE_ARRAY:
 		var result: Array = []
 		for item: Variant in value:
@@ -106,16 +119,17 @@ func _parse_value(value: Variant) -> Variant:
 func _set_resource_properties(resource: Resource, properties: Variant) -> void:
 	var props: Dictionary = _parse_properties_dict(properties)
 	for key: Variant in props:
-		var val: Variant = _parse_value(props[key])
-		resource.set(key, val)
+		var named: String = str(key)
+		resource.set(named, _parse_value(props[key]))
 
 
 func _parse_properties_dict(raw: Variant) -> Dictionary:
 	if typeof(raw) == TYPE_DICTIONARY:
 		return raw
 	if typeof(raw) == TYPE_STRING and raw != "":
+		var text: String = raw
 		var json: JSON = JSON.new()
-		if json.parse(raw) == OK and typeof(json.data) == TYPE_DICTIONARY:
+		if json.parse(text) == OK and typeof(json.data) == TYPE_DICTIONARY:
 			return json.data
 	return {}
 
@@ -212,8 +226,10 @@ func create_shader(args: Dictionary) -> Dictionary:
 	var file: FileAccess = FileAccess.open(shader_path, FileAccess.WRITE)
 	if file == null:
 		return {"ok": false, "error": "Failed to open shader file for writing", "shaderPath": shader_path}
-	file.store_string(code)
+	var written: bool = file.store_string(code)
 	file.close()
+	if not written:
+		return {"ok": false, "error": "Failed to write the shader file", "shaderPath": shader_path}
 
 	_refresh_filesystem()
 	return {"ok": true, "shaderPath": shader_path, "shaderType": shader_type}
@@ -241,17 +257,21 @@ func create_tileset(args: Dictionary) -> Dictionary:
 		atlas.texture = tex
 
 		var tile_size: Dictionary = source.get("tileSize", {})
-		atlas.texture_region_size = Vector2i(int(tile_size.get("x", 0)), int(tile_size.get("y", 0)))
+		atlas.texture_region_size = Vector2i(
+			Read.as_int(tile_size.get("x", 0)), Read.as_int(tile_size.get("y", 0))
+		)
 
 		if source.has("separation"):
 			var sep: Dictionary = source.get("separation", {})
-			atlas.separation = Vector2i(int(sep.get("x", 0)), int(sep.get("y", 0)))
+			atlas.separation = Vector2i(Read.as_int(sep.get("x", 0)), Read.as_int(sep.get("y", 0)))
 
 		if source.has("offset"):
 			var off: Dictionary = source.get("offset", {})
-			atlas.margins = Vector2i(int(off.get("x", 0)), int(off.get("y", 0)))
+			atlas.margins = Vector2i(Read.as_int(off.get("x", 0)), Read.as_int(off.get("y", 0)))
 
-		tileset.add_source(atlas)
+		var added: int = tileset.add_source(atlas)
+		if added < 0:
+			return {"ok": false, "error": "Failed to add a tile source", "texture": tex_path}
 
 	var save_result: Error = ResourceSaver.save(tileset, tileset_path)
 	if save_result != OK:
@@ -262,8 +282,8 @@ func create_tileset(args: Dictionary) -> Dictionary:
 
 
 ## The source ids a tile set holds, for saying what a cell could have named instead.
-func _source_ids(tile_set: TileSet) -> PackedInt32Array:
-	var ids: PackedInt32Array = PackedInt32Array()
+func _source_ids(tile_set: TileSet) -> Array[int]:
+	var ids: Array[int] = []
 	for index: int in tile_set.get_source_count():
 		ids.append(tile_set.get_source_id(index))
 	return ids
@@ -293,7 +313,7 @@ func set_tilemap_cells(args: Dictionary) -> Dictionary:
 		root.queue_free()
 		return {"ok": false, "error": "TileMap node not found", "tilemapNodePath": node_path}
 
-	var layer: int = int(args.get("layer", 0))
+	var layer: int = Read.as_int(args.get("layer", 0))
 	var cells: Variant = args.get("cells", [])
 	# Refused rather than skipped: placing nothing and answering success is indistinguishable
 	# from placing everything, and the caller only finds out by opening the scene.
@@ -322,7 +342,7 @@ func set_tilemap_cells(args: Dictionary) -> Dictionary:
 				"ok": false, "error": "every cell must be an object with coords, sourceId and atlasCoords"
 			}
 		var cell: Dictionary = entry
-		var source_id: int = int(cell.get("sourceId", -1))
+		var source_id: int = Read.as_int(cell.get("sourceId", -1), -1)
 		if not tile_set.has_source(source_id):
 			root.queue_free()
 			return {
@@ -332,13 +352,13 @@ func set_tilemap_cells(args: Dictionary) -> Dictionary:
 
 		var coords: Dictionary = cell.get("coords", {})
 		var atlas_coords: Dictionary = cell.get("atlasCoords", {})
-		var at: Vector2i = Vector2i(int(coords.get("x", 0)), int(coords.get("y", 0)))
+		var at: Vector2i = Vector2i(Read.as_int(coords.get("x", 0)), Read.as_int(coords.get("y", 0)))
 		tilemap.set_cell(
 			layer,
 			at,
 			source_id,
-			Vector2i(int(atlas_coords.get("x", 0)), int(atlas_coords.get("y", 0))),
-			int(cell.get("alternativeTile", 0))
+			Vector2i(Read.as_int(atlas_coords.get("x", 0)), Read.as_int(atlas_coords.get("y", 0))),
+			Read.as_int(cell.get("alternativeTile", 0))
 		)
 		if tilemap.get_cell_source_id(layer, at) != -1:
 			written += 1
@@ -368,7 +388,10 @@ func set_theme_color(args: Dictionary) -> Dictionary:
 
 	var c: Dictionary = args.get("color", {})
 	var color: Color = Color(
-		float(c.get("r", 1.0)), float(c.get("g", 1.0)), float(c.get("b", 1.0)), float(c.get("a", 1.0))
+		Read.as_float(c.get("r", 1.0), 1.0),
+		Read.as_float(c.get("g", 1.0), 1.0),
+		Read.as_float(c.get("b", 1.0), 1.0),
+		Read.as_float(c.get("a", 1.0), 1.0)
 	)
 	theme.set_color(color_name, control_type, color)
 
@@ -406,7 +429,7 @@ func set_theme_font_size(args: Dictionary) -> Dictionary:
 	if theme == null:
 		return {"ok": false, "error": "No Theme at %s. Create one there first." % theme_path}
 
-	theme.set_font_size(font_size_name, control_type, int(args.get("size", 0)))
+	theme.set_font_size(font_size_name, control_type, Read.as_int(args.get("size", 0)))
 
 	var save_result: Error = ResourceSaver.save(theme, theme_path)
 	if save_result != OK: