pixelweaver 0.1.0

package/server/tests/test_mcp_registry.py

@@ -0,0 +1,679 @@
+"""Tests for the MCP command registry."""
+
+from __future__ import annotations
+
+import base64
+from io import BytesIO
+
+import pytest
+from PIL import Image
+
+from pixelweaver.connections import ConnectionManager
+from pixelweaver.mcp_registry import MCPCommandRegistry
+from pixelweaver.state import ServerState
+
+
+@pytest.fixture()
+def state() -> ServerState:
+    """ServerState with one active project."""
+    s = ServerState()
+    s.create_project("test-project", 32, 32)
+    return s
+
+
+@pytest.fixture()
+def connections() -> ConnectionManager:
+    return ConnectionManager()
+
+
+@pytest.fixture()
+def registry(state: ServerState, connections: ConnectionManager) -> MCPCommandRegistry:
+    return MCPCommandRegistry(state, connections)
+
+
+class TestToolDefinitions:
+    def test_has_all_expected_tools(self, registry: MCPCommandRegistry):
+        """Tool definitions include all expected drawing, layer, and project tools."""
+        defs = registry.get_tool_definitions()
+        names = {d["name"] for d in defs}
+
+        # Drawing tools
+        for tool in [
+            "draw_pixels", "erase_pixels", "flood_fill", "draw_line",
+            "draw_rect", "draw_ellipse", "draw_diamond", "draw_gradient",
+            "draw_noise", "draw_dither",
+        ]:
+            assert tool in names, f"Missing drawing tool: {tool}"
+
+        # Layer tools
+        for tool in [
+            "add_layer", "remove_layer", "rename_layer", "move_layer",
+            "set_layer_visibility", "set_layer_opacity",
+        ]:
+            assert tool in names, f"Missing layer tool: {tool}"
+
+        # Frame tools (mutation)
+        for tool in [
+            "add_frame", "remove_frame", "duplicate_frame", "reorder_frame",
+            "set_frame_duration", "set_global_fps", "set_current_frame",
+        ]:
+            assert tool in names, f"Missing frame tool: {tool}"
+
+        # Frame tools (read-only)
+        for tool in ["get_frame_count", "get_current_frame"]:
+            assert tool in names, f"Missing frame read tool: {tool}"
+
+        # Project tools
+        for tool in [
+            "create_project", "list_projects", "open_project",
+            "save_project", "get_project_info",
+        ]:
+            assert tool in names, f"Missing project tool: {tool}"
+
+        # Canvas tools
+        for tool in ["get_canvas_size", "resize_canvas", "get_pixel", "get_region"]:
+            assert tool in names, f"Missing canvas tool: {tool}"
+
+        # History tools
+        for tool in ["undo", "redo", "get_action_log"]:
+            assert tool in names, f"Missing history tool: {tool}"
+
+        # Export tools
+        for tool in ["export_png", "export_spritesheet"]:
+            assert tool in names, f"Missing export tool: {tool}"
+
+        # Curated tools
+        for tool in ["draw_shape", "fill_area", "apply_effect"]:
+            assert tool in names, f"Missing curated tool: {tool}"
+
+        # Read tools
+        for tool in [
+            "get_canvas_info", "get_layer_tree", "get_palette", "get_canvas_thumbnail",
+        ]:
+            assert tool in names, f"Missing read tool: {tool}"
+
+    def test_tool_definitions_have_required_fields(self, registry: MCPCommandRegistry):
+        """Every tool def has name, description, and inputSchema."""
+        for td in registry.get_tool_definitions():
+            assert "name" in td
+            assert "description" in td
+            assert "inputSchema" in td
+            assert td["inputSchema"]["type"] == "object"
+
+    def test_get_tool_def_by_name(self, registry: MCPCommandRegistry):
+        """get_tool_def returns the correct ToolDef for a known tool."""
+        td = registry.get_tool_def("draw_pixels")
+        assert td is not None
+        assert td.name == "draw_pixels"
+        assert td.mutates is True
+
+        td_read = registry.get_tool_def("get_canvas_info")
+        assert td_read is not None
+        assert td_read.mutates is False
+
+
+class TestDrawingToolExecution:
+    @pytest.mark.asyncio
+    async def test_draw_pixels_creates_command(
+        self, registry: MCPCommandRegistry, state: ServerState,
+    ):
+        """Executing draw_pixels stores a command in project history."""
+        result = await registry.execute_tool("draw_pixels", {
+            "pixels": [{"x": 0, "y": 0}],
+            "color": "#ff0000ff",
+        })
+        assert result["success"] is True
+        assert "command_id" in result
+
+        project = state.get_active_project()
+        assert project is not None
+        assert len(project.command_history) == 1
+        assert project.command_history[0]["type"] == "draw_pixels"
+
+    @pytest.mark.asyncio
+    async def test_draw_pixels_no_project(self, connections: ConnectionManager):
+        """Drawing without an active project returns an error."""
+        empty_state = ServerState()
+        reg = MCPCommandRegistry(empty_state, connections)
+        result = await reg.execute_tool("draw_pixels", {
+            "pixels": [{"x": 0, "y": 0}],
+            "color": "#ff0000ff",
+        })
+        assert result["success"] is False
+        assert "No active project" in result["error"]
+
+
+class TestReadToolExecution:
+    @pytest.mark.asyncio
+    async def test_get_canvas_info_returns_data(self, registry: MCPCommandRegistry):
+        """get_canvas_info returns canvas metadata."""
+        result = await registry.execute_tool("get_canvas_info", {})
+        assert result["success"] is True
+        assert "canvases" in result
+        assert len(result["canvases"]) == 1
+        canvas = result["canvases"][0]
+        assert canvas["width"] == 32
+        assert canvas["height"] == 32
+
+    @pytest.mark.asyncio
+    async def test_get_layer_tree_returns_layers(self, registry: MCPCommandRegistry):
+        """get_layer_tree returns the layer structure."""
+        result = await registry.execute_tool("get_layer_tree", {})
+        assert result["success"] is True
+        assert len(result["layers"]) == 1
+        assert result["layers"][0]["name"] == "Layer 0"
+
+    @pytest.mark.asyncio
+    async def test_get_pixel_returns_color(self, registry: MCPCommandRegistry):
+        """get_pixel reads from pixel data (default is transparent)."""
+        result = await registry.execute_tool("get_pixel", {"x": 0, "y": 0})
+        assert result["success"] is True
+        # Default canvas is all transparent
+        assert result["rgba"] == [0, 0, 0, 0]
+
+    @pytest.mark.asyncio
+    async def test_get_pixel_out_of_bounds(self, registry: MCPCommandRegistry):
+        """get_pixel with invalid coords returns error."""
+        result = await registry.execute_tool("get_pixel", {"x": 999, "y": 999})
+        assert result["success"] is False
+        assert "out of bounds" in result["error"]
+
+
+class TestUnknownTool:
+    @pytest.mark.asyncio
+    async def test_unknown_tool_returns_error(self, registry: MCPCommandRegistry):
+        """Calling an unregistered tool returns an error."""
+        result = await registry.execute_tool("nonexistent_tool", {})
+        assert result["success"] is False
+        assert "Unknown tool" in result["error"]
+
+
+class TestCuratedTools:
+    @pytest.mark.asyncio
+    async def test_draw_shape_rect(self, registry: MCPCommandRegistry, state: ServerState):
+        """draw_shape with shape=rect dispatches draw_rect command."""
+        result = await registry.execute_tool("draw_shape", {
+            "shape": "rect",
+            "x": 0,
+            "y": 0,
+            "width": 10,
+            "height": 10,
+            "color": "#00ff00ff",
+        })
+        assert result["success"] is True
+
+        project = state.get_active_project()
+        assert project is not None
+        assert project.command_history[-1]["type"] == "draw_rect"
+
+    @pytest.mark.asyncio
+    async def test_draw_shape_ellipse(self, registry: MCPCommandRegistry, state: ServerState):
+        """draw_shape with shape=ellipse dispatches draw_ellipse command."""
+        result = await registry.execute_tool("draw_shape", {
+            "shape": "ellipse",
+            "x": 10,
+            "y": 10,
+            "width": 5,
+            "height": 5,
+            "color": "#0000ffff",
+        })
+        assert result["success"] is True
+
+        project = state.get_active_project()
+        assert project is not None
+        cmd = project.command_history[-1]
+        assert cmd["type"] == "draw_ellipse"
+        # x/y should be remapped to cx/cy
+        assert cmd["params"]["cx"] == 10
+        assert cmd["params"]["cy"] == 10
+
+    @pytest.mark.asyncio
+    async def test_draw_shape_unknown(self, registry: MCPCommandRegistry):
+        """draw_shape with an invalid shape name returns error."""
+        result = await registry.execute_tool("draw_shape", {
+            "shape": "hexagon",
+            "x": 0, "y": 0, "width": 5, "height": 5,
+            "color": "#ffffffff",
+        })
+        assert result["success"] is False
+        assert "Unknown shape" in result["error"]
+
+    @pytest.mark.asyncio
+    async def test_fill_area_dispatches_flood_fill(
+        self, registry: MCPCommandRegistry, state: ServerState,
+    ):
+        """fill_area dispatches a flood_fill command."""
+        result = await registry.execute_tool("fill_area", {
+            "x": 5, "y": 5, "color": "#ff0000ff",
+        })
+        assert result["success"] is True
+
+        project = state.get_active_project()
+        assert project is not None
+        assert project.command_history[-1]["type"] == "flood_fill"
+
+
+class TestProjectTools:
+    @pytest.mark.asyncio
+    async def test_list_projects(self, registry: MCPCommandRegistry):
+        """list_projects returns the loaded projects."""
+        result = await registry.execute_tool("list_projects", {})
+        assert result["success"] is True
+        assert "test-project" in result["projects"]
+
+    @pytest.mark.asyncio
+    async def test_create_project(self, registry: MCPCommandRegistry, state: ServerState):
+        """create_project adds a new project and sets it active."""
+        result = await registry.execute_tool("create_project", {
+            "name": "new-art",
+            "width": 16,
+            "height": 16,
+        })
+        assert result["success"] is True
+        assert "new-art" in state.projects
+        assert state.active_project == "new-art"
+
+    @pytest.mark.asyncio
+    async def test_create_duplicate_project(self, registry: MCPCommandRegistry):
+        """Creating a project with a duplicate name returns error."""
+        result = await registry.execute_tool("create_project", {
+            "name": "test-project",
+            "width": 8,
+            "height": 8,
+        })
+        assert result["success"] is False
+        assert "already exists" in result["error"]
+
+
+class TestHistoryTools:
+    @pytest.mark.asyncio
+    async def test_undo_redo_cycle(self, registry: MCPCommandRegistry, state: ServerState):
+        """undo/redo cycle works correctly via MCP tools."""
+        # Add a command
+        await registry.execute_tool("draw_pixels", {
+            "pixels": [{"x": 0, "y": 0}],
+            "color": "#ff0000ff",
+        })
+        project = state.get_active_project()
+        assert project is not None
+        assert len(project.command_history) == 1
+
+        # Undo
+        result = await registry.execute_tool("undo", {})
+        assert result["success"] is True
+        assert len(project.command_history) == 0
+        assert len(project.redo_stack) == 1
+
+        # Redo
+        result = await registry.execute_tool("redo", {})
+        assert result["success"] is True
+        assert len(project.command_history) == 1
+        assert len(project.redo_stack) == 0
+
+    @pytest.mark.asyncio
+    async def test_get_action_log(self, registry: MCPCommandRegistry):
+        """get_action_log returns history entries."""
+        await registry.execute_tool("draw_pixels", {
+            "pixels": [{"x": 0, "y": 0}],
+            "color": "#ff0000ff",
+        })
+        result = await registry.execute_tool("get_action_log", {"limit": 10})
+        assert result["success"] is True
+        assert len(result["actions"]) == 1
+        assert result["actions"][0]["type"] == "draw_pixels"
+
+
+class TestFrameTools:
+    """Tests for frame mutation and read tools."""
+
+    @pytest.mark.asyncio
+    async def test_add_frame_increases_count(
+        self, registry: MCPCommandRegistry, state: ServerState,
+    ):
+        """add_frame inserts a new frame and increases frame_count."""
+        canvas = next(iter(state.get_active_project().canvases.values()))
+        initial_count = canvas.frame_count
+        result = await registry.execute_tool("add_frame", {})
+        assert result["success"] is True
+        assert result["frame_count"] == initial_count + 1
+        assert canvas.frame_count == initial_count + 1
+
+    @pytest.mark.asyncio
+    async def test_add_frame_after_index(
+        self, registry: MCPCommandRegistry, state: ServerState,
+    ):
+        """add_frame inserts after the specified index."""
+        canvas = next(iter(state.get_active_project().canvases.values()))
+        first_frame_id = canvas.frames[0].id
+        result = await registry.execute_tool("add_frame", {"after_index": -1})
+        assert result["success"] is True
+        # New frame should be at index 0, original moves to index 1
+        assert canvas.frames[1].id == first_frame_id
+        assert canvas.frames[0].id == result["frame_id"]
+
+    @pytest.mark.asyncio
+    async def test_add_frame_no_project(self, connections: ConnectionManager):
+        """add_frame without active project returns error."""
+        empty = ServerState()
+        reg = MCPCommandRegistry(empty, connections)
+        result = await reg.execute_tool("add_frame", {})
+        assert result["success"] is False
+        assert "No active project" in result["error"]
+
+    @pytest.mark.asyncio
+    async def test_remove_frame_decreases_count(
+        self, registry: MCPCommandRegistry, state: ServerState,
+    ):
+        """remove_frame removes a frame and decreases frame_count."""
+        # First add a second frame
+        await registry.execute_tool("add_frame", {})
+        canvas = next(iter(state.get_active_project().canvases.values()))
+        assert canvas.frame_count == 2
+
+        result = await registry.execute_tool("remove_frame", {"frame_index": 1})
+        assert result["success"] is True
+        assert result["frame_count"] == 1
+        assert canvas.frame_count == 1
+
+    @pytest.mark.asyncio
+    async def test_remove_last_frame_fails(
+        self, registry: MCPCommandRegistry,
+    ):
+        """Cannot remove the only remaining frame."""
+        result = await registry.execute_tool("remove_frame", {"frame_index": 0})
+        assert result["success"] is False
+        assert "Cannot remove the last frame" in result["error"]
+
+    @pytest.mark.asyncio
+    async def test_remove_frame_adjusts_current_index(
+        self, registry: MCPCommandRegistry, state: ServerState,
+    ):
+        """Removing a frame adjusts current_frame_index to stay valid."""
+        canvas = next(iter(state.get_active_project().canvases.values()))
+        # Add two more frames (total 3)
+        await registry.execute_tool("add_frame", {})
+        await registry.execute_tool("add_frame", {})
+        assert canvas.frame_count == 3
+
+        # Point to the last frame
+        canvas.current_frame_index = 2
+        # Remove it
+        result = await registry.execute_tool("remove_frame", {"frame_index": 2})
+        assert result["success"] is True
+        assert canvas.current_frame_index == 1  # clamped to new last index
+
+    @pytest.mark.asyncio
+    async def test_duplicate_frame_creates_copy(
+        self, registry: MCPCommandRegistry, state: ServerState,
+    ):
+        """duplicate_frame creates a new frame with a different ID but same data."""
+        canvas = next(iter(state.get_active_project().canvases.values()))
+        original_id = canvas.frames[0].id
+
+        result = await registry.execute_tool("duplicate_frame", {"frame_index": 0})
+        assert result["success"] is True
+        assert result["source_frame_id"] == original_id
+        assert result["frame_id"] != original_id
+        assert result["frame_count"] == 2
+        assert canvas.frame_count == 2
+
+        # Pixel data should be copied (same content, different objects)
+        source = canvas.frames[0]
+        dup = canvas.frames[1]
+        for layer_id, data in source.pixel_data.items():
+            assert layer_id in dup.pixel_data
+            assert dup.pixel_data[layer_id] == data
+            assert dup.pixel_data[layer_id] is not data  # different object
+
+    @pytest.mark.asyncio
+    async def test_duplicate_frame_out_of_range(
+        self, registry: MCPCommandRegistry,
+    ):
+        """duplicate_frame with invalid index returns error."""
+        result = await registry.execute_tool("duplicate_frame", {"frame_index": 99})
+        assert result["success"] is False
+        assert "out of range" in result["error"]
+
+    @pytest.mark.asyncio
+    async def test_reorder_frame_moves_correctly(
+        self, registry: MCPCommandRegistry, state: ServerState,
+    ):
+        """reorder_frame moves a frame from one position to another."""
+        canvas = next(iter(state.get_active_project().canvases.values()))
+        # Add two frames (total 3: indices 0, 1, 2)
+        await registry.execute_tool("add_frame", {})
+        await registry.execute_tool("add_frame", {})
+        assert canvas.frame_count == 3
+
+        id_0 = canvas.frames[0].id
+        id_1 = canvas.frames[1].id
+        id_2 = canvas.frames[2].id
+
+        # Move frame 0 to position 2
+        result = await registry.execute_tool(
+            "reorder_frame", {"from_index": 0, "to_index": 2},
+        )
+        assert result["success"] is True
+        assert canvas.frames[0].id == id_1
+        assert canvas.frames[1].id == id_2
+        assert canvas.frames[2].id == id_0
+
+    @pytest.mark.asyncio
+    async def test_reorder_frame_tracks_current_index(
+        self, registry: MCPCommandRegistry, state: ServerState,
+    ):
+        """reorder_frame adjusts current_frame_index to track the same frame."""
+        canvas = next(iter(state.get_active_project().canvases.values()))
+        await registry.execute_tool("add_frame", {})
+        await registry.execute_tool("add_frame", {})
+
+        # Current index points to frame 0
+        canvas.current_frame_index = 0
+        current_frame_id = canvas.frames[0].id
+
+        # Move frame 0 to position 2
+        await registry.execute_tool(
+            "reorder_frame", {"from_index": 0, "to_index": 2},
+        )
+
+        # current_frame_index should follow the frame that was at index 0
+        assert canvas.frames[canvas.current_frame_index].id == current_frame_id
+
+    @pytest.mark.asyncio
+    async def test_set_frame_duration_updates(
+        self, registry: MCPCommandRegistry, state: ServerState,
+    ):
+        """set_frame_duration updates the frame's duration_ms."""
+        canvas = next(iter(state.get_active_project().canvases.values()))
+        assert canvas.frames[0].duration_ms is None  # default
+
+        result = await registry.execute_tool(
+            "set_frame_duration", {"frame_index": 0, "duration_ms": 200},
+        )
+        assert result["success"] is True
+        assert canvas.frames[0].duration_ms == 200
+
+    @pytest.mark.asyncio
+    async def test_set_frame_duration_null(
+        self, registry: MCPCommandRegistry, state: ServerState,
+    ):
+        """set_frame_duration with null resets to global FPS."""
+        canvas = next(iter(state.get_active_project().canvases.values()))
+        canvas.frames[0].duration_ms = 200
+
+        result = await registry.execute_tool(
+            "set_frame_duration", {"frame_index": 0, "duration_ms": None},
+        )
+        assert result["success"] is True
+        assert canvas.frames[0].duration_ms is None
+
+    @pytest.mark.asyncio
+    async def test_set_global_fps_updates(
+        self, registry: MCPCommandRegistry, state: ServerState,
+    ):
+        """set_global_fps updates canvas.global_fps with clamping."""
+        canvas = next(iter(state.get_active_project().canvases.values()))
+        assert canvas.global_fps == 12.0  # default
+
+        result = await registry.execute_tool("set_global_fps", {"fps": 24})
+        assert result["success"] is True
+        assert canvas.global_fps == 24.0
+
+    @pytest.mark.asyncio
+    async def test_set_global_fps_clamps(
+        self, registry: MCPCommandRegistry, state: ServerState,
+    ):
+        """set_global_fps clamps to [1, 120]."""
+        canvas = next(iter(state.get_active_project().canvases.values()))
+
+        await registry.execute_tool("set_global_fps", {"fps": 0.1})
+        assert canvas.global_fps == 1.0  # clamped to min
+
+        await registry.execute_tool("set_global_fps", {"fps": 999})
+        assert canvas.global_fps == 120.0  # clamped to max
+
+    @pytest.mark.asyncio
+    async def test_get_frame_count(self, registry: MCPCommandRegistry):
+        """get_frame_count returns count, current index, and fps."""
+        result = await registry.execute_tool("get_frame_count", {})
+        assert result["success"] is True
+        assert result["count"] == 1
+        assert result["current_index"] == 0
+        assert result["global_fps"] == 12.0
+
+    @pytest.mark.asyncio
+    async def test_get_current_frame(self, registry: MCPCommandRegistry):
+        """get_current_frame returns info about the current frame."""
+        result = await registry.execute_tool("get_current_frame", {})
+        assert result["success"] is True
+        assert result["index"] == 0
+        assert "id" in result
+        assert result["duration_ms"] is None
+
+    @pytest.mark.asyncio
+    async def test_set_current_frame(
+        self, registry: MCPCommandRegistry, state: ServerState,
+    ):
+        """set_current_frame changes the active frame index."""
+        canvas = next(iter(state.get_active_project().canvases.values()))
+        # Add a frame so we have two
+        await registry.execute_tool("add_frame", {})
+        assert canvas.frame_count == 2
+
+        result = await registry.execute_tool("set_current_frame", {"frame_index": 1})
+        assert result["success"] is True
+        assert canvas.current_frame_index == 1
+        assert result["current_frame_index"] == 1
+
+    @pytest.mark.asyncio
+    async def test_set_current_frame_out_of_range(
+        self, registry: MCPCommandRegistry,
+    ):
+        """set_current_frame with invalid index returns error."""
+        result = await registry.execute_tool("set_current_frame", {"frame_index": 99})
+        assert result["success"] is False
+        assert "out of range" in result["error"]
+
+
+class TestExportSpritesheet:
+    """Tests for export_spritesheet iterating frames within a canvas."""
+
+    @pytest.mark.asyncio
+    async def test_spritesheet_multi_frame_horizontal(
+        self, registry: MCPCommandRegistry, state: ServerState,
+    ):
+        """Spritesheet from 3 frames produces correct horizontal strip dimensions."""
+        project = state.get_active_project()
+        assert project is not None
+        canvas = next(iter(project.canvases.values()))
+
+        # Draw distinct pixels into frame 0 so it's non-empty
+        await registry.execute_tool("draw_pixels", {
+            "pixels": [{"x": 0, "y": 0}],
+            "color": "#ff0000ff",
+        })
+
+        # Add frame 1 with a different color
+        await registry.execute_tool("add_frame", {})
+        await registry.execute_tool("set_current_frame", {"frame_index": 1})
+        await registry.execute_tool("draw_pixels", {
+            "pixels": [{"x": 1, "y": 1}],
+            "color": "#00ff00ff",
+        })
+
+        # Add frame 2 with yet another color
+        await registry.execute_tool("add_frame", {})
+        await registry.execute_tool("set_current_frame", {"frame_index": 2})
+        await registry.execute_tool("draw_pixels", {
+            "pixels": [{"x": 2, "y": 2}],
+            "color": "#0000ffff",
+        })
+
+        assert canvas.frame_count == 3
+
+        result = await registry.execute_tool("export_spritesheet", {})
+        assert result["success"] is True
+        assert result["frame_count"] == canvas.frame_count
+        assert result["direction"] == "horizontal"
+        assert result["frame_width"] == canvas.width
+        assert result["frame_height"] == canvas.height
+
+        # Decode and verify the full image dimensions
+        img = Image.open(BytesIO(base64.b64decode(result["image_base64"])))
+        assert img.width == canvas.width * 3
+        assert img.height == canvas.height
+
+    @pytest.mark.asyncio
+    async def test_spritesheet_vertical(
+        self, registry: MCPCommandRegistry, state: ServerState,
+    ):
+        """Vertical spritesheet stacks frames top-to-bottom."""
+        project = state.get_active_project()
+        assert project is not None
+        canvas = next(iter(project.canvases.values()))
+
+        # Add a second frame
+        await registry.execute_tool("add_frame", {})
+        assert canvas.frame_count == 2
+
+        result = await registry.execute_tool(
+            "export_spritesheet", {"direction": "vertical"},
+        )
+        assert result["success"] is True
+        assert result["frame_count"] == 2
+        assert result["direction"] == "vertical"
+
+        img = Image.open(BytesIO(base64.b64decode(result["image_base64"])))
+        assert img.width == canvas.width
+        assert img.height == canvas.height * 2
+
+    @pytest.mark.asyncio
+    async def test_spritesheet_single_frame(
+        self, registry: MCPCommandRegistry,
+    ):
+        """Spritesheet with one frame returns a single-frame image."""
+        result = await registry.execute_tool("export_spritesheet", {})
+        assert result["success"] is True
+        assert result["frame_count"] == 1
+
+        img = Image.open(BytesIO(base64.b64decode(result["image_base64"])))
+        assert img.width == 32
+        assert img.height == 32
+
+    @pytest.mark.asyncio
+    async def test_spritesheet_no_project(self, connections: ConnectionManager):
+        """export_spritesheet without active project returns error."""
+        empty = ServerState()
+        reg = MCPCommandRegistry(empty, connections)
+        result = await reg.execute_tool("export_spritesheet", {})
+        assert result["success"] is False
+        assert "No active project" in result["error"]
+
+    @pytest.mark.asyncio
+    async def test_spritesheet_unknown_canvas(self, registry: MCPCommandRegistry):
+        """export_spritesheet with a non-existent canvas_name returns error."""
+        result = await registry.execute_tool(
+            "export_spritesheet", {"canvas_name": "no-such-canvas"},
+        )
+        assert result["success"] is False
+        assert "not found" in result["error"]