breakpoint-mcp 1.0.0 → 1.1.0

package/dist/tools/editor/spatial.js

@@ -0,0 +1,185 @@
+import { z } from "zod";
+import { gate } from "../../confirm.js";
+/** 3D & navigation. meshinstance/mesh/light/camera/csg/navregion/navagent mutate the EDITED scene and are undoable + ungated (the node_* model). primitive_mesh_create and the two environment_* tools author a resource on disk, so are file-writers gated by confirmation. */
+export function registerSpatialTools(server, call) {
+    server.registerTool("meshinstance_create", {
+        title: "Create MeshInstance3D",
+        description: "Add a MeshInstance3D under a parent (undoable). Optional 'mesh_path' loads a Mesh resource (e.g. a primitive_mesh_create output) and assigns it. Returns the new node's path.",
+        inputSchema: {
+            parent_path: z.string().describe("Parent node path relative to the scene root; \".\" for the root"),
+            name: z.string().optional().describe("Node name (default MeshInstance3D)"),
+            mesh_path: z.string().optional().describe("Mesh resource res:// path to assign to the instance's 'mesh'"),
+        },
+    }, async ({ parent_path, name, mesh_path }) => {
+        const params = { parent_path };
+        if (name !== undefined)
+            params.name = name;
+        if (mesh_path !== undefined)
+            params.mesh_path = mesh_path;
+        return call("meshinstance.create", params);
+    });
+    server.registerTool("mesh_set_surface_material", {
+        title: "Set mesh surface material",
+        description: "Assign a Material (res:// path) to a MeshInstance3D (undoable). Default surface -1 sets 'material_override' (whole instance); a surface index >= 0 sets that surface's override material (must be within the mesh's surface count). Refuses a non-MeshInstance3D node or a non-Material resource.",
+        inputSchema: {
+            path: z.string().describe("MeshInstance3D node path relative to the scene root"),
+            material_path: z.string().describe("Material resource res:// path (StandardMaterial3D / ShaderMaterial / …)"),
+            surface: z.number().int().optional().describe("Surface index, or -1 (default) for material_override"),
+        },
+    }, async ({ path, material_path, surface }) => {
+        const params = { path, material_path };
+        if (surface !== undefined)
+            params.surface = surface;
+        return call("mesh.set_surface_material", params);
+    });
+    server.registerTool("primitive_mesh_create", {
+        title: "Create primitive mesh",
+        description: "Create a PrimitiveMesh resource (box/sphere/cylinder/plane/capsule/prism/torus/quad) and save it to a res:// path. DESTRUCTIVE (writes a file) — gated by confirmation. Assign it with meshinstance_create's 'mesh_path'.",
+        inputSchema: {
+            to_path: z.string().describe("Destination res:// path, e.g. res://meshes/box.tres"),
+            shape: z.string().optional().describe("box | sphere | cylinder | plane | capsule | prism | torus | quad (default box)"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ to_path, shape, confirm }) => {
+        const blocked = await gate(server, confirm, `Create ${shape ?? "box"} PrimitiveMesh at ${to_path}`);
+        if (blocked)
+            return blocked;
+        const params = { to_path };
+        if (shape !== undefined)
+            params.shape = shape;
+        return call("primitive_mesh.create", params);
+    });
+    server.registerTool("light_create", {
+        title: "Create Light3D",
+        description: "Add a 3D light under a parent (undoable). 'kind' selects DirectionalLight3D (dir), OmniLight3D (omni), or SpotLight3D (spot). Returns the new node's path.",
+        inputSchema: {
+            parent_path: z.string().describe("Parent node path relative to the scene root; \".\" for the root"),
+            kind: z.enum(["dir", "directional", "omni", "spot"]).optional().describe("Light kind: dir | omni | spot (default omni)"),
+            name: z.string().optional().describe("Node name (defaults to the class name)"),
+        },
+    }, async ({ parent_path, kind, name }) => {
+        const params = { parent_path };
+        if (kind !== undefined)
+            params.kind = kind;
+        if (name !== undefined)
+            params.name = name;
+        return call("light.create", params);
+    });
+    server.registerTool("camera_create", {
+        title: "Create Camera3D",
+        description: "Add a Camera3D under a parent (undoable). Optional 'current' makes it the active camera. Returns the new node's path.",
+        inputSchema: {
+            parent_path: z.string().describe("Parent node path relative to the scene root; \".\" for the root"),
+            name: z.string().optional().describe("Node name (default Camera3D)"),
+            current: z.boolean().optional().describe("Make this the current/active camera (default false)"),
+        },
+    }, async ({ parent_path, name, current }) => {
+        const params = { parent_path };
+        if (name !== undefined)
+            params.name = name;
+        if (current !== undefined)
+            params.current = current;
+        return call("camera.create", params);
+    });
+    server.registerTool("csg_create", {
+        title: "Create CSG node",
+        description: "Add a CSG node under a parent (undoable). 'shape' selects CSGBox3D (box), CSGSphere3D (sphere), CSGCylinder3D (cylinder), CSGTorus3D (torus), CSGPolygon3D (polygon), CSGMesh3D (mesh), or CSGCombiner3D (combiner). Returns the new node's path.",
+        inputSchema: {
+            parent_path: z.string().describe("Parent node path relative to the scene root; \".\" for the root"),
+            shape: z.string().optional().describe("box | sphere | cylinder | torus | polygon | mesh | combiner (default box)"),
+            name: z.string().optional().describe("Node name (defaults to the class name)"),
+        },
+    }, async ({ parent_path, shape, name }) => {
+        const params = { parent_path };
+        if (shape !== undefined)
+            params.shape = shape;
+        if (name !== undefined)
+            params.name = name;
+        return call("csg.create", params);
+    });
+    server.registerTool("navregion_create", {
+        title: "Create NavigationRegion3D",
+        description: "Add a NavigationRegion3D under a parent (undoable). By default seeds a fresh empty NavigationMesh (set with_navmesh=false to skip). Returns the new node's path and whether a navmesh was attached.",
+        inputSchema: {
+            parent_path: z.string().describe("Parent node path relative to the scene root; \".\" for the root"),
+            name: z.string().optional().describe("Node name (default NavigationRegion3D)"),
+            with_navmesh: z.boolean().optional().describe("Seed a fresh empty NavigationMesh resource (default true)"),
+        },
+    }, async ({ parent_path, name, with_navmesh }) => {
+        const params = { parent_path };
+        if (name !== undefined)
+            params.name = name;
+        if (with_navmesh !== undefined)
+            params.with_navmesh = with_navmesh;
+        return call("navregion.create", params);
+    });
+    server.registerTool("navagent_configure", {
+        title: "Add & configure NavigationAgent3D",
+        description: "Add a NavigationAgent3D under a parent (undoable) and set any of its steering/avoidance properties. Returns the new node's path and the resulting config (radius, height, max_speed, path/target desired distances, avoidance_enabled).",
+        inputSchema: {
+            parent_path: z.string().describe("Parent node path relative to the scene root; \".\" for the root"),
+            name: z.string().optional().describe("Node name (default NavigationAgent3D)"),
+            radius: z.number().optional().describe("Agent radius"),
+            height: z.number().optional().describe("Agent height"),
+            max_speed: z.number().optional().describe("Maximum movement speed"),
+            path_desired_distance: z.number().optional().describe("Distance to a path point before advancing"),
+            target_desired_distance: z.number().optional().describe("Distance to the target that counts as arrived"),
+            avoidance_enabled: z.boolean().optional().describe("Enable RVO avoidance"),
+        },
+    }, async ({ parent_path, name, radius, height, max_speed, path_desired_distance, target_desired_distance, avoidance_enabled }) => {
+        const params = { parent_path };
+        if (name !== undefined)
+            params.name = name;
+        if (radius !== undefined)
+            params.radius = radius;
+        if (height !== undefined)
+            params.height = height;
+        if (max_speed !== undefined)
+            params.max_speed = max_speed;
+        if (path_desired_distance !== undefined)
+            params.path_desired_distance = path_desired_distance;
+        if (target_desired_distance !== undefined)
+            params.target_desired_distance = target_desired_distance;
+        if (avoidance_enabled !== undefined)
+            params.avoidance_enabled = avoidance_enabled;
+        return call("navagent.configure", params);
+    });
+    server.registerTool("environment_create", {
+        title: "Create Environment",
+        description: "Create an Environment resource and save it to a res:// path. 'background' sets the mode (clear_color/color/sky/canvas, default clear_color); optional 'ambient_color' ([r,g,b(,a)], 0..1) sets the ambient light color. DESTRUCTIVE (writes a file) — gated by confirmation.",
+        inputSchema: {
+            to_path: z.string().describe("Destination res:// path, e.g. res://world.tres"),
+            background: z.string().optional().describe("clear_color | color | sky | canvas (default clear_color)"),
+            ambient_color: z.array(z.number()).optional().describe("Ambient light color [r,g,b] or [r,g,b,a], 0..1"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ to_path, background, ambient_color, confirm }) => {
+        const blocked = await gate(server, confirm, `Create Environment at ${to_path}`);
+        if (blocked)
+            return blocked;
+        const params = { to_path };
+        if (background !== undefined)
+            params.background = background;
+        if (ambient_color !== undefined)
+            params.ambient_color = ambient_color;
+        return call("environment.create", params);
+    });
+    server.registerTool("environment_set_sky", {
+        title: "Set Environment sky",
+        description: "Attach a Sky to an existing Environment resource file (setting a ProceduralSkyMaterial, PhysicalSkyMaterial, or PanoramaSkyMaterial) and switch its background to SKY, then re-save. DESTRUCTIVE (writes a file) — gated by confirmation. Refuses a path that is not an Environment.",
+        inputSchema: {
+            path: z.string().describe("Environment res:// path"),
+            sky_material: z.enum(["procedural", "physical", "panorama"]).optional().describe("Sky material kind (default procedural)"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ path, sky_material, confirm }) => {
+        const blocked = await gate(server, confirm, `Set sky on Environment ${path}`);
+        if (blocked)
+            return blocked;
+        const params = { path };
+        if (sky_material !== undefined)
+            params.sky_material = sky_material;
+        return call("environment.set_sky", params);
+    });
+}
+//# sourceMappingURL=spatial.js.map

package/dist/tools/editor/tiles.js

@@ -0,0 +1,160 @@
+import { z } from "zod";
+import { gate } from "../../confirm.js";
+/** TileSet authoring (disk-backed, gated) + TileMapLayer cell painting. */
+export function registerTileTools(server, call) {
+    server.registerTool("tileset_create", {
+        title: "Create TileSet",
+        description: "Instantiate a TileSet resource and save it as a new .tres file. DESTRUCTIVE (writes a file) — gated by confirmation. tile_size is the base grid cell size in pixels (default 16×16).",
+        inputSchema: {
+            to_path: z.string().describe("Destination res:// path, e.g. res://tiles/world.tres"),
+            tile_size: z.array(z.number().int()).optional().describe("Base tile grid size [x, y] in pixels (default [16, 16])"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ to_path, tile_size, confirm }) => {
+        const blocked = await gate(server, confirm, `Create TileSet resource at ${to_path}`);
+        if (blocked)
+            return blocked;
+        return call("tileset.create", tile_size !== undefined ? { to_path, tile_size } : { to_path });
+    });
+    server.registerTool("tileset_add_source", {
+        title: "Add TileSet atlas source",
+        description: "Add a TileSetAtlasSource (backed by a Texture2D) to a TileSet .tres and re-save. DESTRUCTIVE (writes a file) — gated by confirmation. texture_region_size defaults to the TileSet's tile_size; source_id -1 auto-assigns.",
+        inputSchema: {
+            tileset_path: z.string().describe("TileSet res:// .tres path"),
+            texture_path: z.string().describe("Texture2D res:// path used as the atlas image"),
+            texture_region_size: z.array(z.number().int()).optional().describe("Atlas cell size [x, y] in pixels (default = tile_size)"),
+            source_id: z.number().int().optional().describe("Explicit source id, or -1 to auto-assign (default -1)"),
+            margins: z.array(z.number().int()).optional().describe("Atlas margins [x, y] in pixels"),
+            separation: z.array(z.number().int()).optional().describe("Atlas separation [x, y] in pixels"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ tileset_path, texture_path, texture_region_size, source_id, margins, separation, confirm }) => {
+        const blocked = await gate(server, confirm, `Add atlas source (${texture_path}) to TileSet ${tileset_path}`);
+        if (blocked)
+            return blocked;
+        const params = { tileset_path, texture_path };
+        if (texture_region_size !== undefined)
+            params.texture_region_size = texture_region_size;
+        if (source_id !== undefined)
+            params.source_id = source_id;
+        if (margins !== undefined)
+            params.margins = margins;
+        if (separation !== undefined)
+            params.separation = separation;
+        return call("tileset.add_source", params);
+    });
+    server.registerTool("tileset_add_tile", {
+        title: "Add TileSet tile",
+        description: "Create a tile at atlas_coords in an atlas source of a TileSet .tres and re-save. DESTRUCTIVE (writes a file) — gated by confirmation. size is measured in atlas cells (default [1, 1]).",
+        inputSchema: {
+            tileset_path: z.string().describe("TileSet res:// .tres path"),
+            source_id: z.number().int().describe("Atlas source id within the TileSet"),
+            atlas_coords: z.array(z.number().int()).describe("Tile atlas coordinates [x, y] (in cells)"),
+            size: z.array(z.number().int()).optional().describe("Tile size in atlas cells [x, y] (default [1, 1])"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ tileset_path, source_id, atlas_coords, size, confirm }) => {
+        const blocked = await gate(server, confirm, `Add tile ${JSON.stringify(atlas_coords)} to source ${source_id} in ${tileset_path}`);
+        if (blocked)
+            return blocked;
+        const params = { tileset_path, source_id, atlas_coords };
+        if (size !== undefined)
+            params.size = size;
+        return call("tileset.add_tile", params);
+    });
+    server.registerTool("tileset_set_tile_collision", {
+        title: "Set tile collision polygon",
+        description: "Add a collision polygon to a tile on a TileSet physics layer and re-save. DESTRUCTIVE (writes a file) — gated by confirmation. Physics layers are created as needed. polygon is an array of [x, y] points (>= 3), tile-local pixels.",
+        inputSchema: {
+            tileset_path: z.string().describe("TileSet res:// .tres path"),
+            source_id: z.number().int().describe("Atlas source id within the TileSet"),
+            atlas_coords: z.array(z.number().int()).describe("Tile atlas coordinates [x, y] (in cells)"),
+            polygon: z.array(z.array(z.number())).describe("Collision polygon points [[x, y], ...] (>= 3), tile-local pixels"),
+            physics_layer: z.number().int().optional().describe("TileSet physics layer index (default 0; created if missing)"),
+            one_way: z.boolean().optional().describe("Mark the polygon as one-way collision"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ tileset_path, source_id, atlas_coords, polygon, physics_layer, one_way, confirm }) => {
+        const blocked = await gate(server, confirm, `Set collision on tile ${JSON.stringify(atlas_coords)} in ${tileset_path}`);
+        if (blocked)
+            return blocked;
+        const params = { tileset_path, source_id, atlas_coords, polygon };
+        if (physics_layer !== undefined)
+            params.physics_layer = physics_layer;
+        if (one_way !== undefined)
+            params.one_way = one_way;
+        return call("tileset.set_tile_collision", params);
+    });
+    server.registerTool("tilemaplayer_create", {
+        title: "Create TileMapLayer",
+        description: "Add a TileMapLayer node under a parent in the edited scene (undoable), optionally binding a TileSet .tres so cells can be painted. In-scene and undoable — not gated.",
+        inputSchema: {
+            parent_path: z.string().describe("Parent node path relative to the scene root; \".\" for the root"),
+            name: z.string().optional().describe("Node name (default \"TileMapLayer\")"),
+            tileset_path: z.string().optional().describe("TileSet res:// .tres path to bind as tile_set (e.g. from tileset_create)"),
+        },
+    }, async ({ parent_path, name, tileset_path }) => {
+        const params = { parent_path };
+        if (name !== undefined)
+            params.name = name;
+        if (tileset_path !== undefined)
+            params.tileset_path = tileset_path;
+        return call("tilemaplayer.create", params);
+    });
+    server.registerTool("tilemap_set_cell", {
+        title: "Set TileMapLayer cell",
+        description: "Paint a single cell on a TileMapLayer (undoable). source_id -1 erases the cell (default). atlas_coords defaults to [0, 0]; alternative defaults to 0.",
+        inputSchema: {
+            path: z.string().describe("TileMapLayer node path relative to the scene root"),
+            coords: z.array(z.number().int()).describe("Cell coordinates [x, y] (in cells)"),
+            source_id: z.number().int().optional().describe("Atlas source id from the bound TileSet, or -1 to erase (default -1)"),
+            atlas_coords: z.array(z.number().int()).optional().describe("Tile atlas coordinates [x, y] within the source (default [0, 0])"),
+            alternative: z.number().int().optional().describe("Alternative tile id (default 0)"),
+        },
+    }, async ({ path, coords, source_id, atlas_coords, alternative }) => {
+        const params = { path, coords };
+        if (source_id !== undefined)
+            params.source_id = source_id;
+        if (atlas_coords !== undefined)
+            params.atlas_coords = atlas_coords;
+        if (alternative !== undefined)
+            params.alternative = alternative;
+        return call("tilemap.set_cell", params);
+    });
+    server.registerTool("tilemap_set_cells_rect", {
+        title: "Fill TileMapLayer cells (rect)",
+        description: "Paint every cell in a rectangular region of a TileMapLayer with one tile (undoable, one action). source_id -1 clears the region. Capped at 65536 cells; split larger fills across calls.",
+        inputSchema: {
+            path: z.string().describe("TileMapLayer node path relative to the scene root"),
+            rect: z.array(z.number().int()).describe("Region [x, y, width, height] in cells (width/height > 0)"),
+            source_id: z.number().int().optional().describe("Atlas source id from the bound TileSet, or -1 to clear (default -1)"),
+            atlas_coords: z.array(z.number().int()).optional().describe("Tile atlas coordinates [x, y] within the source (default [0, 0])"),
+            alternative: z.number().int().optional().describe("Alternative tile id (default 0)"),
+        },
+    }, async ({ path, rect, source_id, atlas_coords, alternative }) => {
+        const params = { path, rect };
+        if (source_id !== undefined)
+            params.source_id = source_id;
+        if (atlas_coords !== undefined)
+            params.atlas_coords = atlas_coords;
+        if (alternative !== undefined)
+            params.alternative = alternative;
+        return call("tilemap.set_cells_rect", params);
+    });
+    server.registerTool("tilemap_get_cell", {
+        title: "Get TileMapLayer cell",
+        description: "Read one cell of a TileMapLayer. An empty cell reads back as source_id -1, atlas_coords [-1, -1], alternative 0 (empty = true).",
+        inputSchema: {
+            path: z.string().describe("TileMapLayer node path relative to the scene root"),
+            coords: z.array(z.number().int()).describe("Cell coordinates [x, y] (in cells)"),
+        },
+    }, async ({ path, coords }) => call("tilemap.get_cell", { path, coords }));
+    server.registerTool("tilemap_clear", {
+        title: "Clear TileMapLayer",
+        description: "Remove every painted cell from a TileMapLayer (undoable — prior cells are restored on undo). Returns the number of cells cleared.",
+        inputSchema: {
+            path: z.string().describe("TileMapLayer node path relative to the scene root"),
+        },
+    }, async ({ path }) => call("tilemap.clear", { path }));
+}
+//# sourceMappingURL=tiles.js.map

package/dist/tools/editor/ui.js

@@ -0,0 +1,175 @@
+import { z } from "zod";
+import { gate } from "../../confirm.js";
+/** UI / Control / theming. control_* + container_add_child mutate the EDITED scene and are undoable via EditorUndoRedoManager and ungated (the node_* model). theme_* author a Theme on disk via ResourceSaver, so — like resource_* — they are file-writers gated by confirmation. */
+export function registerUiTools(server, call) {
+    server.registerTool("control_create", {
+        title: "Create control",
+        description: "Instance a Control-derived UI node (Button, Label, Panel, VBoxContainer, TextureRect, …) under a parent (undoable). Refuses non-Control classes. Optional 'text' is applied only to controls that expose a 'text' property. Returns the new node's path.",
+        inputSchema: {
+            parent_path: z.string().describe("Parent node path relative to the scene root; \".\" for the root"),
+            type: z.string().describe("Control subclass to instance, e.g. Button, Label, Panel, VBoxContainer, TextureRect"),
+            name: z.string().optional().describe("Node name (defaults to the class name)"),
+            text: z.string().optional().describe("Initial text; applied only if the control has a 'text' property"),
+        },
+    }, async ({ parent_path, type, name, text }) => {
+        const params = { parent_path, type };
+        if (name !== undefined)
+            params.name = name;
+        if (text !== undefined)
+            params.text = text;
+        return call("control.create", params);
+    });
+    server.registerTool("container_add_child", {
+        title: "Add control to container",
+        description: "Instance a Control-derived child under a Container node (VBoxContainer, GridContainer, MarginContainer, …) so it participates in the container's layout (undoable). Refuses a non-Container parent or a non-Control child. Returns the new node's path.",
+        inputSchema: {
+            container_path: z.string().describe("Container node path relative to the scene root"),
+            type: z.string().describe("Control subclass to instance as the container's child, e.g. Button, Label"),
+            name: z.string().optional().describe("Node name (defaults to the class name)"),
+        },
+    }, async ({ container_path, type, name }) => call("container.add_child", name !== undefined ? { container_path, type, name } : { container_path, type }));
+    server.registerTool("control_set_anchors", {
+        title: "Set control anchors",
+        description: "Set one or more of a Control's anchors (left/top/right/bottom, each 0..1) directly (undoable). Only the sides you pass are changed; offsets are left as-is. Provide at least one side.",
+        inputSchema: {
+            path: z.string().describe("Control node path relative to the scene root"),
+            left: z.number().optional().describe("anchor_left (0..1)"),
+            top: z.number().optional().describe("anchor_top (0..1)"),
+            right: z.number().optional().describe("anchor_right (0..1)"),
+            bottom: z.number().optional().describe("anchor_bottom (0..1)"),
+        },
+    }, async ({ path, left, top, right, bottom }) => {
+        const params = { path };
+        if (left !== undefined)
+            params.left = left;
+        if (top !== undefined)
+            params.top = top;
+        if (right !== undefined)
+            params.right = right;
+        if (bottom !== undefined)
+            params.bottom = bottom;
+        return call("control.set_anchors", params);
+    });
+    server.registerTool("control_set_layout_preset", {
+        title: "Apply control layout preset",
+        description: "Apply a LayoutPreset to a Control via set_anchors_and_offsets_preset (undoable). 'preset' is a name (full_rect, center, top_left, center_top, left_wide, hcenter_wide, …) or the integer enum value. Optional resize_mode (0=min_size,1=keep_width,2=keep_height,3=keep_size) and margin.",
+        inputSchema: {
+            path: z.string().describe("Control node path relative to the scene root"),
+            preset: z.union([z.string(), z.number()]).describe("LayoutPreset name or integer (0..15)"),
+            resize_mode: z.number().int().optional().describe("LayoutPresetMode 0..3 (default 0 = min size)"),
+            margin: z.number().int().optional().describe("Margin in pixels applied by the preset (default 0)"),
+        },
+    }, async ({ path, preset, resize_mode, margin }) => {
+        const params = { path, preset };
+        if (resize_mode !== undefined)
+            params.resize_mode = resize_mode;
+        if (margin !== undefined)
+            params.margin = margin;
+        return call("control.set_layout_preset", params);
+    });
+    server.registerTool("control_set_size_flags", {
+        title: "Set control size flags",
+        description: "Set a Control's container size flags and/or stretch ratio (undoable). 'horizontal'/'vertical' are SizeFlags bitmasks (1=fill, 2=expand, 3=expand_fill, 4=shrink_center, 8=shrink_end). Provide at least one of horizontal/vertical/stretch_ratio.",
+        inputSchema: {
+            path: z.string().describe("Control node path relative to the scene root"),
+            horizontal: z.number().int().optional().describe("size_flags_horizontal bitmask"),
+            vertical: z.number().int().optional().describe("size_flags_vertical bitmask"),
+            stretch_ratio: z.number().optional().describe("size_flags_stretch_ratio (default 1.0)"),
+        },
+    }, async ({ path, horizontal, vertical, stretch_ratio }) => {
+        const params = { path };
+        if (horizontal !== undefined)
+            params.horizontal = horizontal;
+        if (vertical !== undefined)
+            params.vertical = vertical;
+        if (stretch_ratio !== undefined)
+            params.stretch_ratio = stretch_ratio;
+        return call("control.set_size_flags", params);
+    });
+    server.registerTool("control_set_theme", {
+        title: "Set control theme",
+        description: "Assign a Theme resource (res:// path) to a Control's 'theme' property so it and its children inherit it (undoable). Pass an empty theme_path to clear the override.",
+        inputSchema: {
+            path: z.string().describe("Control node path relative to the scene root"),
+            theme_path: z.string().describe("Theme res:// path, or \"\" to clear the theme override"),
+        },
+    }, async ({ path, theme_path }) => call("control.set_theme", { path, theme_path }));
+    server.registerTool("theme_create", {
+        title: "Create theme",
+        description: "Create a new empty Theme resource and save it to a res:// path. DESTRUCTIVE (writes a file) — gated by confirmation.",
+        inputSchema: {
+            to_path: z.string().describe("Destination res:// path, e.g. res://ui/main.theme or res://ui/main.tres"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ to_path, confirm }) => {
+        const blocked = await gate(server, confirm, `Create Theme resource at ${to_path}`);
+        if (blocked)
+            return blocked;
+        return call("theme.create", { to_path });
+    });
+    server.registerTool("theme_set_color", {
+        title: "Set theme color",
+        description: "Set a color entry on a Theme resource file and save it (e.g. font_color for the Button type). DESTRUCTIVE (writes a file) — gated by confirmation. 'color' is [r,g,b] or [r,g,b,a] with components 0..1.",
+        inputSchema: {
+            path: z.string().describe("Theme res:// path"),
+            name: z.string().describe("Theme item name, e.g. font_color"),
+            theme_type: z.string().describe("Theme type the item belongs to, e.g. Button, Label"),
+            color: z.array(z.number()).describe("[r,g,b] or [r,g,b,a], components 0..1"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ path, name, theme_type, color, confirm }) => {
+        const blocked = await gate(server, confirm, `Set theme color ${theme_type}/${name} in ${path}`);
+        if (blocked)
+            return blocked;
+        return call("theme.set_color", { path, name, theme_type, color });
+    });
+    server.registerTool("theme_set_font", {
+        title: "Set theme font",
+        description: "Set a font entry on a Theme resource file (loading a Font from a res:// path) and save it. DESTRUCTIVE (writes a file) — gated by confirmation.",
+        inputSchema: {
+            path: z.string().describe("Theme res:// path"),
+            name: z.string().describe("Theme item name, e.g. font"),
+            theme_type: z.string().describe("Theme type the item belongs to, e.g. Button, Label"),
+            font_path: z.string().describe("Font resource res:// path (FontFile / SystemFont / …)"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ path, name, theme_type, font_path, confirm }) => {
+        const blocked = await gate(server, confirm, `Set theme font ${theme_type}/${name} in ${path}`);
+        if (blocked)
+            return blocked;
+        return call("theme.set_font", { path, name, theme_type, font_path });
+    });
+    server.registerTool("theme_set_stylebox", {
+        title: "Set theme stylebox",
+        description: "Set a StyleBox entry on a Theme resource file (loading a StyleBox from a res:// path) and save it. DESTRUCTIVE (writes a file) — gated by confirmation.",
+        inputSchema: {
+            path: z.string().describe("Theme res:// path"),
+            name: z.string().describe("Theme item name, e.g. normal, pressed, panel"),
+            theme_type: z.string().describe("Theme type the item belongs to, e.g. Button, PanelContainer"),
+            stylebox_path: z.string().describe("StyleBox resource res:// path (StyleBoxFlat / StyleBoxTexture / …)"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ path, name, theme_type, stylebox_path, confirm }) => {
+        const blocked = await gate(server, confirm, `Set theme stylebox ${theme_type}/${name} in ${path}`);
+        if (blocked)
+            return blocked;
+        return call("theme.set_stylebox", { path, name, theme_type, stylebox_path });
+    });
+    server.registerTool("theme_set_constant", {
+        title: "Set theme constant",
+        description: "Set an integer constant entry on a Theme resource file and save it (e.g. h_separation for a BoxContainer). DESTRUCTIVE (writes a file) — gated by confirmation.",
+        inputSchema: {
+            path: z.string().describe("Theme res:// path"),
+            name: z.string().describe("Theme item name, e.g. h_separation, margin_left"),
+            theme_type: z.string().describe("Theme type the item belongs to, e.g. HBoxContainer, MarginContainer"),
+            value: z.number().int().describe("Integer constant value"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ path, name, theme_type, value, confirm }) => {
+        const blocked = await gate(server, confirm, `Set theme constant ${theme_type}/${name} in ${path}`);
+        if (blocked)
+            return blocked;
+        return call("theme.set_constant", { path, name, theme_type, value });
+    });
+}
+//# sourceMappingURL=ui.js.map