breakpoint-mcp 1.0.0 → 1.2.0

package/dist/tools/editor/scene.js

@@ -0,0 +1,95 @@
+import { z } from "zod";
+import { gate } from "../../confirm.js";
+/** Scene lifecycle: open / save / new / reload / pack / dependencies. */
+export function registerSceneTools(server, call) {
+    server.registerTool("scene_get_tree", {
+        title: "Get scene tree",
+        description: "Return the node tree of the currently edited scene (name, type, path, script, children).",
+        inputSchema: { max_depth: z.number().int().positive().optional().describe("Max recursion depth (default 64)") },
+    }, async ({ max_depth }) => call("scene.get_tree", max_depth ? { max_depth } : {}));
+    server.registerTool("scene_open", {
+        title: "Open scene",
+        description: "Open an existing scene in the editor by res:// path.",
+        inputSchema: { path: z.string().describe("Scene path, e.g. res://scenes/main.tscn") },
+    }, async ({ path }) => call("scene.open", { path }));
+    server.registerTool("scene_save", { title: "Save scene", description: "Save the currently edited scene to its existing path.", inputSchema: {} }, async () => call("scene.save"));
+    server.registerTool("scene_new", {
+        title: "New scene",
+        description: "Create a new scene with the given root class, save it to a path, and open it. DESTRUCTIVE (writes a file) — gated by confirmation.",
+        inputSchema: {
+            root_type: z.string().describe("Root node class, e.g. Node2D, Node3D, Control"),
+            path: z.string().describe("Where to save, e.g. res://scenes/new.tscn"),
+            name: z.string().optional().describe("Root node name (defaults to the class name)"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ root_type, path, name, confirm }) => {
+        const blocked = await gate(server, confirm, `Create and overwrite scene file "${path}"`);
+        if (blocked)
+            return blocked;
+        return call("scene.new", { root_type, path, name });
+    });
+    server.registerTool("scene_list_open", {
+        title: "List open scenes",
+        description: "List the res:// paths of all scenes open in the editor, which one is current, and which have unsaved changes. Read-only.",
+        inputSchema: {},
+    }, async () => call("scene.list_open"));
+    server.registerTool("scene_reload", {
+        title: "Reload scene from disk",
+        description: "Reload a scene from disk, discarding unsaved changes to it. DESTRUCTIVE — gated by confirmation. Defaults to the current scene.",
+        inputSchema: {
+            path: z.string().optional().describe("Scene res:// path; omitted = the current edited scene"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ path, confirm }) => {
+        const blocked = await gate(server, confirm, `Reload scene ${path ?? "(current)"} from disk, discarding unsaved changes`);
+        if (blocked)
+            return blocked;
+        return call("scene.reload", path !== undefined ? { path } : {});
+    });
+    server.registerTool("scene_close", {
+        title: "Close current scene",
+        description: "Close the current scene tab, discarding unsaved changes. DESTRUCTIVE — gated by confirmation. Only the current scene can be closed; pass its path to assert which one.",
+        inputSchema: {
+            path: z.string().optional().describe("Optional assertion: must equal the current edited scene's path"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ path, confirm }) => {
+        const blocked = await gate(server, confirm, "Close the current scene, discarding unsaved changes");
+        if (blocked)
+            return blocked;
+        return call("scene.close", path !== undefined ? { path } : {});
+    });
+    server.registerTool("scene_pack", {
+        title: "Pack branch as scene",
+        description: "Save a node branch (the node and its subtree) as a new PackedScene file. DESTRUCTIVE (writes a file) — gated by confirmation. Does not modify the edited scene.",
+        inputSchema: {
+            path: z.string().describe("Branch root node path relative to the scene root"),
+            to_path: z.string().describe("Where to save the PackedScene, e.g. res://scenes/branch.tscn"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ path, to_path, confirm }) => {
+        const blocked = await gate(server, confirm, `Pack branch "${path}" to ${to_path}`);
+        if (blocked)
+            return blocked;
+        return call("scene.pack", { path, to_path });
+    });
+    server.registerTool("scene_get_dependencies", {
+        title: "Scene dependencies",
+        description: "List the external resource dependencies of a scene file. Read-only. Defaults to the current scene.",
+        inputSchema: { path: z.string().optional().describe("Scene res:// path; omitted = the current edited scene") },
+    }, async ({ path }) => call("scene.get_dependencies", path !== undefined ? { path } : {}));
+    server.registerTool("scene_save_as", {
+        title: "Save scene as",
+        description: "Save the current scene to a new res:// path (Save As). DESTRUCTIVE (writes a file) — gated by confirmation.",
+        inputSchema: {
+            path: z.string().describe("Destination path, e.g. res://scenes/copy.tscn"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ path, confirm }) => {
+        const blocked = await gate(server, confirm, `Save the current scene to ${path}`);
+        if (blocked)
+            return blocked;
+        return call("scene.save_as", { path });
+    });
+}
+//# sourceMappingURL=scene.js.map

package/dist/tools/editor/shader.js

@@ -0,0 +1,59 @@
+import { z } from "zod";
+import { gate } from "../../confirm.js";
+/** Shader + ShaderMaterial authoring. */
+export function registerShaderTools(server, call) {
+    server.registerTool("shader_create", {
+        title: "Create shader",
+        description: "Create a Shader resource with optional initial code and save it as a .gdshader file. DESTRUCTIVE (writes a file) — gated by confirmation.",
+        inputSchema: {
+            to_path: z.string().describe("Destination res:// path, e.g. res://shaders/glow.gdshader"),
+            code: z.string().optional().describe("Initial GDShader source (e.g. \"shader_type canvas_item; ...\")"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ to_path, code, confirm }) => {
+        const blocked = await gate(server, confirm, `Create shader at ${to_path}`);
+        if (blocked)
+            return blocked;
+        return call("shader.create", code !== undefined ? { to_path, code } : { to_path });
+    });
+    server.registerTool("shader_set_code", {
+        title: "Set shader code",
+        description: "Replace the source code of an existing .gdshader resource and save it. DESTRUCTIVE (writes a file) — gated by confirmation.",
+        inputSchema: {
+            path: z.string().describe("Shader res:// path"),
+            code: z.string().describe("New GDShader source"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ path, code, confirm }) => {
+        const blocked = await gate(server, confirm, `Overwrite shader code at ${path}`);
+        if (blocked)
+            return blocked;
+        return call("shader.set_code", { path, code });
+    });
+    server.registerTool("shadermaterial_create", {
+        title: "Create shader material",
+        description: "Create a ShaderMaterial and assign it to a node's material slot in the edited scene (undoable). Targets CanvasItem.material (2D / Control) or GeometryInstance3D.material_override (3D); other node types return unsupported. Optionally assign a Shader loaded from a res:// path. In-scene and undoable — not gated.",
+        inputSchema: {
+            path: z.string().describe("Node path relative to the scene root (a CanvasItem or GeometryInstance3D)"),
+            shader_path: z.string().optional().describe("res:// path to a Shader to assign to the new material"),
+        },
+    }, async ({ path, shader_path }) => call("shadermaterial.create", shader_path !== undefined ? { path, shader_path } : { path }));
+    server.registerTool("shadermaterial_set_shader", {
+        title: "Set shader material shader",
+        description: "Load a Shader from a res:// path and assign it to the ShaderMaterial on a node's material slot in the edited scene (undoable). The node must already have a ShaderMaterial. In-scene and undoable — not gated.",
+        inputSchema: {
+            path: z.string().describe("Node path relative to the scene root"),
+            shader_path: z.string().describe("res:// path to a Shader resource"),
+        },
+    }, async ({ path, shader_path }) => call("shadermaterial.set_shader", { path, shader_path }));
+    server.registerTool("shadermaterial_set_param", {
+        title: "Set shader material parameter",
+        description: "Set a shader uniform parameter on the ShaderMaterial of a node's material slot in the edited scene (undoable). The node must already have a ShaderMaterial. The value uses the tagged-Variant convention. In-scene and undoable — not gated.",
+        inputSchema: {
+            path: z.string().describe("Node path relative to the scene root"),
+            param: z.string().describe("Shader uniform name"),
+            value: z.any().describe("New value (JSON scalar or __type__-tagged Variant)"),
+        },
+    }, async ({ path, param, value }) => call("shadermaterial.set_param", { path, param, value }));
+}
+//# sourceMappingURL=shader.js.map

package/dist/tools/editor/signal.js

@@ -0,0 +1,67 @@
+import { z } from "zod";
+import { gate } from "../../confirm.js";
+/** Signal introspection and (dis)connection on nodes. */
+export function registerSignalTools(server, call) {
+    server.registerTool("signal_list", {
+        title: "List node signals",
+        description: "List the signals a node declares (name and argument names), including user signals. Read-only.",
+        inputSchema: { path: z.string().describe("Node path relative to the scene root") },
+    }, async ({ path }) => call("signal.list", { path }));
+    server.registerTool("signal_list_connections", {
+        title: "List signal connections",
+        description: "List a node's outgoing signal connections (signal, target node path, method, flags). Optionally filter to one signal. Read-only.",
+        inputSchema: {
+            path: z.string().describe("Node path relative to the scene root"),
+            signal: z.string().optional().describe("Only list connections for this signal"),
+        },
+    }, async ({ path, signal }) => call("signal.list_connections", signal !== undefined ? { path, signal } : { path }));
+    server.registerTool("signal_connect", {
+        title: "Connect signal",
+        description: "Connect a source node's signal to a target node's method (undoable). Persistent by default (flags=2, CONNECT_PERSIST) so it saves into the scene. No-op if already connected.",
+        inputSchema: {
+            path: z.string().describe("Source node path (emitter)"),
+            signal: z.string().describe("Signal name on the source"),
+            target_path: z.string().describe("Target node path (receiver)"),
+            method: z.string().describe("Method to call on the target"),
+            flags: z.number().int().optional().describe("Object.ConnectFlags bitmask (default 2 = CONNECT_PERSIST)"),
+        },
+    }, async ({ path, signal, target_path, method, flags }) => call("signal.connect", flags !== undefined ? { path, signal, target_path, method, flags } : { path, signal, target_path, method }));
+    server.registerTool("signal_disconnect", {
+        title: "Disconnect signal",
+        description: "Disconnect a source node's signal from a target node's method (undoable). No-op if not connected.",
+        inputSchema: {
+            path: z.string().describe("Source node path (emitter)"),
+            signal: z.string().describe("Signal name on the source"),
+            target_path: z.string().describe("Target node path (receiver)"),
+            method: z.string().describe("Connected method on the target"),
+        },
+    }, async ({ path, signal, target_path, method }) => call("signal.disconnect", { path, signal, target_path, method }));
+    server.registerTool("signal_add_user_signal", {
+        title: "Add user signal",
+        description: "Declare a new user signal on a node (undoable). Optional typed arguments. Errors if the signal already exists.",
+        inputSchema: {
+            path: z.string().describe("Node path relative to the scene root"),
+            signal: z.string().describe("New signal name"),
+            args: z
+                .array(z.object({ name: z.string(), type: z.number().int().optional() }))
+                .optional()
+                .describe("Signal parameters (name + Variant type int)"),
+        },
+    }, async ({ path, signal, args }) => call("signal.add_user_signal", args !== undefined ? { path, signal, args } : { path, signal }));
+    server.registerTool("signal_emit", {
+        title: "Emit signal (edit-time)",
+        description: "Emit a signal from a node in the EDITED scene, firing its connected callables now. DESTRUCTIVE (edit-time side effects) — gated by confirmation. Args use the tagged-Variant convention.",
+        inputSchema: {
+            path: z.string().describe("Node path relative to the scene root"),
+            signal: z.string().describe("Signal name"),
+            args: z.array(z.any()).optional().describe("Signal arguments (JSON scalars or __type__-tagged Variants)"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ path, signal, args, confirm }) => {
+        const blocked = await gate(server, confirm, `Emit signal "${signal}" from ${path} in the edited scene`);
+        if (blocked)
+            return blocked;
+        return call("signal.emit", { path, signal, args: args ?? [] });
+    });
+}
+//# sourceMappingURL=signal.js.map

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