feat(cp0): vendor arc_grid engine + renderer into proteus

proteus/arc_grid/README.md

@@ -0,0 +1,99 @@
+# arc_grid
+
+The **ARC-AGI 64×64 grid system**, extracted as a self-contained package you can drop
+into another project. Bundles the grid/sprite **engine** and the **visualization** layer.
+
+```
+arc_grid/
+├── __init__.py        # re-exports the public surface (engine + renderer)
+├── rendering.py       # visualization: 16-color palette, frame -> RGB / terminal
+└── arcengine/         # vendored engine (arcprize/ARCEngine, MIT)
+    ├── enums.py       # FrameData / FrameDataRaw, GameAction, GameState, color/mode enums
+    ├── sprites.py     # Sprite: the pixel-grid primitive (rotation, scale, collision)
+    ├── interfaces.py  # RenderableUserDisplay / ToggleableUserDisplay (UI overlays)
+    ├── camera.py      # Camera: sprites -> 64×64 frame (auto-scale + letterbox)
+    ├── level.py       # Level: a group of sprites + placeable areas
+    ├── base_game.py   # ARCBaseGame: the turn-based game loop
+    ├── OVERVIEW.md    # engine design notes
+    ├── LICENSE        # MIT (ARC Prize Foundation)
+    └── py.typed
+```
+
+## What's the "grid"?
+
+A **frame** is a list of layers; each layer is a **64×64** array of integers **0–15**
+(palette indices). Two representations of the same data live in `arcengine/enums.py`:
+
+| Type | `frame` field | Use |
+|---|---|---|
+| `FrameData` (pydantic) | `list[list[list[int]]]` | JSON / wire format |
+| `FrameDataRaw` | `list[numpy.ndarray]` (int8) | runtime format |
+
+Engine invariants: 64×64 output · 16 colors · 6 actions + `RESET` · turn-based ·
+each input yields 1–N frames.
+
+## Dependencies
+
+| Need | Requires |
+|---|---|
+| Engine (`arc_grid.arcengine`) | `numpy`, `pydantic` |
+| Renderer core (`frame_to_rgb_array`, `COLOR_MAP`) | `numpy` |
+| Animated display (`render_frames`) | `matplotlib` (optional; guarded by a `try`-import) |
+
+```bash
+pip install numpy pydantic        # minimum
+pip install matplotlib            # only if you use render_frames()
+```
+
+## Usage
+
+### Draw a raw 64×64 grid (engine not required)
+
+```python
+import numpy as np
+from arc_grid import frame_to_rgb_array, COLOR_MAP
+
+frame = np.zeros((64, 64), dtype=np.int8)
+frame[10:20, 10:20] = 8           # a red square (palette index 8)
+
+rgb = frame_to_rgb_array(0, frame, scale=4)   # -> (256, 256, 3) uint8
+# COLOR_MAP maps each 0–15 index to its hex color.
+```
+
+### Render in the terminal
+
+```python
+from arc_grid import render_frames_terminal
+from arc_grid import FrameDataRaw, GameState
+
+fd = FrameDataRaw()
+fd.frame = [frame]                # list of 64×64 arrays
+fd.state = GameState.NOT_FINISHED
+render_frames_terminal(0, fd)     # ANSI true-color, in-place
+```
+
+### Build a game with the engine
+
+```python
+from arc_grid import ARCBaseGame, Camera, Level, Sprite
+
+# Subclass ARCBaseGame, populate Levels with Sprites, drive it with GameActions.
+# See arcengine/OVERVIEW.md and the upstream examples for the full loop.
+```
+
+## How this was extracted
+
+* **Engine** — vendored verbatim from the `arcengine` pip package (v0.9.3). Internal imports
+  are all relative, so the folder works unmodified.
+* **Renderer** — copied from the ARC-AGI toolkit's `arc_agi/rendering.py`; the single external
+  import `from arcengine import FrameDataRaw` was changed to the relative
+  `from .arcengine import FrameDataRaw` so the package is self-contained.
+
+To move this into another project, copy the whole `arc_grid/` folder. To keep the engine fresh,
+re-vendor from upstream or switch `arc_grid/arcengine/` to a pip dependency on `arcengine`.
+
+## Attribution & License
+
+The `arcengine/` subpackage is **vendored from [arcprize/ARCEngine](https://github.com/arcprize/ARCEngine)**,
+© 2026 ARC Prize Foundation, **MIT License** (see `arcengine/LICENSE`). The renderer originates
+from the ARC-AGI toolkit (same foundation). Retain these notices when redistributing.

proteus/arc_grid/__init__.py

@@ -0,0 +1,78 @@
+"""arc_grid — the ARC-AGI 64x64 grid system, extracted as a standalone package.
+
+Bundles two pieces:
+
+* ``arc_grid.arcengine`` — the grid/sprite engine (vendored from arcprize/ARCEngine).
+  64x64 grid, 16-color palette, Sprite / Camera / Level / ARCBaseGame, collisions.
+  External deps: numpy, pydantic.
+* ``arc_grid.rendering`` — the visualization layer (palette + frame -> RGB / terminal).
+  External deps: numpy (always), matplotlib (only for the animated display helpers).
+
+Quick start::
+
+    import numpy as np
+    from arc_grid import frame_to_rgb_array, COLOR_MAP
+    from arc_grid import Sprite, Camera
+
+    frame = np.zeros((64, 64), dtype=np.int8)      # a blank 64x64 grid
+    rgb = frame_to_rgb_array(0, frame, scale=4)    # -> (256, 256, 3) uint8
+
+See README.md for details and attribution.
+"""
+
+# Engine surface (re-exported from the vendored arcengine package)
+from .arcengine import (
+    ARCBaseGame,
+    ActionInput,
+    BlockingMode,
+    Camera,
+    ComplexAction,
+    FrameData,
+    FrameDataRaw,
+    GameAction,
+    GameState,
+    InteractionMode,
+    Level,
+    PlaceableArea,
+    RenderableUserDisplay,
+    SimpleAction,
+    Sprite,
+    ToggleableUserDisplay,
+)
+
+# Rendering surface
+from .rendering import (
+    COLOR_MAP,
+    frame_to_rgb_array,
+    hex_to_rgb,
+    render_frames,
+    render_frames_terminal,
+    rgb_to_ansi,
+)
+
+__all__ = [
+    # engine
+    "ARCBaseGame",
+    "ActionInput",
+    "BlockingMode",
+    "Camera",
+    "ComplexAction",
+    "FrameData",
+    "FrameDataRaw",
+    "GameAction",
+    "GameState",
+    "InteractionMode",
+    "Level",
+    "PlaceableArea",
+    "RenderableUserDisplay",
+    "SimpleAction",
+    "Sprite",
+    "ToggleableUserDisplay",
+    # rendering
+    "COLOR_MAP",
+    "frame_to_rgb_array",
+    "hex_to_rgb",
+    "render_frames",
+    "render_frames_terminal",
+    "rgb_to_ansi",
+]

proteus/arc_grid/arcengine/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ARC Prize Foundation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

proteus/arc_grid/arcengine/OVERVIEW.md

@@ -0,0 +1,81 @@
+# ARCEngine Overview
+
+## Design Goals
+
+1. The engine only enforces the same opinions as ARC-AGI-3:
+   a. Visual: 64×64 output grid, 16 colors  
+   b. Inputs: limited to 6 actions plus a `RESET`  
+   c. Turn-based: no time advances without input  
+   d. Frames: each input generates 1–N frames  
+2. Beyond those opinions, ARCEngine handles:
+   a. Creation and rendering of sprites  
+   b. Organization of sprites into levels  
+   c. Organization of levels into a game  
+   d. Sprite-based collisions  
+   e. Main rendering pipeline  
+   f. Sensible default settings  
+
+## Sensible Default Settings
+
+#### Camera Auto-Scaling (Not Overridable)
+
+The camera automatically scales up to fill as much of the 64×64 area as possible. You can only control this by setting the camera’s `width` and `height`. Examples:
+
+* `32×32` – Upscaled by 2×, fits perfectly into 64×64  
+* `30×30` – Upscaled by 2×, adds a 2-pixel letterbox around the screen  
+* `30×15` – Upscaled by 2×, adds 2-pixel borders on the sides and 17-pixel borders on top and bottom  
+* `15×15` – Upscaled by 4×, adds a 2-pixel letterbox around the screen  
+
+#### `self.next_level()` Behavior (Overridable)
+
+By default, calling `self.next_level()` will:
+
+* Increment `_current_level_index` by 1 on `frame + 1` (the frame after `self.next_level()` is called)  
+* Increment `_score` by 1  
+* Call `self.win()` if that was the last level  
+
+You can override this entire method if you need custom behavior.
+
+#### `RESET` Action (Overridable)
+
+By default, a `RESET` action will:
+
+* Restart the current level (via `level_reset()`) if any actions have been taken  
+* Otherwise, perform a full game reset (via `full_reset()`)  
+
+Both `level_reset()` and `full_reset()` can be overridden with custom logic.
+
+## Main Game and Render Loops
+
+#### Main Game Loop
+
+The main game loop is fixed. In pseudocode:
+
+```pseudocode
+handle RESET action
+if game is won or lost:
+  return []
+
+frames = []
+
+while action is not complete:
+  STEP()          ── game logic
+  frames.append(RENDER())
+
+return frames
+```
+
+#### Main Render Loop
+
+1. Render all sprites visible to the camera at the camera’s resolution
+   a. Uses the camera’s x and y properties
+2. Upscale the raw render from step 1 and add letterboxing
+3. Render the 64×64 UI on top
+   a. UI always spans 0,0 to 63,63
+
+## Example Games
+
+[Simple Maze](https://github.com/arcprize/ARCEngine/blob/main/examples/simple_maze.py) - Dead simple game that really only uses Engine Logic (Pixel Perfect Collision).
+[Merge](https://github.com/arcprize/ARCEngine/blob/main/examples/merge.py) - Another Dead simple game that shows off Pixel Perfect Collision and Sprite Merging.
+[Complex Maze](https://github.com/arcprize/ARCEngine/blob/main/examples/complex_maze.py) - Added Mechanics onto Simple Maze and demonstrates `ToggleableUserDisplay`
+[Merge/Detatch](https://github.com/arcprize/ARCEngine/blob/main/examples/merge_detach.py) - Adds in the ability to detatch merged sprites and demonstrates writing a custom `RenderableUserDisplay`

proteus/arc_grid/arcengine/__init__.py

@@ -0,0 +1,31 @@
+"""
+ARCEngine - A Python library for 2D sprite-based game development
+"""
+
+from .base_game import ARCBaseGame
+from .camera import Camera
+from .enums import MAX_REASONING_BYTES, ActionInput, BlockingMode, ComplexAction, FrameData, FrameDataRaw, GameAction, GameState, InteractionMode, PlaceableArea, SimpleAction
+from .interfaces import RenderableUserDisplay, ToggleableUserDisplay
+from .level import Level
+from .sprites import Sprite
+
+__version__ = "0.1.0"
+__all__ = [
+    "Sprite",
+    "BlockingMode",
+    "InteractionMode",
+    "PlaceableArea",
+    "Camera",
+    "Level",
+    "GameAction",
+    "GameState",
+    "SimpleAction",
+    "ComplexAction",
+    "FrameData",
+    "FrameDataRaw",
+    "ARCBaseGame",
+    "ActionInput",
+    "RenderableUserDisplay",
+    "ToggleableUserDisplay",
+    "MAX_REASONING_BYTES",
+]

proteus/arc_grid/arcengine/base_game.py

@@ -0,0 +1,593 @@
+"""
+Module for the base game class in ARCEngine.
+"""
+
+import os
+from abc import ABC
+from typing import List, Optional, final
+
+import numpy as np
+from numpy import ndarray
+
+from .camera import Camera
+from .enums import ActionInput, FrameData, FrameDataRaw, GameAction, GameState
+from .level import Level
+from .sprites import Sprite
+
+MAX_FRAME_PER_ACTION: int = 1000
+
+
+class ARCBaseGame(ABC):
+    """Base class for ARCEngine games that manages levels and camera.
+
+    This is a base class that games should inherit from. and extend with game logic.
+    It handles the game loop and rendering.
+
+    Custom game logic should be implemented in the step() method.
+    """
+
+    _game_id: str
+    _levels: list[Level]
+    _clean_levels: list[Level]
+    _current_level_index: int
+    _camera: Camera
+    _debug: bool
+    _action: ActionInput
+    _action_complete: bool
+    _action_count: int
+    _state: GameState
+    _score: int
+    _next_level: bool
+    _full_reset: bool
+    _win_score: int
+    _available_actions: list[int]
+    _placeable_sprite: Optional[Sprite]
+    _seed: int
+
+    def __init__(
+        self,
+        game_id: str,
+        levels: List[Level],
+        camera: Optional[Camera] = None,
+        debug: bool = False,
+        win_score: int = 1,
+        available_actions: list[int] = [1, 2, 3, 4, 5, 6],
+        seed: int = 0,
+    ) -> None:
+        """Initialize a new game.
+
+        Args:
+            levels: List of levels to initialize the game with. Each level will be cloned.
+            camera: Optional camera to use. If not provided, a default 64x64 camera will be created.
+
+        Raises:
+            ValueError: If levels list is empty
+        """
+        if not levels:
+            raise ValueError("Game must have at least one level")
+
+        # Game ID should be set by subclasses
+        self._game_id = game_id
+
+        # Clone each level to prevent external modification
+        self._levels = [level.clone() for level in levels]
+        self._clean_levels = [level.clone() for level in levels]
+        self._current_level_index = 0
+
+        # Debug mode
+        self._debug = debug
+
+        # Camera
+        # Use provided camera or create default
+        self._camera = camera if camera is not None else Camera()
+
+        # Game state
+        self._state = GameState.NOT_PLAYED
+        self._score = 0
+        self._next_level = False
+        self._action = ActionInput()
+        self._action_complete = False
+        self._action_count = 0
+        self._full_reset = False
+        self._win_score = win_score if win_score > 1 else len(levels)
+        self.set_level(0)
+        self._available_actions = available_actions
+        self._placeable_sprite = None
+        self._seed = seed
+
+    def debug(self, message: str) -> None:
+        """Debug mode.
+
+        Args:
+            message: The message to print
+        """
+        if self._debug:
+            print(message)
+
+    @property
+    @final
+    def current_level(self) -> Level:
+        """Get the current level.
+
+        Returns:
+            Level: The current level
+        """
+        return self._levels[self._current_level_index]
+
+    @property
+    @final
+    def camera(self) -> Camera:
+        """Get the game's camera.
+
+        Returns:
+            Camera: The game's camera
+        """
+        return self._camera
+
+    @property
+    @final
+    def game_id(self) -> str:
+        """Get the game's ID.
+
+        Returns:
+            str: The game's ID
+        """
+        return self._game_id
+
+    @property
+    @final
+    def win_score(self) -> int:
+        """Get the game's max score.
+
+        Returns:
+            int: The game's max score
+        """
+        return self._win_score
+
+    @final
+    def set_level(self, index: int) -> None:
+        """Set the current level by index.
+
+        Args:
+            index: The index of the level to set as current
+
+        Raises:
+            IndexError: If index is out of range
+        """
+        if not 0 <= index < len(self._levels):
+            raise IndexError(f"Level index {index} out of range [0, {len(self._levels)})")
+        self._current_level_index = index
+        self._action_count = 0
+        level = self.current_level
+        if level.grid_size:
+            self.camera.resize(level.grid_size[0], level.grid_size[1])
+        self.on_set_level(level)
+
+    def set_level_by_name(self, name: str) -> None:
+        """Set the current level by name.
+
+        Args:
+            name: The name of the level to set as current
+        """
+        for index, level in enumerate(self._levels):
+            if level.name == name:
+                self.set_level(index)
+                return
+        raise ValueError(f"Level with name {name} not found")
+
+    @property
+    @final
+    def level_index(self) -> int:
+        """Get the current level index.
+
+        Returns:
+            int: The current level index
+        """
+        return self._current_level_index
+
+    @final
+    def perform_action(self, action_input: ActionInput, raw: bool = False) -> FrameData | FrameDataRaw:
+        """Perform an action and return the resulting frame data.
+
+        DO NOT OVERRIDE THIS METHOD, Your Game Logic should be in step()
+
+        The base implementation:
+        1. While the action is not complete, call step() and render frames
+        2. Returns a FrameData object with the current state
+
+        Args:
+            action_input: The action to perform
+
+        Returns:
+            FrameData: The resulting frame data
+        """
+        self._full_reset = False
+        if action_input.id == GameAction.RESET:
+            self.handle_reset()
+        elif self._state == GameState.GAME_OVER or self._state == GameState.WIN:
+            return FrameData(
+                game_id=self._game_id,
+                frame=[],
+                state=self._state,
+                score=self._score,
+                win_score=self._win_score,
+                action_input=action_input,
+                available_actions=self._available_actions,
+            )
+
+        self._set_action(action_input)
+
+        frame_list: list[ndarray | list[list[int]]] = []
+
+        count = 0
+
+        while not self.is_action_complete():
+            if count > MAX_FRAME_PER_ACTION:
+                raise ValueError("Action took too many frames")
+            count += 1
+            if self._next_level:
+                self._really_set_next_level()
+            else:
+                self.step()
+            frame = self.camera.render(self.current_level.get_sprites())
+            if raw:
+                frame_list.append(frame)
+            else:
+                frame_list.append(frame.tolist())
+
+        # Create and return FrameData
+        if raw:
+            frame_raw = FrameDataRaw()
+            frame_raw.game_id = self._game_id
+            frame_raw.frame = frame_list
+            frame_raw.state = self._state
+            frame_raw.levels_completed = self._score
+            frame_raw.win_levels = self._win_score
+            frame_raw.action_input = action_input
+            frame_raw.full_reset = self._full_reset
+            frame_raw.available_actions = self._available_actions
+            return frame_raw
+
+        return FrameData(
+            game_id=self._game_id,
+            frame=frame_list,
+            state=self._state,
+            levels_completed=self._score,
+            win_levels=self._win_score,
+            action_input=action_input,
+            full_reset=self._full_reset,
+            available_actions=self._available_actions,
+        )
+
+    @property
+    @final
+    def action(self) -> ActionInput:
+        """Get the current action."""
+        return self._action
+
+    @final
+    def _set_action(self, action_input: ActionInput) -> None:
+        """Set the action to perform.
+
+        Args:
+            action_input: The action to perform
+        """
+        self._state = GameState.NOT_FINISHED
+        self._action = action_input
+        self._action_complete = False
+        if action_input.id != GameAction.RESET:
+            self._action_count += 1
+
+    @final
+    def complete_action(self) -> None:
+        """Complete the action. Call this when the provided action is fully resolved"""
+        self._action_complete = True
+
+    @final
+    def is_action_complete(self) -> bool:
+        """Check if the action is complete.
+
+        Returns:
+            bool: True if the action is complete, False otherwise
+        """
+        return not self._next_level and self._action_complete
+
+    @final
+    def win(self) -> None:
+        """Call this when the player has beaten the game."""
+        self._state = GameState.WIN
+
+    @final
+    def lose(self) -> None:
+        """Call this when the player has losses the game."""
+        self._state = GameState.GAME_OVER
+
+    def handle_reset(self) -> None:
+        """Handle the reset of the game.
+
+        If the action count is 0, perform a full reset.
+        Otherwise, perform a level reset.
+        """
+        if os.getenv("ONLY_RESET_LEVELS") == "true" and self._state != GameState.WIN:
+            self.level_reset()
+        elif self._action_count == 0 or self._state == GameState.WIN:
+            self.full_reset()
+        else:
+            self.level_reset()
+
+    def full_reset(self) -> None:
+        self._levels = [level.clone() for level in self._clean_levels]
+        self._score = 0
+        self._action_count = 0
+        self._full_reset = True
+        self.set_level(0)
+        self._state = GameState.NOT_FINISHED
+
+    def level_reset(self) -> None:
+        self._levels[self._current_level_index] = self._clean_levels[self._current_level_index].clone()
+        self.set_level(self._current_level_index)
+        self._state = GameState.NOT_FINISHED
+
+    def step(self) -> None:
+        """Step the game.  This is where your game logic should be implemented.
+
+        REQUIRED: Call complete_action() when the action is complete.
+          It does not need to be called every step, but once the action is complete.
+          The engine will keep calling step and rendering frames until the action is complete.
+        """
+
+        self.complete_action()
+
+    def try_move(self, sprite_name: str, dx: int, dy: int) -> List[Sprite]:
+        """Try to move a sprite and return a list of sprites it collides with.
+
+        This method attempts to move the sprite by the given deltas and checks for collisions.
+        If any collisions are detected, the sprite is not moved and the method returns a list
+        of sprite names that were collided with.
+
+        Args:
+            sprite_name: The name of the sprite to move.
+            dx: The change in x position (positive = right, negative = left).
+            dy: The change in y position (positive = down, negative = up).
+
+        Returns:
+            A list of sprite names that the sprite collided with. If no collisions occurred,
+            the sprite is moved and an empty list is returned.
+
+        Raises:
+            ValueError: If no sprite with the given name is found.
+        """
+        # Get the sprite to move
+        sprites = self.current_level.get_sprites_by_name(sprite_name)
+        if not sprites:
+            raise ValueError(f"No sprite found with name: {sprite_name}")
+        return self.try_move_sprite(sprites[0], dx, dy)  # Use the first sprite with this name
+
+    def try_move_sprite(self, sprite: Sprite, dx: int, dy: int) -> List[Sprite]:
+        """Try to move a sprite and return a list of sprites it collides with.
+
+        This method attempts to move the sprite by the given deltas and checks for collisions.
+        If any collisions are detected, the sprite is not moved and the method returns a list
+        of sprite names that were collided with.
+
+        Args:
+            sprite_name: The name of the sprite to move.
+            dx: The change in x position (positive = right, negative = left).
+            dy: The change in y position (positive = down, negative = up).
+
+        Returns:
+            A list of sprite names that the sprite collided with. If no collisions occurred,
+            the sprite is moved and an empty list is returned.
+
+        Raises:
+            ValueError: If no sprite with the given name is found.
+        """  # Get the sprite to move
+        # Store original position
+        original_x = sprite.x
+        original_y = sprite.y
+
+        # Try the move
+        sprite.move(dx, dy)
+
+        # Check for collisions with all other sprites
+        collisions = []
+        for other in self.current_level.get_sprites():
+            if sprite.collides_with(other):
+                collisions.append(other)
+
+        # If there were collisions, revert the move
+        if collisions:
+            sprite.set_position(original_x, original_y)
+
+        return collisions
+
+    def is_last_level(self) -> bool:
+        """Check if the current level is the last level.
+
+        Returns:
+            bool: True if the current level is the last level, False otherwise
+        """
+        return self._current_level_index == len(self._levels) - 1
+
+    def next_level(self) -> None:
+        """Move to the next level."""
+        self._score += 1
+        if not self.is_last_level():
+            self._next_level = True
+        else:
+            self.win()
+
+    def _really_set_next_level(self) -> None:
+        self.set_level(self._current_level_index + 1)
+        self._next_level = False
+
+    def on_set_level(self, level: Level) -> None:
+        """Called when the level is set, use this to set level specific data."""
+        pass
+
+    def get_pixels_at_sprite(self, sprite: Sprite) -> ndarray:
+        """Get the camera pixels at a sprite.
+
+        Args:
+            sprite: The sprite to get the pixels at
+
+        Returns:
+            list[list[int]]: The camera returned pixels at the sprite
+        """
+        return self.get_pixels(sprite.x - self.camera.x, sprite.y - self.camera.y, sprite.width, sprite.height)
+
+    def get_pixels(self, x: int, y: int, width: int, height: int) -> ndarray:
+        """Get the camera pixels at a given position.
+
+        Args:
+            x: The x position to get the pixels at
+            y: The y position to get the pixels at
+            width: The width of the area to get the pixels at
+            height: The height of the area to get the pixels at
+
+        Returns:
+            list[list[int]]: The camera returned pixels at the given position and width/height
+        """
+
+        frame = self.camera._raw_render(self.current_level.get_sprites())
+        return frame[y : y + height, x : x + width]
+
+    def set_placeable_sprite(self, sprite: Sprite | None) -> None:
+        """Set the placeable sprite.
+
+        Args:
+            sprite: The sprite to set as placeable
+        """
+        self._placeable_sprite = sprite
+
+    def _get_graph_location(self) -> tuple[float, float, float] | None:
+        """Get the location for the graph builder to use for this state.
+
+        Returns:
+            tuple[float, float, float] | None: The location this state should report as its location in the graph,
+                or None if the graph builder should calculate the location.
+        """
+        return None
+
+    def _get_hidden_state(self) -> ndarray:
+        """Get the hidden state for the graph builder to use for this state.
+
+        Returns:
+            ndarray: Hidden state for the graph builder to use for this state.
+        """
+        return np.zeros((4, 4), dtype=np.int8)
+
+    def _get_valid_actions(self) -> list[ActionInput]:
+        """Get the valid actions for the current game state.
+
+        Note: This method is for internal use only, the data here is never exposed
+        via the API or to Users/Agents.
+
+        Returns:
+            list[int]: The valid actions for the current game state
+        """
+        valid_actions: list[ActionInput] = []
+
+        for action in self._available_actions:
+            match action:
+                case 1 | 2 | 3 | 4 | 5:
+                    valid_actions.append(ActionInput(id=GameAction.from_id(action)))
+                case 6:
+                    if self._placeable_sprite:
+                        valid_actions.extend(self._get_valid_placeble_actions())
+                    else:
+                        valid_actions.extend(self._get_valid_clickable_actions())
+
+        return valid_actions
+
+    def _get_valid_placeble_actions(self) -> list[ActionInput]:
+        """Get valid placeable actions from placeable areas.
+
+        Returns:
+            list[ActionInput]: List of valid placeable actions with screen coordinates
+        """
+
+        scale, x_offset, y_offset = self.camera._calculate_scale_and_offset()
+
+        valid_actions: list[ActionInput] = []
+
+        for area in self.current_level.placeable_areas:
+            for y in range(area.y, area.y + area.height, area.y_scale):
+                for x in range(area.x, area.x + area.width, area.x_scale):
+                    action_input = ActionInput(id=GameAction.ACTION6.value, data={"x": x * scale + x_offset, "y": y * scale + y_offset})
+                    valid_actions.append(action_input)
+
+        return valid_actions
+
+    def _get_valid_clickable_actions(self) -> list[ActionInput]:
+        """Get valid clickable actions from sprites with the 'sys_click' tag.
+
+        This method finds all sprites tagged with 'sys_click' and generates clickable actions
+        based on their pixel data and the presence of the 'sys_every_pixel' tag.
+
+        Returns:
+            list[ActionInput]: List of valid clickable actions with screen coordinates
+        """
+        valid_actions: list[ActionInput] = []
+
+        # Get all sprites with the 'sys_click' tag
+        clickable_sprites = self.current_level.get_sprites_by_tag("sys_click")
+        clickable_sprites.extend(self.current_level.get_sprites_by_tag("sys_place"))
+
+        scale, x_offset, y_offset = self.camera._calculate_scale_and_offset()
+
+        for sprite in clickable_sprites:
+            if not self._is_sprite_clickable_now(sprite):
+                continue
+
+            # Check if sprite has the 'sys_every_pixel' tag
+            has_every_pixel = "sys_every_pixel" in sprite._tags
+
+            # Get the rendered sprite pixels (accounts for scale, rotation, etc.)
+            rendered_pixels = sprite.render()
+
+            if has_every_pixel:
+                # Every non-negative pixel is a valid action
+                for y in range(rendered_pixels.shape[0]):
+                    for x in range(rendered_pixels.shape[1]):
+                        if rendered_pixels[y, x] >= 0:
+                            # Convert sprite-relative coordinates to screen coordinates
+                            screen_x = (sprite._x + x) * scale + x_offset
+                            screen_y = (sprite._y + y) * scale + y_offset
+
+                            # Create ActionInput with ACTION6 (ComplexAction) and coordinates
+                            action_input = ActionInput(id=GameAction.ACTION6.value, data={"x": screen_x, "y": screen_y})
+                            valid_actions.append(action_input)
+            else:
+                # Find any single non-negative pixel to represent the entire sprite
+                found_pixel = False
+                for y in range(rendered_pixels.shape[0]):
+                    for x in range(rendered_pixels.shape[1]):
+                        if rendered_pixels[y, x] >= 0:
+                            # Convert sprite-relative coordinates to screen coordinates
+                            screen_x = (sprite._x + x) * scale + x_offset
+                            screen_y = (sprite._y + y) * scale + y_offset
+
+                            # Create ActionInput with ACTION6 (ComplexAction) and coordinates
+                            action_input = ActionInput(id=GameAction.ACTION6.value, data={"x": screen_x, "y": screen_y})
+                            valid_actions.append(action_input)
+                            found_pixel = True
+                            break
+                    if found_pixel:
+                        break
+
+        return valid_actions
+
+    def _is_sprite_clickable_now(self, sprite: Sprite) -> bool:
+        """
+        Check if a sprite is clickable now.  This method is designed to be overridden by games
+        that have more complex clickable logic. (e.g. not all sprites flagged with 'sys_click'
+        are clickable at all times)
+
+        Args:
+            sprite: The sprite to check
+
+        Returns:
+            bool: True if the sprite is clickable now, False otherwise
+        """
+        return True

proteus/arc_grid/arcengine/camera.py

@@ -0,0 +1,350 @@
+"""
+Module for camera-related functionality in the ARCEngine.
+"""
+
+from typing import List, Tuple
+
+import numpy as np
+
+from .interfaces import RenderableUserDisplay
+from .sprites import Sprite
+
+
+class Camera:
+    """A camera that defines the viewport into the game world."""
+
+    # Maximum allowed dimensions
+    MAX_DIMENSION = 64
+
+    _x: int
+    _y: int
+    _width: int
+    _height: int
+    _background: int
+    _letter_box: int
+    _interfaces: list[RenderableUserDisplay]
+
+    def __init__(
+        self,
+        x: int = 0,
+        y: int = 0,
+        width: int = 64,
+        height: int = 64,
+        background: int = 5,
+        letter_box: int = 5,
+        interfaces: list[RenderableUserDisplay] = [],
+    ):
+        """Initialize a new Camera.
+
+        Args:
+            x: X coordinate in pixels (default: 0)
+            y: Y coordinate in pixels (default: 0)
+            width: Viewport width in pixels (default: 64, max: 64)
+            height: Viewport height in pixels (default: 64, max: 64)
+            background: Background color index (default: 5 - Black)
+            letter_box: Letter box color index (default: 5 - Black)
+            interfaces: Optional list of renderable interfaces to initialize with
+
+        Raises:
+            ValueError: If width or height exceed 64 pixels
+        """
+        if width > 64 or height > 64 or width < 0 or height < 0:
+            raise ValueError("Camera dimensions cannot exceed 64x64 pixels and must be positive")
+
+        self._x = x
+        self._y = y
+        self.width = width
+        self.height = height
+        self._background = background
+        self._letter_box = letter_box
+        self._interfaces: List[RenderableUserDisplay] = []
+
+        if interfaces:
+            for interface in interfaces:
+                self._interfaces.append(interface)
+
+    @property
+    def x(self) -> int:
+        """Get the camera's x position.
+
+        Returns:
+            int: The camera's x position
+        """
+        return self._x
+
+    @x.setter
+    def x(self, value: int) -> None:
+        """Set the camera's x position.
+
+        Args:
+            value: The new x position
+        """
+        self._x = int(value)
+
+    @property
+    def y(self) -> int:
+        """Get the camera's y position.
+
+        Returns:
+            int: The camera's y position
+        """
+        return self._y
+
+    @y.setter
+    def y(self, value: int) -> None:
+        """Set the camera's y position.
+
+        Args:
+            value: The new y position
+        """
+        self._y = int(value)
+
+    @property
+    def width(self) -> int:
+        """Get the camera's width.
+
+        Returns:
+            int: The camera's width
+        """
+        return self._width
+
+    @width.setter
+    def width(self, value: int) -> None:
+        """Set the camera's width.
+
+        Args:
+            value: The new width
+
+        Raises:
+            ValueError: If width exceeds MAX_DIMENSION
+        """
+        width_int = int(value)
+        if width_int > self.MAX_DIMENSION:
+            raise ValueError(f"Width cannot exceed {self.MAX_DIMENSION} pixels")
+        self._width = width_int
+
+    @property
+    def height(self) -> int:
+        """Get the camera's height.
+
+        Returns:
+            int: The camera's height
+        """
+        return self._height
+
+    @height.setter
+    def height(self, value: int) -> None:
+        """Set the camera's height.
+
+        Args:
+            value: The new height
+
+        Raises:
+            ValueError: If height exceeds MAX_DIMENSION
+        """
+        height_int = int(value)
+        if height_int > self.MAX_DIMENSION:
+            raise ValueError(f"Height cannot exceed {self.MAX_DIMENSION} pixels")
+        self._height = height_int
+
+    @property
+    def background(self) -> int:
+        """Get the camera's background color."""
+        return self._background
+
+    @background.setter
+    def background(self, value: int) -> None:
+        """Set the camera's background color."""
+        self._background = value
+
+    @property
+    def letter_box(self) -> int:
+        """Get the camera's letter box color."""
+        return self._letter_box
+
+    @letter_box.setter
+    def letter_box(self, value: int) -> None:
+        """Set the camera's letter box color."""
+        self._letter_box = value
+
+    def resize(self, width: int, height: int) -> None:
+        """Resize the camera.
+
+        Args:
+            width: The new width
+            height: The new height
+        """
+        self.width = width
+        self.height = height
+
+    def move(self, dx: int, dy: int) -> None:
+        """Move the camera by the specified delta.
+
+        Args:
+            dx: The change in x position
+            dy: The change in y position
+        """
+        self._x += int(dx)
+        self._y += int(dy)
+
+    def _calculate_scale_and_offset(self) -> Tuple[int, int, int]:
+        """Calculate the scale factor and offsets for letterboxing.
+
+        Returns:
+            Tuple[int, int, int]: (scale, x_offset, y_offset)
+            - scale: The uniform scale factor to fit viewport in 64x64
+            - x_offset: Horizontal offset for centering
+            - y_offset: Vertical offset for centering
+        """
+        # Calculate maximum possible scale that fits in MAX_DIMENSION
+        scale_x = self.MAX_DIMENSION // self._width
+        scale_y = self.MAX_DIMENSION // self._height
+        scale = min(scale_x, scale_y)
+
+        # Calculate scaled dimensions
+        scaled_width = self._width * scale
+        scaled_height = self._height * scale
+
+        # Only use offsets if we can't scale up to fill the screen
+        x_offset = (self.MAX_DIMENSION - scaled_width) // 2
+        y_offset = (self.MAX_DIMENSION - scaled_height) // 2
+
+        return scale, x_offset, y_offset
+
+    def _raw_render(self, sprites: List[Sprite]) -> np.ndarray:
+        """Internal method to render the camera view.
+
+        Args:
+            sprites: List of sprites to render. Sprites are rendered in order of their layer
+                    value (lower layers first). Negative pixel values are treated as transparent.
+                    Only visible sprites (based on their interaction mode) will be rendered.
+
+        Returns:
+            np.ndarray: The rendered view as a 2D numpy array
+        """
+        # Create background array filled with background color
+        output = np.full((self._height, self._width), self._background, dtype=np.int8)
+
+        if not sprites:
+            return output
+
+        # Sort sprites by layer (lower layers first) and filter out non-visible sprites
+        sorted_sprites = sorted((s for s in sprites if s.is_visible), key=lambda s: s.layer)
+
+        for sprite in sorted_sprites:
+            # Get the sprite's rendered pixels (handles rotation and scaling)
+            sprite_pixels = sprite.render()
+            sprite_height, sprite_width = sprite_pixels.shape
+
+            # Calculate sprite position relative to camera
+            rel_x = sprite.x - self._x
+            rel_y = sprite.y - self._y
+
+            # Calculate the intersection with viewport
+            dest_x_start = max(0, rel_x)
+            dest_x_end = min(self._width, rel_x + sprite_width)
+            dest_y_start = max(0, rel_y)
+            dest_y_end = min(self._height, rel_y + sprite_height)
+
+            # Skip if sprite is completely outside viewport
+            if dest_x_end <= dest_x_start or dest_y_end <= dest_y_start:
+                continue
+
+            # Calculate source region from sprite
+            sprite_x_start = max(0, -rel_x)
+            sprite_x_end = sprite_width - max(0, (rel_x + sprite_width) - self._width)
+            sprite_y_start = max(0, -rel_y)
+            sprite_y_end = sprite_height - max(0, (rel_y + sprite_height) - self._height)
+
+            # Get the sprite region we're going to copy
+            sprite_region = sprite_pixels[sprite_y_start:sprite_y_end, sprite_x_start:sprite_x_end]
+
+            # Create a mask for non-negative (visible) pixels
+            visible_mask = sprite_region >= 0
+
+            # Update only the non-transparent pixels
+            output[dest_y_start:dest_y_end, dest_x_start:dest_x_end][visible_mask] = sprite_region[visible_mask]
+
+        return output
+
+    def render(self, sprites: List[Sprite]) -> np.ndarray:
+        """Render the camera view.
+
+        The rendered output is always 64x64 pixels. If the camera's viewport is smaller,
+        the view will be scaled up uniformly (maintaining aspect ratio) to fit within
+        64x64, and the remaining space will be filled with the letter_box color.
+
+        Args:
+            sprites: List of sprites to render (currently unused)
+
+        Returns:
+            np.ndarray: The rendered view as a 64x64 numpy array
+        """
+        # Start with a letter-boxed canvas
+        output = np.full((self.MAX_DIMENSION, self.MAX_DIMENSION), self._letter_box, dtype=np.int8)
+
+        # Get the raw camera view
+        view = self._raw_render(sprites)
+
+        # Calculate scaling and offsets
+        scale, x_offset, y_offset = self._calculate_scale_and_offset()
+
+        # Scale up the view using numpy's repeat
+        if scale > 1:
+            view = np.repeat(np.repeat(view, scale, axis=0), scale, axis=1)
+
+        # Insert the scaled view into the letter-boxed output
+        output[y_offset : y_offset + view.shape[0], x_offset : x_offset + view.shape[1]] = view
+
+        for interface in self._interfaces:
+            output = interface.render_interface(output)
+
+        return output
+
+    def replace_interface(self, new_interfaces: list[RenderableUserDisplay]) -> None:
+        """Replace the current interfaces with new ones.
+
+        This method replaces all current interfaces with the provided ones. Each interface
+        in the new list will be cloned to prevent external modification.
+
+        Args:
+            new_interfaces: List of new interfaces to use.  These should be cloned before passing them in.
+        """
+        self._interfaces = []
+        if new_interfaces:
+            for interface in new_interfaces:
+                self._interfaces.append(interface)
+
+    def display_to_grid(self, display_x: int, display_y: int) -> tuple[int, int] | None:
+        """Convert display coordinates (64x64) to camera grid coordinates.
+
+        This takes into account:
+        - Camera scaling max(64/camera_width, 64/camera_height)
+        - Letterbox padding
+        - Grid boundaries
+
+        Args:
+            display_x: X coordinate in display space (0-63)
+            display_y: Y coordinate in display space (0-63)
+
+        Returns:
+            tuple[int, int] | None: The corresponding grid coordinates (x, y) or None if the display coordinates are within the letterbox
+        """
+        # Calculate scaling factor
+        scale_x = int(64 / self.width)
+        scale_y = int(64 / self.height)
+        scale = min(scale_x, scale_y)
+
+        # Calculate letterbox padding
+        x_padding = int((64 - (self.width * scale)) / 2)
+        y_padding = int((64 - (self.height * scale)) / 2)
+
+        # Remove padding and scale down
+        grid_x = int((display_x - x_padding) / scale) if display_x - x_padding >= 0 else -1
+        grid_y = int((display_y - y_padding) / scale) if display_y - y_padding >= 0 else -1
+
+        if grid_x < 0 or grid_y < 0 or grid_x >= self.width or grid_y >= self.height:
+            # Given X, Y is off the camera screen
+            return None
+
+        return grid_x + self.x, grid_y + self.y

proteus/arc_grid/arcengine/enums.py

@@ -0,0 +1,191 @@
+"""
+Module containing enums used throughout the ARCEngine.
+"""
+
+from __future__ import annotations
+
+import json
+from enum import Enum, auto
+from typing import Any, List, Optional, Type, Union
+
+from numpy import ndarray
+from pydantic import BaseModel, Field, PrivateAttr, field_validator
+
+MAX_REASONING_BYTES = 16 * 1024  # 16 KB guard-rail
+
+
+class BlockingMode(Enum):
+    """Enum defining different collision detection behaviors for sprites."""
+
+    NOT_BLOCKED = auto()  # No collision detection
+    BOUNDING_BOX = auto()  # Simple rectangular collision detection
+    PIXEL_PERFECT = auto()  # Precise pixel-level collision detection
+
+
+class InteractionMode(Enum):
+    """Enum defining how a sprite interacts with the game world visually and physically."""
+
+    TANGIBLE = auto()  # Visible and can be collided with
+    INTANGIBLE = auto()  # Visible but cannot be collided with (ghost-like)
+    INVISIBLE = auto()  # Not visible but can be collided with (invisible wall)
+    REMOVED = auto()  # Not visible and cannot be collided with (effectively removed)
+
+
+class GameState(str, Enum):
+    NOT_PLAYED = "NOT_PLAYED"
+    NOT_FINISHED = "NOT_FINISHED"
+    WIN = "WIN"
+    GAME_OVER = "GAME_OVER"
+
+
+class SimpleAction(BaseModel):
+    game_id: str = ""
+
+
+class ComplexAction(BaseModel):
+    game_id: str = ""
+    x: int = Field(0, ge=0, le=63)
+    y: int = Field(0, ge=0, le=63)
+
+
+class GameAction(Enum):
+    RESET = (0, SimpleAction)
+    ACTION1 = (1, SimpleAction)
+    ACTION2 = (2, SimpleAction)
+    ACTION3 = (3, SimpleAction)
+    ACTION4 = (4, SimpleAction)
+    ACTION5 = (5, SimpleAction)
+    ACTION6 = (6, ComplexAction)
+    ACTION7 = (7, SimpleAction)
+
+    action_type: Union[Type[SimpleAction], Type[ComplexAction]]
+    action_data: Union[SimpleAction | ComplexAction]
+
+    def __init__(
+        self,
+        action_id: int,
+        action_type: Union[Type[SimpleAction], Type[ComplexAction]],
+    ) -> None:
+        self._value_ = action_id
+        self.action_type = action_type
+        self.action_data = action_type()
+
+    def is_simple(self) -> bool:
+        return self.action_type is SimpleAction
+
+    def is_complex(self) -> bool:
+        return self.action_type is ComplexAction
+
+    def validate_data(self, data: dict[str, Any]) -> bool:
+        """Raise exception on invalid parse of incoming JSON data."""
+        self.action_type.model_validate(data)
+        return True
+
+    def set_data(self, data: dict[str, Any]) -> Union[SimpleAction | ComplexAction]:
+        self.action_data = self.action_type(**data)
+        return self.action_data
+
+    @classmethod
+    def from_id(cls, action_id: int) -> GameAction:
+        for action in cls:
+            if action.value == action_id:
+                return action
+        raise ValueError(f"No GameAction with id {action_id}")
+
+    @classmethod
+    def from_name(cls, name: str) -> "GameAction":
+        try:
+            return cls[name.upper()]
+        except KeyError:
+            raise ValueError(f"No GameAction with name '{name}'")
+
+    @classmethod
+    def all_simple(cls) -> list[GameAction]:
+        return [a for a in cls if a.is_simple()]
+
+    @classmethod
+    def all_complex(cls) -> list[GameAction]:
+        return [a for a in cls if a.is_complex()]
+
+
+class ActionInput(BaseModel):
+    id: GameAction = GameAction.RESET
+    data: dict[str, Any] = {}
+    reasoning: Optional[Any] = Field(default=None, description="Opaque client-supplied blob; stored & echoed back verbatim.")
+
+    # Optional size / serialisability guard
+    @field_validator("reasoning")
+    @classmethod
+    def _check_reasoning(cls, v: Any) -> Any:
+        if v is None:
+            return v  # field omitted → fine
+        try:
+            raw = json.dumps(v, separators=(",", ":")).encode("utf-8")
+        except (TypeError, ValueError):
+            raise ValueError("reasoning must be JSON-serialisable")
+        if len(raw) > MAX_REASONING_BYTES:
+            raise ValueError(f"reasoning exceeds {MAX_REASONING_BYTES} bytes")
+        return v
+
+
+class FrameData(BaseModel):
+    game_id: str = ""
+    frame: list[list[list[int]]] = []
+    state: GameState = GameState.NOT_PLAYED
+    levels_completed: int = Field(0, ge=0, le=254)
+    win_levels: int = Field(0, ge=0, le=254)
+    action_input: ActionInput = Field(default_factory=lambda: ActionInput())
+    guid: Optional[str] = None
+    full_reset: bool = False
+    available_actions: list[int] = []
+
+    def is_empty(self) -> bool:
+        return len(self.frame) == 0
+
+    def __str__(self) -> str:
+        return self.model_dump_json(indent=2)
+
+
+class FrameDataRaw(BaseModel):
+    game_id: str = ""
+    state: GameState = GameState.NOT_PLAYED
+    levels_completed: int = 0
+    win_levels: int = 0
+    action_input: ActionInput = Field(default_factory=ActionInput)
+    guid: Optional[str] = None
+    full_reset: bool = False
+    available_actions: list[int] = Field(default_factory=list)
+
+    # runtime-only, not validated, not serialized
+    _frame: List[ndarray] = PrivateAttr(default_factory=list)
+
+    @property
+    def frame(self) -> List[ndarray]:
+        return self._frame
+
+    @frame.setter
+    def frame(self, value: List[ndarray]) -> None:
+        self._frame = value
+
+    def is_empty(self) -> bool:
+        return len(self._frame) == 0
+
+    def __str__(self) -> str:
+        return self.model_dump_json(indent=2)
+
+
+class PlaceableArea:
+    x: int = 0
+    y: int = 0
+    width: int = 0
+    height: int = 0
+    x_scale: int = 1
+    y_scale: int = 1
+
+    def __init__(self, x: int, y: int, width: int, height: int, x_scale: int = 1, y_scale: int = 1):
+        self.x = x
+        self.y = y
+        self.width = width
+        self.height = height
+        self.x_scale = x_scale
+        self.y_scale = y_scale

proteus/arc_grid/arcengine/interfaces.py

@@ -0,0 +1,275 @@
+"""
+Module for user display interfaces in the ARCEngine.
+"""
+
+from abc import ABC, abstractmethod
+
+import numpy as np
+
+from .enums import InteractionMode
+from .sprites import Sprite
+
+
+class RenderableUserDisplay(ABC):
+    """Abstract base class for UI elements that can be rendered by the camera.
+
+    This class defines the interface for UI elements that can be rendered by the camera.
+    It is used as the final step in the camera's rendering pipeline to produce the 64x64 output frame.
+    """
+
+    @abstractmethod
+    def render_interface(self, frame: np.ndarray) -> np.ndarray:
+        """Render this UI element onto the given frame.
+
+        Args:
+            frame: The 64x64 numpy array to render onto
+        """
+        return frame
+
+    def draw_sprite(self, frame: np.ndarray, sprite: Sprite, start_x: int, start_y: int) -> np.ndarray:
+        sprite_pixels = sprite.render()
+        sprite_height, sprite_width = sprite_pixels.shape
+
+        # Calculate sprite boundaries
+        end_x = start_x + sprite_width
+        end_y = start_y + sprite_height
+
+        # Only render if sprite is at least partially visible
+        if start_x < 64 and start_y < 64 and end_x > 0 and end_y > 0:
+            # Calculate the visible portion of the sprite
+            sprite_start_y = max(0, -start_y)
+            sprite_start_x = max(0, -start_x)
+            sprite_end_y = sprite_height - max(0, end_y - 64)
+            sprite_end_x = sprite_width - max(0, end_x - 64)
+
+            # Calculate frame boundaries
+            frame_start_y = max(0, start_y)
+            frame_start_x = max(0, start_x)
+            frame_end_y = min(64, end_y)
+            frame_end_x = min(64, end_x)
+
+            # Only render non-negative pixels
+            frame[frame_start_y:frame_end_y, frame_start_x:frame_end_x] = np.where(
+                sprite_pixels[sprite_start_y:sprite_end_y, sprite_start_x:sprite_end_x] >= 0,
+                sprite_pixels[sprite_start_y:sprite_end_y, sprite_start_x:sprite_end_x],
+                frame[frame_start_y:frame_end_y, frame_start_x:frame_end_x],
+            )
+        return frame
+
+
+class ToggleableUserDisplay(RenderableUserDisplay):
+    """A UI element that manages a collection of sprite pairs (enabled/disabled states).
+
+    This class provides methods to toggle between enabled and disabled states of sprite pairs,
+    and renders the appropriate sprite based on the current state.
+    """
+
+    _sprite_pairs: list[tuple[Sprite, Sprite]]
+
+    def __init__(self, sprite_pairs: list[tuple[Sprite, Sprite]] = []):
+        """Initialize the toggleable interface with sprite pairs.
+
+        Each sprite pair consists of two sprites:
+        - The first sprite is used when the object is enabled
+        - The second sprite is used when the object is disabled
+
+        Args:
+            sprite_pairs: List of sprite pairs to initialize with. Each pair will be cloned
+                         to prevent external modification. Defaults to an empty list.
+        """
+        self._sprite_pairs: list[tuple[Sprite, Sprite]] = []
+        if sprite_pairs:
+            for sprite_pair in sprite_pairs:
+                self._sprite_pairs.append((sprite_pair[0].clone(), sprite_pair[1].clone()))
+
+    def clone(self) -> "ToggleableUserDisplay":
+        """Create a deep copy of this toggleable interface.
+
+        This method creates a new ToggleableInterface instance with cloned sprite pairs.
+        Each sprite in each pair is cloned, ensuring that the new interface has
+        completely independent sprites from the original.
+
+        Returns:
+            ToggleableInterface: A new instance with cloned sprite pairs
+        """
+        # Create new instance with empty sprite pairs
+        cloned_pairs: list[tuple[Sprite, Sprite]] = []
+
+        # Clone each sprite pair
+        for sprite_pair in self._sprite_pairs:
+            cloned_pairs.append((sprite_pair[0].clone(), sprite_pair[1].clone()))
+
+        return ToggleableUserDisplay(cloned_pairs)
+
+    def is_enabled(self, index: int) -> bool:
+        """Check if a sprite pair is enabled.
+
+        Args:
+            index: The index of the sprite pair to check.
+
+        Returns:
+            bool: True if the pair is enabled, False otherwise.
+
+        Raises:
+            ValueError: If the index is out of bounds.
+        """
+        if index < 0 or index >= len(self._sprite_pairs):
+            raise ValueError(f"Index {index} is out of bounds")
+        return self._sprite_pairs[index][0].interaction != InteractionMode.REMOVED
+
+    def enable(self, index: int) -> None:
+        """Enable the sprite pair at the given index.
+
+        This will make the first sprite in the pair visible and interactive,
+        while making the second sprite invisible and non-interactive.
+
+        Args:
+            index: The index of the sprite pair to enable.
+
+        Raises:
+            ValueError: If the index is out of bounds.
+        """
+        if index < 0 or index >= len(self._sprite_pairs):
+            raise ValueError(f"Index {index} is out of bounds")
+        self._enable_sprite_pair(self._sprite_pairs[index])
+
+    def disable(self, index: int) -> None:
+        """Disable the sprite pair at the given index.
+
+        This will make the first sprite in the pair invisible and non-interactive,
+        while making the second sprite visible and interactive.
+
+        Args:
+            index: The index of the sprite pair to disable.
+
+        Raises:
+            ValueError: If the index is out of bounds.
+        """
+        if index < 0 or index >= len(self._sprite_pairs):
+            raise ValueError(f"Index {index} is out of bounds")
+        self._disable_sprite_pair(self._sprite_pairs[index])
+
+    def enable_all_by_tag(self, tag: str) -> None:
+        """Enable all sprite pairs that have the given tag.
+
+        This will enable all sprite pairs where either sprite in the pair
+        has the specified tag.
+
+        Args:
+            tag: The tag to search for in the sprites.
+        """
+        sprites = self._find_sprites_by_tag(tag)
+        for sprite in sprites:
+            self._enable_sprite_pair(sprite)
+
+    def disabled_all_by_tag(self, tag: str) -> None:
+        """Disable all sprite pairs that have the given tag.
+
+        This will disable all sprite pairs where either sprite in the pair
+        has the specified tag.
+
+        Args:
+            tag: The tag to search for in the sprites.
+        """
+        sprites = self._find_sprites_by_tag(tag)
+        for sprite in sprites:
+            self._disable_sprite_pair(sprite)
+
+    def enable_first_by_tag(self, tag: str) -> bool:
+        """Enable the first disabled sprite pair that has the given tag.
+
+        This will find the first sprite pair with the given tag where the first
+        sprite is currently disabled, and enable it.
+
+        Args:
+            tag: The tag to search for in the sprites.
+
+        Returns:
+            bool: True if a sprite pair was enabled, False if no disabled pairs
+                  with the tag were found.
+        """
+        sprites = self._find_sprites_by_tag(tag)
+        for sprite in sprites:
+            if sprite[0].interaction == InteractionMode.REMOVED:
+                self._enable_sprite_pair(sprite)
+                return True
+        return False
+
+    def disabled_first_by_tag(self, tag: str) -> bool:
+        """Disable the first enabled sprite pair that has the given tag.
+
+        This will find the first sprite pair with the given tag where the first
+        sprite is currently enabled, and disable it.
+
+        Args:
+            tag: The tag to search for in the sprites.
+
+        Returns:
+            bool: True if a sprite pair was disabled, False if no enabled pairs
+                  with the tag were found.
+        """
+        sprites = self._find_sprites_by_tag(tag)
+        for sprite in sprites:
+            if sprite[0].interaction == InteractionMode.INTANGIBLE:
+                self._disable_sprite_pair(sprite)
+                return True
+        return False
+
+    def _find_sprites_by_tag(self, tag: str) -> list[tuple[Sprite, Sprite]]:
+        """Find all sprite pairs that have the given tag.
+
+        Args:
+            tag: The tag to search for in the sprites.
+
+        Returns:
+            list[Sprite]: List of sprite pairs where either sprite has the tag.
+        """
+        return [sprite_pair for sprite_pair in self._sprite_pairs if tag in sprite_pair[0].tags]
+
+    def _enable_sprite_pair(self, sprite_pair: tuple[Sprite, Sprite]) -> None:
+        """Enable a sprite pair by setting appropriate interaction modes.
+
+        This makes the first sprite visible and interactive, while making
+        the second sprite invisible and non-interactive.
+
+        Args:
+            sprite_pair: The pair of sprites to enable.
+        """
+        sprite_pair[0].set_interaction(InteractionMode.INTANGIBLE)
+        sprite_pair[1].set_interaction(InteractionMode.REMOVED)
+
+    def _disable_sprite_pair(self, sprite_pair: tuple[Sprite, Sprite]) -> None:
+        """Disable a sprite pair by setting appropriate interaction modes.
+
+        This makes the first sprite invisible and non-interactive, while making
+        the second sprite visible and interactive.
+
+        Args:
+            sprite_pair: The pair of sprites to disable.
+        """
+        sprite_pair[0].set_interaction(InteractionMode.REMOVED)
+        sprite_pair[1].set_interaction(InteractionMode.INTANGIBLE)
+
+    def render_interface(self, frame: np.ndarray) -> np.ndarray:
+        """Render all visible sprites to the given frame.
+
+        This method renders all sprites that are currently visible (not in REMOVED mode)
+        to the provided frame. The frame is modified in-place and returned.
+
+        Args:
+            frame: A 64x64 numpy array to render the sprites onto.
+
+        Returns:
+            np.ndarray: The modified frame with all visible sprites rendered.
+        """
+        # Get all sprites from pairs
+        all_sprites: list[Sprite] = []
+        for pair in self._sprite_pairs:
+            all_sprites.extend(pair)
+
+        # Render each visible sprite
+        for sprite in all_sprites:
+            if sprite.interaction != InteractionMode.REMOVED:
+                frame = self.draw_sprite(frame, sprite, sprite.x, sprite.y)
+
+        return frame

proteus/arc_grid/arcengine/level.py

@@ -0,0 +1,251 @@
+"""
+Module for level-related functionality in the ARCEngine.
+"""
+
+import copy
+from typing import Any, List, Optional, Tuple
+
+from .enums import BlockingMode, PlaceableArea
+from .sprites import Sprite
+
+
+class Level:
+    """A level that manages a collection of sprites."""
+
+    _sprites: List[Sprite]
+    _sorted_sprites: List[Sprite] | None  # Sorted High to low
+    _grid_size: Tuple[int, int] | None
+    _data: dict[str, Any]
+    _name: str
+    _placeable_areas: List[PlaceableArea]
+    _need_sort: bool
+
+    def __init__(
+        self,
+        sprites: Optional[List[Sprite]] = None,
+        grid_size: Tuple[int, int] | None = None,
+        data: dict[str, Any] = {},
+        name: str = "Level",
+        placeable_areas: Optional[List[PlaceableArea]] = None,
+    ):
+        """Initialize a new level.
+
+        Args:
+            sprites: List of sprites to add to the level
+            grid_size: Tuple of width and height of the grid
+            data: Dictionary of data to store in the level
+            name: Name of the level
+            placeable_areas: List of placeable areas in the level
+        """
+        self._sprites = []
+        self._grid_size = grid_size
+        self._data = data
+        self._name = name
+        self._placeable_areas = placeable_areas if placeable_areas is not None else []
+        self._need_sort = True
+
+        if sprites:
+            # Add first (fast path), then do one-time merge+sort.
+            self._sprites.extend(sprites)
+            self._merge_sys_static_pixel_perfect_on_init()
+
+    def _merge_sys_static_pixel_perfect_on_init(self) -> None:
+        """
+        Merge any sprites that are:
+          - PIXEL_PERFECT
+          - have tag "sys_static"
+        into ONE sprite per layer.
+
+        This runs only during construction.
+        """
+        if not self._sprites:
+            return
+
+        # Partition sprites into merge-candidates (by layer) and others.
+        by_layer: dict[int, List[Sprite]] = {}
+        others: List[Sprite] = []
+
+        for s in self._sprites:
+            if s.blocking == BlockingMode.PIXEL_PERFECT and "sys_static" in s.tags:
+                by_layer.setdefault(s.layer, []).append(s)
+            else:
+                others.append(s)
+
+        merged: List[Sprite] = []
+        for layer, group in by_layer.items():
+            if not group:
+                continue
+            if len(group) == 1:
+                merged.append(group[0])
+                continue
+
+            # Merge left-to-right; merge() returns a NEW Sprite each time.
+            base = group[0]
+            for nxt in group[1:]:
+                base = base.merge(nxt)
+
+            # Ensure the merged sprite stays on this layer.
+            # (merge() uses max layer, but all are same layer anyway; set explicitly for safety.)
+            base.set_layer(layer)
+
+            # Ensure sys_static remains (merge unions tags, so it should already be present)
+            if "sys_static" not in base.tags:
+                base.tags.append("sys_static")
+
+            merged.append(base)
+
+        self._sprites = others + merged
+
+    def remove_all_sprites(self) -> None:
+        """Remove all sprites from the level."""
+        self._sprites = []
+
+    def add_sprite(self, sprite: Sprite) -> None:
+        """Add a sprite to the level.
+
+        Args:
+            sprite: The sprite to add
+        """
+        self._sprites.append(sprite)
+        self._need_sort = True
+
+    def remove_sprite(self, sprite: Sprite) -> None:
+        """Remove a sprite from the level.
+
+        Args:
+            sprite: The sprite to remove
+        """
+        if sprite in self._sprites:
+            self._sprites.remove(sprite)
+
+    def get_sprites(self) -> List[Sprite]:
+        """Get all sprites in the level.
+
+        Returns:
+            List[Sprite]: All sprites in the level
+        """
+        return self._sprites.copy()  # Return copy to prevent external modification
+
+    def get_sprites_by_name(self, name: str) -> List[Sprite]:
+        """Get all sprites with the given name.
+
+        Args:
+            name: The name to search for
+
+        Returns:
+            List[Sprite]: All sprites with the given name
+        """
+        return [s for s in self._sprites if s.name == name]
+
+    def get_sprites_by_tag(self, tag: str) -> List[Sprite]:
+        """Get all sprites that have the given tag.
+
+        Args:
+            tag: The tag to search for
+
+        Returns:
+            List[Sprite]: All sprites that have the given tag
+        """
+        return [s for s in self._sprites if tag in s.tags]
+
+    def get_sprites_by_tags(self, tags: List[str]) -> List[Sprite]:
+        """Get all sprites that have all of the given tags.
+
+        Args:
+            tags: The tags to search for
+
+        Returns:
+            List[Sprite]: All sprites that have all of the given tags
+        """
+        if not tags:
+            return []
+        return [s for s in self._sprites if all(tag in s.tags for tag in tags)]
+
+    def get_sprites_by_any_tag(self, tags: List[str]) -> List[Sprite]:
+        """Get all sprites that have any of the specified tags.
+
+        Args:
+            tags: List of tags to search for
+
+        Returns:
+            List[Sprite]: List of sprites that have any of the specified tags
+        """
+        return [sprite for sprite in self._sprites if any(tag in sprite.tags for tag in tags)]
+
+    def get_all_tags(self) -> set[str]:
+        """Get all unique tags from all sprites in the level.
+
+        This method collects all tags from all sprites and returns them as a set,
+        ensuring each tag appears only once in the result.
+
+        Returns:
+            set[str]: A set containing all unique tags from all sprites
+        """
+        all_tags = set()
+        for sprite in self._sprites:
+            all_tags.update(sprite.tags)
+        return all_tags
+
+    def get_sprite_at(self, x: int, y: int, tag: Optional[str] = None, ignore_collidable: bool = False) -> Sprite | None:
+        """Get the sprite at the given coordinates.
+
+        This method returns the first sprite that is at the given coordinates.
+        If a tag is provided, it will return the first sprite that has the given tag.
+
+        Args:
+            x: The x coordinate
+            y: The y coordinate
+            tag: The tag to search for
+        """
+        if self._need_sort or self._sorted_sprites is None or len(self._sorted_sprites) != len(self._sprites):
+            self._sorted_sprites = sorted(self._sprites, key=lambda sprite: sprite.layer, reverse=True)
+            self._need_sort = False
+        for sprite in self._sorted_sprites:
+            if (ignore_collidable or sprite.is_collidable) and x >= sprite.x and y >= sprite.y and x < sprite.x + sprite.width and y < sprite.y + sprite.height:
+                if sprite.blocking == BlockingMode.PIXEL_PERFECT:
+                    pixels = sprite.render()
+                    if pixels[y - sprite.y][x - sprite.x] == -1:
+                        continue
+                if tag is None or tag in sprite.tags:
+                    return sprite
+        return None
+
+    def collides_with(self, sprite: Sprite, ignoreMode: bool = False) -> List[Sprite]:
+        """Checks all sprites in the level for collisions with the given sprite.
+
+        Args:
+            sprite: The sprite to check for collisions
+        """
+        return [s for s in self._sprites if sprite.collides_with(other=s, ignoreMode=ignoreMode)]
+
+    @property
+    def name(self) -> str:
+        """Get the name of the level."""
+        return self._name
+
+    def get_data(self, key: str) -> Any:
+        return self._data.get(key)
+
+    @property
+    def grid_size(self) -> Tuple[int, int] | None:
+        """Get the grid size of the level.
+
+        Returns:
+            Tuple[int, int]: The grid size of the level
+        """
+        return self._grid_size
+
+    @property
+    def placeable_areas(self) -> List[PlaceableArea]:
+        """Get the placeable areas of the level."""
+        return self._placeable_areas
+
+    def clone(self) -> "Level":
+        """Create a deep copy of this level.
+
+        Returns:
+            Level: A new Level instance with cloned sprites
+        """
+        # Clone each sprite and create new level
+        cloned_sprites = [sprite.clone() for sprite in self._sprites]
+        return Level(name=self._name, sprites=cloned_sprites, grid_size=self._grid_size, data=copy.deepcopy(self._data), placeable_areas=self._placeable_areas)

proteus/arc_grid/arcengine/sprites.py

@@ -0,0 +1,651 @@
+"""
+Module for sprite-related classes and functionality in the ARCEngine.
+"""
+
+import uuid
+from typing import List, Optional
+
+import numpy as np
+from numpy import ndarray
+
+from .enums import BlockingMode, InteractionMode
+
+
+def _downscale_mode(arr: np.ndarray, factor: int) -> np.ndarray:
+    """
+    Nearest-neighbor style down-scaling for palette images.
+    For each non-overlapping block it keeps the dominant color
+    (mode), breaking ties by the highest palette index.
+    Transparent pixels (-1) are ignored, but if all pixels are
+    transparent, the block remains transparent.
+
+    Parameters
+    ----------
+    arr : 2-D np.ndarray
+        Input image of dtype int8 / uint8 holding palette indices.
+        Transparency is denoted by -1.
+    factor : int
+        The integer scale factor (e.g. 2 turns 64×64 → 32×32).
+
+    Returns
+    -------
+    np.ndarray
+        The down-scaled image, same dtype as the input.
+    """
+    H, W = arr.shape
+    if H % factor != 0 or W % factor != 0:
+        raise ValueError(f"Array dimensions ({H}, {W}) must be divisible by scale factor {factor}")
+
+    # Step 1: split into blocks → shape (out_h, out_w, factor, factor)
+    blocks = arr.reshape(H // factor, factor, -1, factor).swapaxes(1, 2)
+    blocks = blocks.reshape(-1, factor * factor)
+
+    # Step 2: find dominant color for each block
+    out = np.empty(len(blocks), dtype=arr.dtype)
+
+    for i, blk in enumerate(blocks):
+        non_transparent = blk[blk != -1]
+        transparent = blk[blk < 0]
+        # Check to see if this is majority transparent
+        if transparent.size > non_transparent.size:
+            out[i] = -1  # if all values are -1, keep block transparent
+        else:
+            cnts = np.bincount(non_transparent.astype(np.int16))
+            max_count = cnts.max()
+            max_indices = np.where(cnts == max_count)[0]
+            out[i] = max_indices[-1]  # break ties by highest index
+
+    # Step 3: reshape to 2-D image
+    return out.reshape(H // factor, W // factor)
+
+
+def _interaction_mode_from(visible: bool, collidable: bool) -> InteractionMode:
+    if visible and collidable:
+        return InteractionMode.TANGIBLE
+    elif visible and not collidable:
+        return InteractionMode.INTANGIBLE
+    elif not visible and collidable:
+        return InteractionMode.INVISIBLE
+    else:
+        return InteractionMode.REMOVED
+
+
+class Sprite:
+    """A 2D sprite that can be positioned and scaled in the game world."""
+
+    # Valid rotation values in degrees (clockwise)
+    VALID_ROTATIONS = {0, 90, 180, 270}
+
+    pixels: ndarray
+    _name: str
+    _x: int
+    _y: int
+    _layer: int
+    _rotation: int
+    _mirror_ud: bool
+    _mirror_lr: bool
+    _scale: int  # Use set_scale to validate scale factor
+    _blocking: BlockingMode
+    _interaction: InteractionMode
+    _tags: list[str]
+
+    def __init__(
+        self,
+        pixels: List[List[int]] | np.ndarray,
+        name: Optional[str] = None,
+        x: int = 0,
+        y: int = 0,
+        layer: int = 0,
+        scale: int = 1,
+        rotation: int = 0,
+        mirror_ud: bool = False,
+        mirror_lr: bool = False,
+        blocking: BlockingMode = BlockingMode.PIXEL_PERFECT,
+        interaction: InteractionMode | None = None,
+        visible: bool = True,
+        collidable: bool = True,
+        tags: list[str] = [],
+    ):
+        """Initialize a new Sprite.
+
+        Args:
+            pixels: 2D list representing the sprite's pixels
+            name: Sprite name (default: None, will generate UUID)
+            x: X coordinate in pixels (default: 0)
+            y: Y coordinate in pixels (default: 0)
+            layer: Z-order layer for rendering (default: 0, higher values render on top)
+            scale: Scale factor (default: 1)
+            rotation: Rotation in degrees (default: 0)
+            blocking: Collision detection method (default: NOT_BLOCKED)
+            interaction: How the sprite interacts with the game world (default: TANGIBLE)
+
+        Raises:
+            ValueError: If scale is 0, pixels is not a 2D list, rotation is invalid,
+                       or if downscaling factor doesn't evenly divide sprite dimensions
+        """
+        if isinstance(pixels, np.ndarray):
+            if pixels.ndim != 2:
+                raise ValueError("Pixels must be a 2D array 111")
+            if pixels.dtype != np.int8:
+                base = pixels.astype(np.int8, copy=False)
+            else:
+                base = pixels
+        else:
+            if not isinstance(pixels, list) or not all(isinstance(row, list) for row in pixels):
+                raise ValueError("Pixels must be a 2D list or a 2D numpy array")
+            base = np.array(pixels, dtype=np.int8)
+
+        self.pixels = base
+        if self.pixels.ndim != 2:
+            raise ValueError("Pixels must be a 2D array 222")
+
+        self._name = name if name is not None else str(uuid.uuid4())
+        self._x = int(x)
+        self._y = int(y)
+        self._layer = int(layer)
+        self._set_rotation(rotation)
+        self._mirror_ud = mirror_ud
+        self._mirror_lr = mirror_lr
+        self._blocking = blocking
+        self.set_scale(scale)  # Use set_scale to validate scale factor
+        if interaction is None:
+            self._interaction = _interaction_mode_from(visible, collidable)
+        else:
+            self._interaction = interaction
+        self._tags = tags
+
+    def clone(self, new_name: Optional[str] = None) -> "Sprite":
+        """Create an independent copy of this sprite.
+
+        Args:
+            new_name: Optional name for the cloned sprite. If None, reuses current name.
+
+        Returns:
+            A new Sprite instance with the same properties but independent state.
+        """
+        # Create a deep copy of the pixels array
+        pixels_copy = self.pixels.copy()
+
+        # Create a new sprite with copied properties
+        return Sprite(
+            pixels=pixels_copy.tolist(),  # Convert back to list for constructor
+            name=new_name if new_name is not None else self._name,  # Use new name or generate new UUID
+            x=self._x,
+            y=self._y,
+            scale=self._scale,
+            rotation=self.rotation,  # Use the public property to get normalized value
+            mirror_ud=self._mirror_ud,
+            mirror_lr=self._mirror_lr,
+            blocking=self._blocking,
+            layer=self._layer,
+            interaction=self._interaction,
+            tags=self._tags.copy(),  # Copy the tags list
+        )
+
+    def _set_rotation(self, rotation: int) -> None:
+        """Internal method to set rotation with validation.
+
+        Args:
+            rotation: The rotation value in degrees
+
+        Raises:
+            ValueError: If rotation is not a valid 90-degree increment
+        """
+        normalized = rotation % 360
+        if normalized not in self.VALID_ROTATIONS:
+            raise ValueError(f"Rotation must be one of {self.VALID_ROTATIONS}, got {rotation}")
+        self.rotation = normalized
+
+    def set_rotation(self, rotation: int) -> "Sprite":
+        """Set the sprite's rotation to a specific value.
+
+        Args:
+            rotation: The new rotation in degrees (must be 0, 90, 180, or 270)
+
+        Raises:
+            ValueError: If rotation is not a valid 90-degree increment
+        """
+        self._set_rotation(int(rotation))
+        return self
+
+    def rotate(self, delta: int) -> "Sprite":
+        """Rotate the sprite by a given amount.
+
+        Args:
+            delta: The change in rotation in degrees (must result in a valid rotation)
+
+        Raises:
+            ValueError: If resulting rotation is not a valid 90-degree increment
+        """
+        if delta < 0:
+            delta = 360 + (delta % 360)
+        new_rotation = (self.rotation + delta) % 360
+        self._set_rotation(new_rotation)
+        return self
+
+    def set_position(self, x: int, y: int) -> "Sprite":
+        """Set the sprite's position.
+
+        Args:
+            x: New X coordinate in pixels
+            y: New Y coordinate in pixels
+        """
+        self._x = int(x)
+        self._y = int(y)
+        return self
+
+    def set_scale(self, scale: int) -> "Sprite":
+        """Set the sprite's scale factor.
+
+        Args:
+            scale: The new scale factor. Positive values scale up, negative values scale down.
+                  Negative values indicate divisor: -1 means half size (divide by 2), -2 means one-third size, etc.
+
+        Raises:
+            ValueError: If scale is 0 or if downscaling factor doesn't evenly divide sprite dimensions
+        """
+        scale_int = int(scale)
+        if scale_int == 0:
+            raise ValueError("Scale cannot be zero")
+
+        # For downscaling, validate dimensions are divisible by scale factor
+        if scale_int < 0:
+            H, W = self.pixels.shape
+            factor = -scale_int + 1  # -1 -> 2, -2 -> 3, -3 -> 4, etc.
+            if H % factor != 0 or W % factor != 0:
+                raise ValueError(f"Array dimensions ({H}, {W}) must be divisible by scale factor {factor}")
+
+        self._scale = scale_int
+        return self
+
+    def adjust_scale(self, delta: int) -> None:
+        """Adjust the sprite's scale by a delta value, moving one step at a time.
+
+        The method will adjust the scale by incrementing or decrementing by 1
+        repeatedly until reaching the target scale. This ensures smooth transitions
+        and validates each step.
+
+        Negative scales indicate downscaling factors:
+        -1 = half size (1/2)
+        -2 = one-third size (1/3)
+        -3 = one-fourth size (1/4)
+        etc.
+
+        For example:
+        - Current scale 1, delta +2 -> Steps through: 1 -> 2 -> 3
+        - Current scale 1, delta -2 -> Steps through: 1 -> 0 -> -1 (half size)
+        - Current scale -2, delta +3 -> Steps through: -2 -> -1 -> 0 -> 1
+
+        Args:
+            delta: The total change in scale to apply. Positive values increase scale,
+                  negative values decrease it.
+
+        Raises:
+            ValueError: If any intermediate scale would be 0 or if a downscaling factor
+                       doesn't evenly divide sprite dimensions
+        """
+        if delta == 0:
+            return
+
+        # Determine direction of change
+        step = 1 if delta > 0 else -1
+        target_scale = self._scale + delta
+
+        # Take steps one at a time
+        while self._scale != target_scale:
+            next_scale = self._scale + step
+
+            # Skip over zero since it's invalid
+            if next_scale == 0:
+                next_scale = step
+
+            # Let ValueError propagate up
+            self.set_scale(next_scale)
+
+    def set_blocking(self, blocking: BlockingMode) -> "Sprite":
+        """Set the sprite's blocking behavior.
+
+        Args:
+            blocking: The new blocking behavior
+        """
+        if not isinstance(blocking, BlockingMode):
+            raise ValueError("blocking must be a BlockingMode enum value")
+        self._blocking = blocking
+        return self
+
+    def set_name(self, name: str) -> "Sprite":
+        """Set the sprite's name.
+
+        Args:
+            name: New name for the sprite
+        """
+        if not name:
+            raise ValueError("Name cannot be empty")
+        self._name = name
+        return self
+
+    @property
+    def name(self) -> str:
+        """Get the sprite's name."""
+        return self._name
+
+    @property
+    def x(self) -> int:
+        """Get the current X coordinate."""
+        return self._x
+
+    @property
+    def y(self) -> int:
+        """Get the current Y coordinate."""
+        return self._y
+
+    @property
+    def scale(self) -> int:
+        """Get the current scale factor."""
+        return self._scale
+
+    @property
+    def blocking(self) -> BlockingMode:
+        """Get the current blocking behavior."""
+        return self._blocking
+
+    @property
+    def layer(self) -> int:
+        """Get the current rendering layer."""
+        return self._layer
+
+    @property
+    def tags(self) -> list[str]:
+        """Get the current tags."""
+        return self._tags
+
+    @property
+    def mirror_ud(self) -> bool:
+        """Get the current mirror up/down state."""
+        return self._mirror_ud
+
+    @property
+    def mirror_lr(self) -> bool:
+        """Get the current mirror left/right state."""
+        return self._mirror_lr
+
+    def set_mirror_ud(self, mirror_ud: bool) -> "Sprite":
+        """Set the sprite's mirror up/down state."""
+        self._mirror_ud = mirror_ud
+        return self
+
+    def set_mirror_lr(self, mirror_lr: bool) -> "Sprite":
+        """Set the sprite's mirror left/right state."""
+        self._mirror_lr = mirror_lr
+        return self
+
+    def set_layer(self, layer: int) -> "Sprite":
+        """Set the sprite's rendering layer.
+
+        Args:
+            layer: New layer value. Higher values render on top.
+        """
+        self._layer = int(layer)
+        return self
+
+    @property
+    def interaction(self) -> InteractionMode:
+        """Get the current interaction mode."""
+        return self._interaction
+
+    def set_interaction(self, interaction: InteractionMode) -> "Sprite":
+        """Set the sprite's interaction mode.
+
+        Args:
+            interaction: The new interaction mode
+
+        Raises:
+            ValueError: If interaction is not an InteractionMode enum value
+        """
+        if not isinstance(interaction, InteractionMode):
+            raise ValueError("interaction must be an InteractionMode enum value")
+        self._interaction = interaction
+        return self
+
+    @property
+    def is_visible(self) -> bool:
+        """Check if a sprite with this interaction mode should be rendered.
+
+        Returns:
+            bool: True if the sprite should be visible, False otherwise
+        """
+        return self._interaction == InteractionMode.TANGIBLE or self._interaction == InteractionMode.INTANGIBLE
+
+    def set_visible(self, visible: bool) -> "Sprite":
+        """Set the sprite's visibility.
+
+        Args:
+            visible: The new visibility state
+        """
+        self._interaction = _interaction_mode_from(visible, self.is_collidable)
+        return self
+
+    @property
+    def width(self) -> int:
+        """Get the sprite's width."""
+        return int(self.render().shape[1])
+
+    @property
+    def height(self) -> int:
+        """Get the sprite's height."""
+        return int(self.render().shape[0])
+
+    @property
+    def is_collidable(self) -> bool:
+        """Check if a sprite with this interaction mode should participate in collisions.
+
+        Returns:
+            bool: True if the sprite should be checked for collisions, False otherwise
+        """
+        return self._interaction == InteractionMode.TANGIBLE or self._interaction == InteractionMode.INVISIBLE
+
+    def set_collidable(self, collidable: bool) -> "Sprite":
+        """Set the sprite's collidable state.
+
+        Args:
+            collidable: The new collidable state
+        """
+        self._interaction = _interaction_mode_from(self.is_visible, collidable)
+        return self
+
+    def render(self) -> np.ndarray:
+        """Render the sprite with current scale and rotation.
+
+        Returns:
+            np.ndarray: The rendered sprite as a 2D numpy array
+        """
+        # Start with the base pixels
+        result = self.pixels.copy()
+
+        # Handle rotation first (if any)
+        if self.rotation != 0:
+            # Convert degrees to number of 90-degree rotations (clockwise)
+            k = int((-self.rotation % 360) / 90)  # Negative for clockwise rotation
+            if k != 0:
+                result = np.rot90(result, k=k)
+
+        if self._mirror_ud:
+            result = np.flipud(result)
+        if self._mirror_lr:
+            result = np.fliplr(result)
+
+        # Handle scaling
+        if self._scale != 1:
+            if self._scale > 1:
+                # For upscaling, repeat the array in both dimensions
+                result = np.repeat(np.repeat(result, self._scale, axis=0), self._scale, axis=1)
+            else:  # self._scale < 0
+                # For downscaling, use mode-based approach
+                # Convert negative scale to actual divisor (e.g. -1 -> 2, -2 -> 3)
+                factor = -self._scale + 1  # -1 -> 2, -2 -> 3, -3 -> 4, etc.
+                result = _downscale_mode(result, factor)
+
+        return result
+
+    def collides_with(self, other: "Sprite", ignoreMode: bool = False) -> bool:
+        """Check if this sprite collides with another sprite.
+
+        The collision check follows these rules:
+        1. A sprite cannot collide with itself
+        2. Non-collidable sprites (based on interaction mode) never collide
+        3. For collidable sprites, the collision detection method is based on their blocking mode:
+           - NOT_BLOCKED: Always returns False
+           - BOUNDING_BOX: Simple rectangular collision check
+           - PIXEL_PERFECT: Precise pixel-level collision detection
+
+        Args:
+            other: The other sprite to check collision with
+
+        Returns:
+            bool: True if the sprites collide, False otherwise
+        """
+        # Rule 1: A sprite cannot collide with itself
+        if self is other:
+            return False
+
+        if not ignoreMode:
+            # Rule 2: Both sprites must be collidable
+            if not (self.is_collidable and other.is_collidable):
+                return False
+
+            # Rule 3: Handle different blocking modes
+            if self._blocking == BlockingMode.NOT_BLOCKED or other._blocking == BlockingMode.NOT_BLOCKED:
+                return False
+
+        # Get sprite dimensions after rendering (accounts for rotation and scaling)
+        self_pixels = self.render()
+        other_pixels = other.render()
+        self_height, self_width = self_pixels.shape
+        other_height, other_width = other_pixels.shape
+
+        # First check bounding box collision
+        # If there's no bounding box collision, there can't be pixel collision
+        if self._x >= other._x + other_width or self._x + self_width <= other._x or self._y >= other._y + other_height or self._y + self_height <= other._y:
+            return False
+
+        # If either sprite uses PIXEL_PERFECT, do pixel-level collision detection
+        if self._blocking == BlockingMode.PIXEL_PERFECT or other._blocking == BlockingMode.PIXEL_PERFECT:
+            # Calculate intersection region
+            x_min = max(self._x, other._x)
+            x_max = min(self._x + self_width, other._x + other_width)
+            y_min = max(self._y, other._y)
+            y_max = min(self._y + self_height, other._y + other_height)
+
+            # Get the overlapping regions from both sprites
+            self_x_start = x_min - self._x
+            self_x_end = x_max - self._x
+            self_y_start = y_min - self._y
+            self_y_end = y_max - self._y
+
+            other_x_start = x_min - other._x
+            other_x_end = x_max - other._x
+            other_y_start = y_min - other._y
+            other_y_end = y_max - other._y
+
+            # Extract overlapping regions
+            self_region = self_pixels[self_y_start:self_y_end, self_x_start:self_x_end]
+            other_region = other_pixels[other_y_start:other_y_end, other_x_start:other_x_end]
+
+            # Check if any non-transparent pixels overlap
+            self_mask = self_region != -1
+            other_mask = other_region != -1
+            return bool(np.any(self_mask & other_mask))
+
+        # Otherwise, we already know there's a bounding box collision
+        return True
+
+    def move(self, dx: int, dy: int) -> None:
+        """Move the sprite by the given deltas.
+
+        Args:
+            dx: Change in x position (positive = right, negative = left)
+            dy: Change in y position (positive = down, negative = up)
+        """
+        self._x += int(dx)
+        self._y += int(dy)
+
+    def color_remap(self, old_color: int | None, new_color: int) -> "Sprite":
+        """Remap the sprite's color.
+
+        Args:
+            old_color: The old color to remap, or None to remap all colors
+            new_color: The new color to remap to
+        """
+        if old_color is None:
+            # Replace all non-negative pixels with new_color
+            self.pixels = np.where(self.pixels >= 0, new_color, self.pixels)
+        else:
+            # Replace only pixels matching old_color
+            self.pixels = np.where(self.pixels == old_color, new_color, self.pixels)
+        return self
+
+    def merge(self, other: "Sprite") -> "Sprite":
+        """Merge two sprites together.
+
+        This method creates a new sprite that combines the pixels of both sprites.
+        When pixels overlap, non-negative pixels take precedence over negative ones.
+
+        Args:
+            other: The other sprite to merge with
+
+        Returns:
+            Sprite: A new sprite containing the merged pixels
+        """
+        # Get rendered versions of both sprites to handle scaling/rotation
+        self_pixels = self.render()
+        other_pixels = other.render()
+
+        # Calculate the bounds of the merged sprite
+        min_x = min(self._x, other._x)
+        min_y = min(self._y, other._y)
+        max_x = max(self._x + self_pixels.shape[1], other._x + other_pixels.shape[1])
+        max_y = max(self._y + self_pixels.shape[0], other._y + other_pixels.shape[0])
+
+        # Create a new array for the merged sprite
+        merged_height = max_y - min_y
+        merged_width = max_x - min_x
+        merged_pixels = np.full((merged_height, merged_width), -1, dtype=np.int8)
+
+        # Copy other's pixels, keeping non-negative pixels
+        other_y_start = other._y - min_y
+        other_x_start = other._x - min_x
+        other_region = merged_pixels[other_y_start : other_y_start + other_pixels.shape[0], other_x_start : other_x_start + other_pixels.shape[1]]
+        merged_pixels[other_y_start : other_y_start + other_pixels.shape[0], other_x_start : other_x_start + other_pixels.shape[1]] = np.where(other_pixels != -1, other_pixels, other_region)
+
+        # Copy self's pixels
+        self_y_start = self._y - min_y
+        self_x_start = self._x - min_x
+        merged_pixels[self_y_start : self_y_start + self_pixels.shape[0], self_x_start : self_x_start + self_pixels.shape[1]] = np.where(
+            self_pixels != -1, self_pixels, merged_pixels[self_y_start : self_y_start + self_pixels.shape[0], self_x_start : self_x_start + self_pixels.shape[1]]
+        )
+
+        blocking = self._blocking
+        if blocking == BlockingMode.NOT_BLOCKED:
+            blocking = other._blocking
+        elif blocking == BlockingMode.BOUNDING_BOX and other._blocking == BlockingMode.PIXEL_PERFECT:
+            blocking = BlockingMode.PIXEL_PERFECT
+
+        interaction = self._interaction
+        if interaction == InteractionMode.REMOVED:
+            interaction = other._interaction
+        elif interaction == InteractionMode.INVISIBLE and other._interaction == InteractionMode.TANGIBLE:
+            interaction = InteractionMode.TANGIBLE
+        elif interaction == InteractionMode.INTANGIBLE and other._interaction == InteractionMode.TANGIBLE:
+            interaction = InteractionMode.TANGIBLE
+
+        # Create and return new sprite
+        return Sprite(
+            name=self._name,
+            pixels=merged_pixels,
+            x=min_x,
+            y=min_y,
+            layer=max(self._layer, other._layer),  # Use higher layer
+            blocking=blocking,
+            interaction=interaction,
+            tags=list(set(self._tags + other._tags)),  # Combine unique tags
+        )

proteus/arc_grid/rendering.py

@@ -0,0 +1,301 @@
+"""Rendering utilities for ARC-AGI-3 grids (64x64, 16-color palette).
+
+Vendored from the ARC-AGI toolkit (`arc_agi/rendering.py`) and decoupled to
+sit alongside the vendored ``arcengine`` engine in this folder. The core
+``frame_to_rgb_array(frame)`` works on a plain 64x64 numpy array, so the
+renderer can be used without the engine; ``FrameDataRaw`` is only needed by
+the animation convenience functions.
+"""
+
+import sys
+import time
+from typing import Any, Optional, Tuple
+
+try:
+    import matplotlib.animation as animation
+    import matplotlib.pyplot as plt
+
+    HAS_MATPLOTLIB = True
+except ImportError:
+    plt = None
+    animation = None
+    HAS_MATPLOTLIB = False
+
+from .arcengine import FrameDataRaw
+from numpy import ndarray
+
+# Color mapping for frame values (0-15)
+COLOR_MAP: dict[int, str] = {
+    0: "#FFFFFFFF",  # White
+    1: "#CCCCCCFF",  # Off-white
+    2: "#999999FF",  # neutral Light
+    3: "#666666FF",  # neutral
+    4: "#333333FF",  # Off Black
+    5: "#000000FF",  # Black
+    6: "#E53AA3FF",  # Magenta
+    7: "#FF7BCCFF",  # Magenta Light
+    8: "#F93C31FF",  # Red
+    9: "#1E93FFFF",  # Blue
+    10: "#88D8F1FF",  # Blue Light
+    11: "#FFDC00FF",  # Yellow
+    12: "#FF851BFF",  # Orange
+    13: "#921231FF",  # Maroon
+    14: "#4FCC30FF",  # Green
+    15: "#A356D6FF",  # Purple
+}
+
+
+def hex_to_rgb(hex_color: str) -> tuple[int, int, int]:
+    """Convert hex color string to RGB tuple.
+
+    Args:
+        hex_color: Hex color string (e.g., "#FFFFFFFF").
+
+    Returns:
+        RGB tuple (r, g, b).
+    """
+    # Remove '#' and convert to int
+    hex_color = hex_color.lstrip("#")
+    # Parse RGBA hex (8 chars) or RGB hex (6 chars)
+    if len(hex_color) == 8:
+        r = int(hex_color[0:2], 16)
+        g = int(hex_color[2:4], 16)
+        b = int(hex_color[4:6], 16)
+        # Alpha is ignored for display
+    else:
+        r = int(hex_color[0:2], 16)
+        g = int(hex_color[2:4], 16)
+        b = int(hex_color[4:6], 16)
+    return (r, g, b)
+
+
+def frame_to_rgb_array(
+    steps: int,
+    frame: ndarray,
+    scale: int = 4,
+    color_map: Optional[dict[int, str]] = None,
+) -> ndarray:
+    """Convert a frame to an RGB numpy array for matplotlib.
+
+    Args:
+        frame: 2D numpy array (64x64) with values 0-15.
+        scale: Upscaling factor (default 4, so 64x64 -> 256x256).
+        color_map: Optional color mapping dict. Uses default if None.
+
+    Returns:
+        3D numpy array (height, width, 3) with RGB values.
+    """
+    import numpy as np
+
+    if color_map is None:
+        color_map = COLOR_MAP
+
+    height, width = frame.shape
+    upscaled_height = height * scale
+    upscaled_width = width * scale
+
+    # Create RGB array
+    rgb_array = np.zeros((upscaled_height, upscaled_width, 3), dtype=np.uint8)
+
+    # Fill pixels
+    for y in range(height):
+        for x in range(width):
+            value = int(frame[y, x])
+            hex_color = color_map.get(value, "#000000FF")
+            rgb = hex_to_rgb(hex_color)
+
+            # Fill the scaled block
+            for dy in range(scale):
+                for dx in range(scale):
+                    rgb_array[y * scale + dy, x * scale + dx] = rgb
+
+    return rgb_array
+
+
+def render_frames(
+    steps: int,
+    frame_data: FrameDataRaw,
+    default_fps: Optional[int] = None,
+    scale: int = 4,
+    color_map: Optional[dict[int, str]] = None,
+) -> None:
+    """Render multiple frames with optional FPS control using matplotlib.
+
+    Args:
+        frame_data: FrameDataRaw object containing frame data and other information.
+        default_fps: Optional FPS for frame timing. If None, displays immediately.
+        scale: Upscaling factor (default 4, so 64x64 -> 256x256).
+        color_map: Optional color mapping dict. Uses default if None.
+    """
+    if not HAS_MATPLOTLIB or plt is None or animation is None:
+        raise ImportError(
+            "matplotlib is required for rendering. Install with: pip install matplotlib"
+        )
+
+    frames = frame_data.frame
+    if not frames:
+        return
+
+    # Convert frames to RGB arrays
+    frame_images = [
+        frame_to_rgb_array(steps, frame, scale, color_map) for frame in frames
+    ]
+
+    # Calculate interval between frames if FPS is specified
+    interval = (1000.0 / default_fps) if default_fps and default_fps > 0 else 100
+
+    # Create figure and axis
+    fig, ax = plt.subplots(figsize=(8, 8))
+    ax.axis("off")
+    ax.set_title("ARC-AGI-3 Environment")
+
+    # Display first frame
+    im = ax.imshow(frame_images[0], interpolation="nearest")
+    plt.tight_layout()
+
+    def update_frame(frame_num: int) -> Tuple[Any, ...]:
+        """Update the displayed frame."""
+        if frame_num < len(frame_images):
+            im.set_array(frame_images[frame_num])
+            return (im,)
+        return (im,)
+
+    # Create animation that plays automatically
+    # Keep reference to prevent garbage collection
+    anim = animation.FuncAnimation(
+        fig,
+        update_frame,
+        frames=len(frame_images),
+        interval=interval,
+        blit=False,
+        repeat=False,
+    )
+
+    # Show the plot - animation will play automatically
+    # Use non-blocking mode so frames play and code continues
+    plt.ion()  # Turn on interactive mode
+    plt.show(block=False)
+
+    # Wait for animation to complete (frames * interval + small buffer)
+    if interval > 0:
+        total_time = len(frame_images) * interval / 1000.0
+    else:
+        total_time = len(frame_images) * 0.1  # Default 100ms per frame
+
+    # Small initial pause to ensure window appears and animation starts
+    time.sleep(0.1)
+
+    # Use plt.pause to process events and let animation play
+    # This ensures the animation actually renders
+    plt.pause(total_time + 0.1)
+
+    # Keep animation reference alive until we're done
+    # Close the figure after animation completes
+    plt.close(fig)
+    plt.ioff()  # Turn off interactive mode
+
+    # Explicitly delete animation after closing to avoid warnings
+    del anim
+
+
+def rgb_to_ansi(rgb: tuple[int, int, int]) -> str:
+    """Convert RGB tuple to ANSI color code.
+
+    Args:
+        rgb: RGB tuple (r, g, b).
+
+    Returns:
+        ANSI escape sequence for the color.
+    """
+    r, g, b = rgb
+    return f"\033[38;2;{r};{g};{b}m"
+
+
+def render_frames_terminal(
+    steps: int,
+    frame_data: FrameDataRaw,
+    default_fps: Optional[int] = None,
+    scale: int = 1,
+    color_map: Optional[dict[int, str]] = None,
+    skip_deplay: bool = False,
+) -> None:
+    """Render frames in the terminal using ANSI color codes, overwriting in place.
+
+    Args:
+        frame_data: FrameDataRaw object containing frame data and other information.
+        default_fps: Optional FPS for frame timing. If None, displays immediately.
+        scale: Scaling factor (default 1, terminal uses 2 chars per pixel for better visibility).
+        color_map: Optional color mapping dict. Uses default if None.
+    """
+    frames = frame_data.frame
+    if not frames:
+        return
+
+    if color_map is None:
+        color_map = COLOR_MAP
+
+    # Check if terminal supports colors
+    if not sys.stdout.isatty():
+        print(
+            "Warning: Not a terminal, colors may not display correctly", file=sys.stderr
+        )
+
+    # Calculate delay between frames (default 5 FPS if not specified)
+    fps = default_fps if default_fps and default_fps > 0 else 5
+    delay = 1.0 / fps
+
+    # ANSI codes
+    RESET = "\033[0m"
+    HOME = "\033[H"  # Move cursor to home position (top-left)
+    HIDE_CURSOR = "\033[?25l"  # Hide cursor
+    SHOW_CURSOR = "\033[?25h"  # Show cursor
+    # Use block character for better visibility (2 chars wide)
+    BLOCK = "██"
+
+    # Get frame dimensions
+    height, width = frames[0].shape
+
+    # Build frame strings for all frames (as single strings to reduce flicker)
+    frame_strings = []
+    for frame_idx, frame in enumerate(frames):
+        # Build entire frame as one string
+        frame_str = f"Step: {steps} - State: {frame_data.state.name}\n\n"
+
+        # Frame content - build all lines first, then join
+        frame_lines = []
+        for y in range(height):
+            line_parts = []
+            for x in range(width):
+                value = int(frame[y, x])
+                hex_color = color_map.get(value, "#000000FF")
+                rgb = hex_to_rgb(hex_color)
+                ansi_color = rgb_to_ansi(rgb)
+                # Use block character (2 chars) for better visibility
+                line_parts.append(f"{ansi_color}{BLOCK}{RESET}")
+            frame_lines.append("".join(line_parts))
+
+        frame_str += "\n".join(frame_lines)
+        frame_strings.append(frame_str)
+
+    # Hide cursor to reduce flicker
+    print(HIDE_CURSOR, end="", flush=True)
+
+    try:
+        # First frame: clear screen and display in single operation to reduce flicker
+        print(f"{HOME}\033[2J{frame_strings[0]}", end="", flush=True)
+
+        # Update frames in place - single operation per frame to minimize flicker
+        for frame_idx in range(1, len(frames)):
+            # Single operation: move home + print new frame (no separate operations)
+            print(f"{HOME}{frame_strings[frame_idx]}", end="", flush=True)
+            # Sleep for 1/fps seconds between frames
+            if not skip_deplay:
+                time.sleep(delay)
+    finally:
+        # Always show cursor again
+        print(SHOW_CURSOR, end="", flush=True)
+
+    # Reset terminal colors and move cursor below the frame
+    print(f"\n{RESET}", end="", flush=True)
+    if not skip_deplay:
+        time.sleep(delay)

tests/test_arc_grid_vendored.py

@@ -0,0 +1,14 @@
+def test_arc_grid_engine_surface_importable():
+    from proteus.arc_grid import Sprite, Level, Camera, ARCBaseGame, GameAction
+    sprite = Sprite(pixels=[[1]], name="x", x=0, y=0)
+    assert sprite.x == 0 and sprite.y == 0
+
+
+def test_arc_grid_has_no_squid_game_imports():
+    import pathlib
+    root = pathlib.Path("proteus/arc_grid")
+    offenders = [
+        p for p in root.rglob("*.py")
+        if "squid_game" in p.read_text(encoding="utf-8")
+    ]
+    assert offenders == [], f"vendored arc_grid must not import squid_game: {offenders}"