breakpoint-mcp 1.0.0 → 1.1.0

package/dist/tools/editor/project_input_test.js

@@ -0,0 +1,187 @@
+import { z } from "zod";
+import { gate } from "../../confirm.js";
+/** InputMap, extended project config (autoloads / export presets / main scene / settings), editor settings, and test-framework detection. */
+export function registerProjectInputTestTools(server, call) {
+    server.registerTool("inputmap_add_action", {
+        title: "Add input action",
+        description: "Define a project input action (ProjectSettings input/<name>) with an empty event list and a deadzone. Set save=true to persist to project.godot. DESTRUCTIVE (project-wide input map) — gated by confirmation.",
+        inputSchema: {
+            name: z.string().describe("Action name (without the input/ prefix)"),
+            deadzone: z.number().optional().describe("Analog deadzone 0..1 (default 0.5)"),
+            save: z.boolean().optional().describe("Persist to project.godot (default false)"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ name, deadzone, save, confirm }) => {
+        const blocked = await gate(server, confirm, `Add input action "${name}"${save ? " and save project.godot" : ""}`);
+        if (blocked)
+            return blocked;
+        const params = { name };
+        if (deadzone !== undefined)
+            params.deadzone = deadzone;
+        if (save !== undefined)
+            params.save = save;
+        return call("inputmap.add_action", params);
+    });
+    server.registerTool("inputmap_add_event", {
+        title: "Add input event to action",
+        description: "Append an input event to an existing project input action. 'event' is { type: key|mouse_button|joy_button|joy_motion, ... } — key: keycode or physical_keycode as a name like \"A\"/\"Space\" or an int; mouse_button/joy_button: button_index; joy_motion: axis + axis_value. Set save=true to persist. DESTRUCTIVE — gated by confirmation.",
+        inputSchema: {
+            name: z.string().describe("Existing action name (without the input/ prefix)"),
+            event: z
+                .object({
+                type: z.enum(["key", "mouse_button", "joy_button", "joy_motion"]).describe("Event type"),
+                keycode: z.union([z.string(), z.number()]).optional().describe("Key name or code (type=key)"),
+                physical_keycode: z.union([z.string(), z.number()]).optional().describe("Physical key name or code (type=key)"),
+                button_index: z.number().optional().describe("Button index (mouse_button/joy_button)"),
+                axis: z.number().optional().describe("Joypad axis (joy_motion)"),
+                axis_value: z.number().optional().describe("Joypad axis value (joy_motion)"),
+            })
+                .describe("Input event descriptor"),
+            save: z.boolean().optional().describe("Persist to project.godot (default false)"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ name, event, save, confirm }) => {
+        const blocked = await gate(server, confirm, `Add input event to "${name}"`);
+        if (blocked)
+            return blocked;
+        const params = { name, event };
+        if (save !== undefined)
+            params.save = save;
+        return call("inputmap.add_event", params);
+    });
+    server.registerTool("inputmap_list", {
+        title: "List input actions",
+        description: "List all project-defined input actions (ProjectSettings input/*) with their deadzone and events (class + human-readable text). Read-only.",
+        inputSchema: {},
+    }, async () => call("inputmap.list"));
+    server.registerTool("inputmap_erase_action", {
+        title: "Erase input action",
+        description: "Remove a project input action (ProjectSettings input/<name>). Set save=true to persist to project.godot. DESTRUCTIVE — gated by confirmation.",
+        inputSchema: {
+            name: z.string().describe("Action name (without the input/ prefix)"),
+            save: z.boolean().optional().describe("Persist to project.godot (default false)"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ name, save, confirm }) => {
+        const blocked = await gate(server, confirm, `Erase input action "${name}"${save ? " and save project.godot" : ""}`);
+        if (blocked)
+            return blocked;
+        const params = { name };
+        if (save !== undefined)
+            params.save = save;
+        return call("inputmap.erase_action", params);
+    });
+    server.registerTool("project_add_autoload", {
+        title: "Add autoload singleton",
+        description: "Register an autoload (ProjectSettings autoload/<name>) pointing at a res:// script or scene, enabled as a global singleton by default. Set save=true to persist to project.godot. DESTRUCTIVE — gated by confirmation.",
+        inputSchema: {
+            name: z.string().describe("Autoload / singleton name"),
+            path: z.string().describe("res:// path to a .gd script or .tscn scene"),
+            enabled: z.boolean().optional().describe("Enable as a global singleton (default true)"),
+            save: z.boolean().optional().describe("Persist to project.godot (default false)"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ name, path, enabled, save, confirm }) => {
+        const blocked = await gate(server, confirm, `Add autoload "${name}" -> ${path}${save ? " and save project.godot" : ""}`);
+        if (blocked)
+            return blocked;
+        const params = { name, path };
+        if (enabled !== undefined)
+            params.enabled = enabled;
+        if (save !== undefined)
+            params.save = save;
+        return call("project.add_autoload", params);
+    });
+    server.registerTool("project_remove_autoload", {
+        title: "Remove autoload singleton",
+        description: "Remove an autoload (ProjectSettings autoload/<name>). Set save=true to persist to project.godot. DESTRUCTIVE — gated by confirmation.",
+        inputSchema: {
+            name: z.string().describe("Autoload / singleton name"),
+            save: z.boolean().optional().describe("Persist to project.godot (default false)"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ name, save, confirm }) => {
+        const blocked = await gate(server, confirm, `Remove autoload "${name}"${save ? " and save project.godot" : ""}`);
+        if (blocked)
+            return blocked;
+        const params = { name };
+        if (save !== undefined)
+            params.save = save;
+        return call("project.remove_autoload", params);
+    });
+    server.registerTool("project_add_export_preset", {
+        title: "Add export preset",
+        description: "Append an export preset to res://export_presets.cfg for a platform (e.g. \"Windows Desktop\", \"Web\", \"Linux/X11\", \"macOS\"). Returns the preset's index. DESTRUCTIVE (writes export_presets.cfg) — gated by confirmation.",
+        inputSchema: {
+            name: z.string().describe("Preset display name"),
+            platform: z.string().describe("Export platform name as shown in the editor"),
+            runnable: z.boolean().optional().describe("Mark the preset runnable (default true)"),
+            export_path: z.string().optional().describe("Default export output path"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ name, platform, runnable, export_path, confirm }) => {
+        const blocked = await gate(server, confirm, `Add export preset "${name}" (${platform})`);
+        if (blocked)
+            return blocked;
+        const params = { name, platform };
+        if (runnable !== undefined)
+            params.runnable = runnable;
+        if (export_path !== undefined)
+            params.export_path = export_path;
+        return call("project.add_export_preset", params);
+    });
+    server.registerTool("project_set_main_scene", {
+        title: "Set main scene",
+        description: "Set the project's main scene (ProjectSettings application/run/main_scene) to an existing res:// .tscn/.scn. Set save=true to persist to project.godot. DESTRUCTIVE — gated by confirmation.",
+        inputSchema: {
+            path: z.string().describe("res:// path to the scene to run first"),
+            save: z.boolean().optional().describe("Persist to project.godot (default false)"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ path, save, confirm }) => {
+        const blocked = await gate(server, confirm, `Set main scene to ${path}${save ? " and save project.godot" : ""}`);
+        if (blocked)
+            return blocked;
+        const params = { path };
+        if (save !== undefined)
+            params.save = save;
+        return call("project.set_main_scene", params);
+    });
+    server.registerTool("project_list_settings", {
+        title: "List project settings",
+        description: "List ProjectSettings keys and values, optionally filtered by a dotted-key prefix (e.g. \"input/\", \"autoload/\", \"application/\"). Read-only.",
+        inputSchema: {
+            prefix: z.string().optional().describe("Only return keys starting with this prefix (default: all)"),
+        },
+    }, async ({ prefix }) => call("project.list_settings", prefix !== undefined ? { prefix } : {}));
+    server.registerTool("editorsettings_get_set", {
+        title: "Get or set an editor setting",
+        description: "Read an EditorSettings value by name; if 'value' is provided, write it instead (persists to the editor's global config). Reading is read-only; writing is DESTRUCTIVE (mutates the editor config) — gated by confirmation.",
+        inputSchema: {
+            name: z.string().describe("EditorSettings key, e.g. interface/editor/code_font_size"),
+            value: z.any().optional().describe("If provided, set this value (rich types use the {\"__type__\":...} tagging convention)"),
+            confirm: z.boolean().optional().describe("Auto-approve the write (skip the confirmation prompt)"),
+        },
+    }, async ({ name, value, confirm }) => {
+        if (value !== undefined) {
+            const blocked = await gate(server, confirm, `Set editor setting "${name}"`);
+            if (blocked)
+                return blocked;
+            return call("editorsettings.get_set", { name, value });
+        }
+        return call("editorsettings.get_set", { name });
+    });
+    server.registerTool("test_detect", {
+        title: "Detect test framework",
+        description: "Detect an installed GDScript test framework (GUT or GdUnit4) in the project. Returns { framework: gut|gdunit4|none, path, version }. Read-only.",
+        inputSchema: {},
+    }, async () => call("test.detect"));
+    server.registerTool("test_list", {
+        title: "List test scripts",
+        description: "List GDScript test scripts (files named test_*.gd or *_test.gd) under a directory (default res://test), searched recursively. Read-only.",
+        inputSchema: {
+            dir: z.string().optional().describe("Directory to search (default res://test)"),
+        },
+    }, async ({ dir }) => call("test.list", dir !== undefined ? { dir } : {}));
+}
+//# sourceMappingURL=project_input_test.js.map

package/dist/tools/editor/resource.js

@@ -0,0 +1,104 @@
+import { z } from "zod";
+import { gate } from "../../confirm.js";
+/** Resource (.tres/.res) create / load / save / property / import ops. */
+export function registerResourceTools(server, call) {
+    server.registerTool("resource_create", {
+        title: "Create resource",
+        description: "Instantiate a Resource subclass and save it as a new file. DESTRUCTIVE (writes a file) — gated by confirmation. Optional initial properties use the tagged-Variant convention.",
+        inputSchema: {
+            class_name: z.string().describe("Resource subclass to instantiate, e.g. StyleBoxFlat, Theme, GDScript"),
+            to_path: z.string().describe("Destination res:// path, e.g. res://styles/panel.tres"),
+            properties: z.record(z.any()).optional().describe("Initial property values (JSON scalars or __type__-tagged Variants)"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ class_name, to_path, properties, confirm }) => {
+        const blocked = await gate(server, confirm, `Create ${class_name} resource at ${to_path}`);
+        if (blocked)
+            return blocked;
+        return call("resource.create", properties !== undefined ? { class_name, to_path, properties } : { class_name, to_path });
+    });
+    server.registerTool("resource_load", {
+        title: "Load resource",
+        description: "Load a resource file and return its class, resource_name, and inspector-visible property list. Read-only.",
+        inputSchema: { path: z.string().describe("Resource res:// path") },
+    }, async ({ path }) => call("resource.load", { path }));
+    server.registerTool("resource_save", {
+        title: "Save resource",
+        description: "Load a resource and (re-)save it, optionally to a new path and with ResourceSaver flags. DESTRUCTIVE (writes a file) — gated by confirmation. Shares subresources by reference; use resource_duplicate for an independent copy.",
+        inputSchema: {
+            from_path: z.string().describe("Source resource res:// path"),
+            to_path: z.string().optional().describe("Destination res:// path (default: overwrite from_path)"),
+            flags: z.number().int().optional().describe("ResourceSaver.SaverFlags bitmask (e.g. 32 = FLAG_COMPRESS)"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ from_path, to_path, flags, confirm }) => {
+        const blocked = await gate(server, confirm, `Save resource ${from_path}${to_path ? ` to ${to_path}` : ""}`);
+        if (blocked)
+            return blocked;
+        const params = { from_path };
+        if (to_path !== undefined)
+            params.to_path = to_path;
+        if (flags !== undefined)
+            params.flags = flags;
+        return call("resource.save", params);
+    });
+    server.registerTool("resource_duplicate", {
+        title: "Duplicate resource",
+        description: "Load a resource, duplicate it (optionally deep, cloning subresources), and save the copy to a new path. DESTRUCTIVE (writes a file) — gated by confirmation.",
+        inputSchema: {
+            path: z.string().describe("Source resource res:// path"),
+            to_path: z.string().describe("Destination res:// path for the copy"),
+            deep: z.boolean().optional().describe("Deep-duplicate subresources (default false)"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ path, to_path, deep, confirm }) => {
+        const blocked = await gate(server, confirm, `Duplicate resource ${path} to ${to_path}`);
+        if (blocked)
+            return blocked;
+        return call("resource.duplicate", deep !== undefined ? { path, to_path, deep } : { path, to_path });
+    });
+    server.registerTool("resource_get_property", {
+        title: "Get resource property",
+        description: "Read a single property of a resource file by name. Read-only. The value comes back tagged (Variant convention).",
+        inputSchema: {
+            path: z.string().describe("Resource res:// path"),
+            property: z.string().describe("Property name"),
+        },
+    }, async ({ path, property }) => call("resource.get_property", { path, property }));
+    server.registerTool("resource_set_property", {
+        title: "Set resource property",
+        description: "Set a single property on a resource file and save it. DESTRUCTIVE (writes a file) — gated by confirmation. The value uses the tagged-Variant convention.",
+        inputSchema: {
+            path: z.string().describe("Resource res:// path"),
+            property: z.string().describe("Property name"),
+            value: z.any().describe("New value (JSON scalar or __type__-tagged Variant)"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ path, property, value, confirm }) => {
+        const blocked = await gate(server, confirm, `Set ${property} on ${path}`);
+        if (blocked)
+            return blocked;
+        return call("resource.set_property", { path, property, value });
+    });
+    server.registerTool("resource_get_import_settings", {
+        title: "Get import settings",
+        description: "Read an asset's import metadata (.import): the importer and its parameters. Read-only. Returns imported=false when the asset has no .import sidecar.",
+        inputSchema: { path: z.string().describe("Asset res:// path (e.g. res://icon.png)") },
+    }, async ({ path }) => call("resource.get_import_settings", { path }));
+    server.registerTool("resource_set_import_settings", {
+        title: "Set import settings",
+        description: "Update import parameters in an asset's .import metadata and trigger a reimport. DESTRUCTIVE (rewrites metadata + reimports) — gated by confirmation. Errors if the asset has no .import sidecar.",
+        inputSchema: {
+            path: z.string().describe("Asset res:// path"),
+            settings: z.record(z.any()).describe("Import params to set (name -> JSON scalar or __type__-tagged Variant)"),
+            reimport: z.boolean().optional().describe("Reimport after writing (default true)"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ path, settings, reimport, confirm }) => {
+        const blocked = await gate(server, confirm, `Set import settings on ${path} and reimport`);
+        if (blocked)
+            return blocked;
+        return call("resource.set_import_settings", reimport !== undefined ? { path, settings, reimport } : { path, settings });
+    });
+}
+//# sourceMappingURL=resource.js.map

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