← MCP Security Catalog

Phaser Editor MCP Server 1.0.6

npm · @phaserjs/editor-mcp-server · latest release

Verified with no proven findings
Security result
57
Observed tools
31
Version rating
100
Change risk

Independent inventory

Observed 2026-08-14T15:52:07.895Z using mcpSecurity-inventory. Protocol 2025-06-18.

ToolCategoryRisk
assets-get-available-animationsGet all available sprite animations in the project.
Input schema
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {}
}
——
assets-get-available-asset-packsGet all available asset packs in the project. An asset pack is a collection of assets, like images, audio files, and other resources that can be used in the game. The asset pack contains information like the key of the assets, the url to the file, and other parameters.
Input schema
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {}
}
——
assets-get-available-bitmapfontsGet all available bitmap fonts in the project.
Input schema
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {}
}
——
assets-get-available-spine-atlasesGet the all the Spine atlases in the project.
Input schema
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {}
}
——
assets-get-available-spine-skeletonsGet the all the Spine skeletons in the project. It only returns the key of the skeleton.
Input schema
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {}
}
——
assets-get-available-texturesGet all available textures in the project. It includes the name of the texture and the size.
Input schema
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {}
}
——
assets-get-available-tilemapsSearch for the available Tiled tilemap files in the asset packs and return the list of tilemap keys. A Tiled tilemap file contains the data of a tilemap. It is used by the scene editor to create the Tilemap and TilemapLayer objects. These maps are created by the third party tool Tiled. Like the other assets in the asset packs, Phaser Editor uses the tilemap key to identify the tilemap.
Input schema
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {}
}
——
assets-get-bitmapfont-imageGet the PNG image/texture of the given bitmap font.
Input schema
{
  "type": "object",
  "properties": {
    "key": {
      "type": "string",
      "description": "The key of the bitmap font."
    }
  },
  "required": [
    "key"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
——
assets-get-spine-skeleton-infoGet the skeleton info (animations and skins) of the given Spine skeleton key. To build the info of a skeleton it requires also the Spine atlas key. The user can select a different atlas key, but it is common that the user also define a 'preview' atlas key for each skeleton. You can use it if it exists or ask for a different atlas key to the user.
Input schema
{
  "type": "object",
  "properties": {
    "dataKey": {
      "type": "string",
      "description": "The key of the spine data (skeleton) asset."
    },
    "atlasKey": {
      "type": "string",
      "description": "The key of the spine atlas asset."
    }
  },
  "required": [
    "dataKey",
    "atlasKey"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
——
assets-get-spine-skin-imageGet the PNG image of the given Spine skin. You can use this tool to get a better understanding of the appearance of a Spine skeleton with a given skin. The image may be scaled or not. You can the skeleton data to get more info about the size of a skeleton.
Input schema
{
  "type": "object",
  "properties": {
    "dataKey": {
      "type": "string",
      "description": "The key of the spine data (skeleton) asset."
    },
    "atlasKey": {
      "type": "string",
      "description": "The key of the spine atlas asset."
    },
    "skinName": {
      "type": "string",
      "description": "The name of the skin to use. A skeleton can have multiple skins."
    },
    "animationName": {
      "type": "string",
      "description": "The name of the animation to use. A skeleton can have multiple animations."
    }
  },
  "required": [
    "dataKey",
    "atlasKey",
    "skinName",
    "animationName"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
——
assets-get-spritesheet-imageGet the PNG image/texture of the given spritesheet. You can use this tool to get a better understanding of the position of tiles/frames.
Input schema
{
  "type": "object",
  "properties": {
    "key": {
      "type": "string",
      "description": "The key of the bitmap font."
    }
  },
  "required": [
    "key"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
——
assets-get-texture-binaryGet the size of the texture. If you need to get the real size of the object inside the texture (without the transparent margin), then you can use the `assets-get-texture-content-bounding-box` tool.
Input schema
{
  "type": "object",
  "properties": {
    "texture": {
      "type": "object",
      "properties": {
        "key": {
          "type": "string",
          "description": "The key of the texture."
        },
        "frame": {
          "description": "Texture frame for atlases or sprite-sheets (string for atlas, number for sprite-sheet). Omit if using a simple image"
        }
      },
      "additionalProperties": false,
      "description": "The texture of the game object."
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
——
assets-get-texture-content-bounding-boxGet the bounding box of the content of the given texture. Many textures has transparent padding but we need the exact offset and size of the content/object of the texture to place them in the right positions in the scene. Like when placing different objects one next to the other, with touching edges. If you need to know the size of the whole image, use the `assets-get-texture-size` tool.
Input schema
{
  "type": "object",
  "properties": {
    "texture": {
      "type": "object",
      "properties": {
        "key": {
          "type": "string",
          "description": "The key of the texture."
        },
        "frame": {
          "description": "Texture frame for atlases or sprite-sheets (string for atlas, number for sprite-sheet). Omit if using a simple image"
        }
      },
      "additionalProperties": false,
      "description": "The texture of the game object."
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
——
assets-get-texture-sizeGet the binary data of a texture.
Input schema
{
  "type": "object",
  "properties": {
    "texture": {
      "type": "object",
      "properties": {
        "key": {
          "type": "string",
          "description": "The key of the texture."
        },
        "frame": {
          "description": "Texture frame for atlases or sprite-sheets (string for atlas, number for sprite-sheet). Omit if using a simple image"
        }
      },
      "additionalProperties": false,
      "description": "The texture of the game object."
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
——
assets-get-tilemap-dataGet the data of a Tiled tilemap file. It returns the data of the tilemap, including the layers, tilesets, and objects. The data is used by the scene editor to create the Tilemap and TilemapLayer objects.
Input schema
{
  "type": "object",
  "properties": {
    "key": {
      "type": "string",
      "description": "The key of the file in the asset pack. The key is used by the scene editor to create Tilemap objects."
    }
  },
  "required": [
    "key"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
——
get-system-instructionsGet the system instructions. This is fully required for the LLM to know how to build the arguments of this MCP server tools. Tools like `scene-add-game-objects`, `scene-update-game-objects`, `scene-add-game-object-filters`, `scene-update-game-object-filters`, `scene-add-plain-objects`, and `scene-update-plain-objects` requires that the LLM get the system instructions first to know the tool arguments structure.
Input schema
{
  "type": "object",
  "properties": {}
}
——
ide-create-new-prefab-sceneCreate a new special scene that is a prefab. A prefab is a scene with a single game object (the prefab object) and its children. You can create a prefab instance and add it to a scene or another prefab. That's the idea of prefabs, create reusable objects. It is very common to create a prefab for every entity of the game, like the player, the different enemies, non-player characters, platforms, collectibles and many more. A prefab scene is compiled as a subclass of a game object, not as a Phaser.Scene. You can think about a prefab as a custom game object class. Even, you can create a prefab that is variant of another prefab. This means, a prefab that inherits another prefab. To create a prefab variant, just use another prefab instance as root of the prefab scene, as prefab object. This tool only creates an empty prefab scene, you must add the prefab object to the scene, immediately. The goal of a prefab is to instantiate and add it to other scenes.
Input schema
{
  "type": "object",
  "properties": {
    "name": {
      "type": "string",
      "description": "The name of the prefab scene file. It is not a full name, just the name. The extension will be added automatically."
    }
  },
  "required": [
    "name"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
——
ide-create-new-sceneCreate a new scene file. This tool only creates a new scene. If the user wants to show the scene in the game then the user has to add the scene first to the game instance.
Input schema
{
  "type": "object",
  "properties": {
    "name": {
      "type": "string",
      "description": "The name of the scene file. It is not a full name, just the name. The extension will be added automatically."
    }
  },
  "required": [
    "name"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
——
ide-get-active-sceneGet the scene has the focus in the editorÍ. The active scene is the one the user is working at the moment. It may be happen there isn't an active scene.
Input schema
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {}
}
——
ide-get-all-prefabs-in-projectGet all prefabs in the project.
Input schema
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {}
}
——
ide-get-all-scenes-in-projectGet all scenes in the project.
Input schema
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {}
}
——
ide-get-prefab-inheritanceGet an array of all the prefabs that are part of the inheritance of the given prefab. A prefab can inherit another prefab. We call it a prefab variant. If the result is an empty array it means the given prefab is not a variant any other prefab.
Input schema
{
  "type": "object",
  "properties": {
    "prefabId": {
      "type": "string",
      "description": "The ID of the prefab scene to get the inheritance from. The `prefabId` is the same of the id of referring prefab scene."
    }
  },
  "required": [
    "prefabId"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
——
ide-open-sceneOpen the scene in the editor.
Input schema
{
  "type": "object",
  "properties": {
    "sceneId": {
      "type": "string",
      "description": "The `id` of the scene. The `id` is not the name of the scene, else a unique identifier is set in the scene data. You need to read the scene data to get the `id`."
    }
  },
  "required": [
    "sceneId"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
——
ide-save-sceneSave the the editor of the given scene. When the scene is saved, the editor generates its code. Use this tool to sync the scene with the code it represents. It is important to keep both the scene content and the scene's code file in sync if you are working in both files at the same time. Also, it is very important that you save prefab scenes after changing them, so the changes can be propagated in all the scenes that contains the instances of the prefab.
Input schema
{
  "type": "object",
  "properties": {
    "sceneId": {
      "type": "string",
      "description": "The `id` of the scene. The `id` is not the name of the scene, else a unique identifier is set in the scene data. You need to read the scene data to get the `id`."
    }
  },
  "required": [
    "sceneId"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
——
scene-add-editable-tilemapAdd an editable tilemap to the scene. An editable tilemap is different to a Tiled map because all the data can be edited by the user in the scene editor. However, it follows many of the concepts of Tiled. The editable tilemap is also a plain object so you can manipulate it using most of the plain object tools.
Input schema
{
  "type": "object",
  "properties": {
    "sceneId": {
      "type": "string",
      "description": "The `id` of the scene. The `id` is not the name of the scene, else a unique identifier is set in the scene data. You need to read the scene data to get the `id`."
    },
    "label": {
      "type": "string",
      "description": "Label of the object. It is used to name the object in the scene and as the variable name in code."
    },
    "width": {
      "type": "number",
      "description": "The width of the editable tilemap in tiles."
    },
    "height": {
      "type": "number",
      "description": "The height of the editable tilemap in tiles."
    },
    "tileWidth": {
      "type": "number",
      "description": "The width of each tile in pixels."
    },
    "tileHeight": {
      "type": "number",
      "description": "The height of each tile in pixels."
    },
    "tilesets": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "name": {
            "type": "string",
            "description": "The name of the tileset, as it appears in the map data."
          },
          "imageKey": {
            "type": "string",
            "description": "The key of an asset image or spritesheet to associate with the tileset."
          },
          "tileWidth": {
            "type": "number",
            "description": "The width of each tile in pixels."
          },
          "tileHeight": {
            "type": "number",
            "description": "The height of each tile in pixels."
          },
          "tileMargin": {
            "type": "number",
            "default": 0,
            "description": "The margin around each tile in pixels."
          },
          "tileSpacing": {
            "type": "number",
            "default": 0,
            "description": "The spacing between tiles in pixels."
          }
        },
        "required": [
          "name",
          "imageKey",
          "tileWidth",
          "tileHeight"
        ],
        "additionalProperties": false
      },
      "description": "The tilesets used by the tilemap."
    }
  },
  "required": [
    "sceneId",
    "label",
    "width",
    "height",
    "tileWidth",
    "tileHeight",
    "tilesets"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
——
scene-add-editable-tilemap-layerAdd an editable tilemap layer to an editable tilemap. Because the complexity of the editable tilemaps, we provide a couple of dedicated tools. An editable tilemap is different to a Tiled map because all the data can be edited by the user in the scene editor. This method adds a layer to the tilemap data but also it adds an EditableLayer game object to the scene.
Input schema
{
  "type": "object",
  "properties": {
    "sceneId": {
      "type": "string",
      "description": "The `id` of the scene. The `id` is not the name of the scene, else a unique identifier is set in the scene data. You need to read the scene data to get the `id`."
    },
    "tilemapId": {
      "type": "string",
      "description": "The `id` of the editable tilemap to add the layer to. An 'editable tilemap' is not the same as a Tiled tilemap."
    },
    "layer": {
      "type": "object",
      "properties": {
        "name": {
          "type": "string",
          "description": "The name of the layer in the editable tilemap. The name is also used to generate a variable name in code, so it should be a valid variable name."
        },
        "width": {
          "type": "number",
          "description": "The width of the layer in tiles."
        },
        "height": {
          "type": "number",
          "description": "The height of the layer in tiles."
        },
        "tileWidth": {
          "type": "number",
          "description": "The width of each tile in pixels."
        },
        "tileHeight": {
          "type": "number",
          "description": "The height of each tile in pixels."
        }
      },
      "required": [
        "name",
        "width",
        "height",
        "tileWidth",
        "tileHeight"
      ],
      "additionalProperties": false
    }
  },
  "required": [
    "sceneId",
    "tilemapId",
    "layer"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
——
scene-add-game-object-filtersAdd multiple filters to parent game objects in the scene
Input schema
{
  "type": "object",
  "properties": {
    "sceneId": {
      "type": "string",
      "description": "The `id` of the scene. The `id` is not the name of the scene, else a unique identifier is set in the scene data. You need to read the scene data to get the `id`."
    },
    "objects": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "Glow",
              "Shadow",
              "Pixelate",
              "Blur",
              "Barrel",
              "Displacement",
              "Bokeh",
              "Blend",
              "ObjectMask",
              "TextureMask",
              "Threshold",
              "ColorMatrix"
            ]
          },
          "parentId": {
            "type": "string",
            "description": "The `id` of the game object to add the filter to."
          },
          "properties": {
            "type": "object",
            "additionalProperties": {},
            "description": "The properties of the filter to add. Look the system prompt for filter definitions."
          }
        },
        "required": [
          "type",
          "parentId",
          "properties"
        ],
        "additionalProperties": false
      }
    }
  },
  "required": [
    "sceneId",
    "objects"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
——
scene-add-game-objectsAdd multiple new game objects to the scene. If you are adding prefab instances, then you should include the "unlock" property which contains an array of the name of the properties you are setting to the object. By default, are properties are locked in a prefab instance, so you need to unlock them before setting them, otherwise, the prefab instance will get the values defined originally in the prefab scene.
Input schema
{
  "type": "object",
  "properties": {
    "sceneId": {
      "type": "string",
      "description": "The `id` of the scene. The `id` is not the name of the scene, else a unique identifier is set in the scene data. You need to read the scene data to get the `id`."
    },
    "objects": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "Image",
              "Sprite",
              "TileSprite",
              "NineSlice",
              "ThreeSlice",
              "Text",
              "Layer",
              "Container",
              "BitmapText",
              "Rectangle",
              "Ellipse",
              "Triangle",
              "Polygon",
              "ParticleEmitter",
              "SpineGameObject",
              "TilemapLayer",
              "EditableTilemapLayer"
            ]
          },
          "properties": {
            "type": "object",
            "additionalProperties": {},
            "description": "The properties of the game object to add. You should provide all the required properties for creating the game object. The required properties are part of the class constructor of the game object class defined i the system prompt. You can provide a subset of the optional properties plus the required properties."
          }
        },
        "required": [
          "type",
          "properties"
        ],
        "additionalProperties": false
      }
    }
  },
  "required": [
    "sceneId",
    "objects"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
——
scene-add-object-listCreate an Object List, which is an array with the ids of game objects. The user can use this array to group objects for a purpose. One of the most common purpose of objects lists are grouping the objects to be part of an arcade physics colliders.
Input schema
{
  "type": "object",
  "properties": {
    "sceneId": {
      "type": "string",
      "description": "The `id` of the scene. The `id` is not the name of the scene, else a unique identifier is set in the scene data. You need to read the scene data to get the `id`."
    },
    "lists": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "scope": {
            "type": "string",
            "enum": [
              "LOCAL",
              "PUBLIC",
              "METHOD",
              "CLASS",
              "NESTED_PREFAB"
            ],
            "description": "The scope of the variable. By default, the editor may generate or not a variable ('local' scope). It depends on if it needs a variable to update the object just after the creation. However, you can force to generate a variable and assign a scope to it, so you can access the object from different parts of the code. When you set a 'public' scope, the editor generates a public field in the class. The same with the `class` scope, but the field is private (in TypeScript). The 'method' scope says to the editor to generate a local variable. The 'nested_prefab' scope is like the public scope but also indicates that the object is a nested prefab."
          },
          "label": {
            "type": "string",
            "description": "Label of the object. It is used to name the object in the scene and as the variable name in code."
          },
          "objectIds": {
            "type": "array",
            "items": {
              "type": "string"
            },
            "description": "The ids of the game objects in the list. The ids are used to reference the game objects in the scene."
          }
        },
        "required": [
          "objectIds"
        ],
        "additionalProperties": false
      },
      "description": "The object lists to add to the scene."
    }
  },
  "required": [
    "sceneId",
    "lists"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
——
scene-add-plain-objectsAdd multiple new plain objects to the scene.
Input schema
{
  "type": "object",
  "properties": {
    "sceneId": {
      "type": "string",
      "description": "The `id` of the scene. The `id` is not the name of the scene, else a unique identifier is set in the scene data. You need to read the scene data to get the `id`."
    },
    "objects": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "Tilemap",
              "Collider"
            ]
          },
          "properties": {
            "type": "object",
            "additionalProperties": {},
            "description": "The properties of the plain object to add. You should provide all the required properties for creating the object. The required properties are part of the class constructor of the object class defined in the system prompt. You can provide a subset of the optional properties plus the required properties."
          }
        },
        "required": [
          "type",
          "properties"
        ],
        "additionalProperties": false
      }
    }
  },
  "required": [
    "sceneId",
    "objects"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
——
scene-add-tileset-to-editable-tilemapAdd a tileset to an editable tilemap. This will add the tileset to the tilemap data, but it will not add the tileset asset itself. It also will update the ID of the tiles of every layer in the map.
Input schema
{
  "type": "object",
  "properties": {
    "sceneId": {
      "type": "string",
      "description": "The `id` of the scene. The `id` is not the name of the scene, else a unique identifier is set in the scene data. You need to read the scene data to get the `id`."
    },
    "tilemapId": {
      "type": "string",
      "description": "The `id` of the editable tilemap to add the tileset to."
    },
    "tileset": {
      "type": "object",
      "properties": {
        "imageKey": {
          "type": "string",
          "description": "The key of an asset image or spritesheet to associate with the tileset."
        }
      },
      "required": [
        "imageKey"
      ],
      "additionalProperties": false
    }
  },
  "required": [
    "sceneId",
    "tilemapId",
    "tileset"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
——
scene-clear-sceneClear the current scene.
Input schema
{
  "type": "object",
  "properties": {
    "sceneId": {
      "type": "string",
      "description": "The `id` of the scene. The `id` is not the name of the scene, else a unique identifier is set in the scene data. You need to read the scene data to get the `id`."
    }
  },
  "required": [
    "sceneId"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
——
scene-declare-prefab-propertyCreate a new user property for the given prefab.
Input schema
{
  "type": "object",
  "properties": {
    "sceneId": {
      "type": "string",
      "description": "The `id` of the prefab scene. The `id` is not the name of the scene, else a unique identifier is set in the scene data. You need to read the scene data to get the `id`. This id refers only to the scenes that are prefabs."
    },
    "name": {
      "type": "string",
      "description": "The name of the user property. The editor compiles a prefab user property as a field of the prefab class. This name is used as variable name for that field."
    },
    "label": {
      "type": "string",
      "description": "The display name of the property. It is used in the editor to show the property name in the user interface."
    },
    "tooltip": {
      "type": "string",
      "description": "A very short description."
    },
    "customDefinition": {
      "type": "boolean",
      "default": false,
      "description": "By default, a user property is generated in code as a field. If you set this property to true, then the editor skips the generation of the field definition in code, so the user can write a custom property declaration. Most of the time the user doesn't need to do this."
    },
    "type": {
      "type": "object",
      "properties": {
        "id": {
          "type": "string",
          "enum": [
            "number",
            "string",
            "boolean",
            "color",
            "keycode",
            "expression",
            "option",
            "objectVar",
            "object-ref",
            "constructor",
            "event",
            "texture-config",
            "animation-key",
            "audio-key",
            "asset-key",
            "scene-key",
            "spine-skin-name",
            "spine-animation-name",
            "spine-event"
          ],
          "description": "The id type of the user property. Following the list of all the available types and a description of the format of their values: \n\n- \"number\": A numeric property. The value is a number.\n\n- \"string\": A text property. The value is a string.\n\n- \"boolean\": A true/false property. The value is a boolean.\n\n- \"color\": A color property. The value is a string representing a color in hexadecimal format, e g. \"#ff0000\" for red.\n\n- \"keycode\": A Phaser keyboard key code property. The value is a string representing a keyboard key, e g. \"SPACE\", \"A\", \"ENTER\". All the values in the `Phaser.Input.Keyboard.KeyCodes` enum.\n\n- \"expression\": Any javascript valid expression. The value is a string representing the expression, e g. \"this.player.x\", \"Math.random() * 500\".\n\n- \"option\": A property that can be one of a set of predefined string options. The value is a string representing one of the options. When the the type is \"option\", the property definition must include the list of all the available options, in the \"options\" field. Look the \"options\" field for more details.\n\n- \"objectVar\": A reference to a variable that is an object. The value is a string representing a valid JavaScript expression that points to an object in the scene. Like in `this.player.leftHand`. This type is kind of deprecated, use \"object-ref\" instead.\n\n- \"object-ref\": A reference to another game object in the scene. The value is the 'id' of the game object.\n\n- \"constructor\": A JavaScript expression that is a class. It could be a Phaser game object class or a prefab class. Like in \"Phaser.GameObjects.Image\" or \"PlayerPrefab\".\n\n- \"event\": A reference to a Phaser event or custom user event. The value is a string representing the event name, e g. \"pointerdown\", \"update\", \"my-user-event\".\n\n- \"texture-config\": A string that is an string-encoded texture configuration that is a JSON object with the 'key' and 'frame' of the texture, Like in '{\"key\":\"bubbles\",\"frame\":\"blue\"}'. The 'frame' is optional if the texture is an image, like in '{\"key\":\"background\"}'. It is important, very important that you encode the JSON object as a string, so the value is a string. Don't forget to properly escape the string. The editor will decode it to an object when reading the property value.\n\n- \"animation-key\": A string the key of a sprite animation. You can look for the available animations in the project with the `assets-get-available-animations` tool.\n\n- \"audio-key\": A string that is the key of an audio asset.\n\n- \"asset-key\": A string that is the key of an asset in the project. You can look for the available assets in the project with the `assets-get-available-asset-packs` tool.\n\n- \"scene-key\": A string that is the key of a scene in the project. The scene key is the name of the scene file without the extension.\n\n- \"spine-skin-name\": A string that is the name of a skin of a Spine skeleton.\n\n- \"spine-animation-name\": A string that is the name of an animation of a Spine skeleton.\n\n- \"spine-event\": A string that is the name of a Spine event.\n"
        },
        "isArray": {
          "type": "boolean",
          "default": false,
          "description": "If true, the property is an array of the given type. If false, the property is a single value of the given type. If the property is an array, "
        },
        "options": {
          "type": "array",
          "items": {
            "type": "string"
          },
          "description": "If the type is 'option', this is the list of all the available options. The value (and defValue) of the property must be one of these options. If the type is not 'option', this property is ignored."
        }
      },
      "required": [
        "id"
      ],
      "additionalProperties": false
    },
    "defValue": {
      "description": "A user property is always initialized with a default value. It could never be null or undefined. Its raw type is string, number, or boolean, but the format/syntax of the value depends on the type of the property. If the property is an array, then this property refers to the default element of the array when the user adds a new element. To set the default array, use the `defArrayValue` property. If the type is `option`, then the default value should be one of the provided options. Look the `type` property for more details."
    },
    "defArrayValue": {
      "type": "array",
      "items": {},
      "description": "If the property is an array, this is the default array. If the property is not an array, this value is ignored. The type of each element of the array must follow the same rules as the `defValue` property. Look the `defValue` property for more details."
    }
  },
  "required": [
    "sceneId",
    "name",
    "label",
    "tooltip",
    "type"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
——
scene-delete-game-object-filtersDelete the given filters from the scene.
Input schema
{
  "type": "object",
  "properties": {
    "sceneId": {
      "type": "string",
      "description": "The `id` of the scene. The `id` is not the name of the scene, else a unique identifier is set in the scene data. You need to read the scene data to get the `id`."
    },
    "filterIds": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "The `id`s of the filters to delete."
    }
  },
  "required": [
    "sceneId",
    "filterIds"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
——
scene-delete-game-objectsDelete the given game objects from the scene.
Input schema
{
  "type": "object",
  "properties": {
    "sceneId": {
      "type": "string",
      "description": "The `id` of the scene. The `id` is not the name of the scene, else a unique identifier is set in the scene data. You need to read the scene data to get the `id`."
    },
    "objectIds": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "The `id`s of the game objects to delete."
    }
  },
  "required": [
    "sceneId",
    "objectIds"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
——
scene-delete-plain-objectsDelete the given plain objects from the scene. Plain objects are Tilemap, Key, Collider...
Input schema
{
  "type": "object",
  "properties": {
    "sceneId": {
      "type": "string",
      "description": "The `id` of the scene. The `id` is not the name of the scene, else a unique identifier is set in the scene data. You need to read the scene data to get the `id`."
    },
    "objectIds": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "The `id`s of the plain objects to delete."
    }
  },
  "required": [
    "sceneId",
    "objectIds"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
——
scene-delete-prefab-propertyDelete a user property from the given prefab.
Input schema
{
  "type": "object",
  "properties": {
    "sceneId": {
      "type": "string",
      "description": "The `id` of the prefab scene. The `id` is not the name of the scene, else a unique identifier is set in the scene data. You need to read the scene data to get the `id`. This id refers only to the scenes that are prefabs."
    },
    "name": {
      "type": "string",
      "description": "The name of the user property to delete."
    }
  },
  "required": [
    "sceneId",
    "name"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
——
scene-delete-tileset-from-editable-tilemapDelete a tileset from an editable tilemap. This will remove the tileset from the tilemap data, but it will not delete the tileset asset itself. It also will update the ID of the tiles of every layer in the map.
Input schema
{
  "type": "object",
  "properties": {
    "sceneId": {
      "type": "string",
      "description": "The `id` of the scene. The `id` is not the name of the scene, else a unique identifier is set in the scene data. You need to read the scene data to get the `id`."
    },
    "tilemapId": {
      "type": "string",
      "description": "The `id` of the editable tilemap to delete the tileset from. An 'editable tilemap' is not the same as a Tiled tilemap."
    },
    "tilesetName": {
      "type": "string",
      "description": "The name of the tileset to delete from the editable tilemap. This should match the name defined in the tilemap's tilesets."
    }
  },
  "required": [
    "sceneId",
    "tilemapId",
    "tilesetName"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
——
scene-disable-arcade-physics-bodyRemoves the Arcade physics body from the given game objects.
Input schema
{
  "type": "object",
  "properties": {
    "sceneId": {
      "type": "string",
      "description": "The `id` of the scene. The `id` is not the name of the scene, else a unique identifier is set in the scene data. You need to read the scene data to get the `id`."
    },
    "ids": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "The IDs of the game objects to remove the Arcade physics body from."
    }
  },
  "required": [
    "sceneId",
    "ids"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
——
scene-enable-arcade-physics-bodyAdds an Arcade physics body to the given game objects. To set the physics body properties you first have to create the body with this tool.
Input schema
{
  "type": "object",
  "properties": {
    "sceneId": {
      "type": "string",
      "description": "The `id` of the scene. The `id` is not the name of the scene, else a unique identifier is set in the scene data. You need to read the scene data to get the `id`."
    },
    "updates": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "id": {
            "type": "string",
            "description": "The ID of the game object to add the Arcade physics body to."
          }
        },
        "required": [
          "id"
        ],
        "additionalProperties": false
      }
    }
  },
  "required": [
    "sceneId",
    "updates"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
——
scene-fill-editable-tilemap-layer-dataFill a region of the tile data of an editable tilemap layer with a single tile ID. This is useful to do things like clear the layer (fill the full layer with a -1 tile), or to paint backgrounds, filling the layer with the background tile, or filling just a part of the layer like for making a floor, or any other level element.
Input schema
{
  "type": "object",
  "properties": {
    "sceneId": {
      "type": "string",
      "description": "The `id` of the scene. The `id` is not the name of the scene, else a unique identifier is set in the scene data. You need to read the scene data to get the `id`."
    },
    "layerId": {
      "type": "string",
      "description": "The `id` of the editable tilemap layer to fill. An editable tilemap layer is also a game object, so you can use the `id` of the EditableLayer game object."
    },
    "x": {
      "type": "number",
      "description": "The x coordinate of the top left corner of the region to fill."
    },
    "y": {
      "type": "number",
      "description": "The y coordinate of the top left corner of the region to fill."
    },
    "width": {
      "type": "number",
      "description": "The width of the region to fill in tiles."
    },
    "height": {
      "type": "number",
      "description": "The height of the region to fill in tiles."
    },
    "tileId": {
      "type": "number",
      "description": "The tile ID to fill the region with. The tile ID is a global ID that is computed by the index (starting from 1) of the tile in the tileset. If there are more than one tileset, then the global ID is computed by adding the length of each tileset."
    }
  },
  "required": [
    "sceneId",
    "layerId",
    "x",
    "y",
    "width",
    "height",
    "tileId"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
——
scene-get-editable-tilemap-layer-selection-dataGet the selected tile data of an editable tilemap layer. It returns a 2D array with the tile IDs. The selection is always a rectangular region of the tilemap layer.
Input schema
{
  "type": "object",
  "properties": {
    "sceneId": {
      "type": "string",
      "description": "The `id` of the scene. The `id` is not the name of the scene, else a unique identifier is set in the scene data. You need to read the scene data to get the `id`."
    }
  },
  "required": [
    "sceneId"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
——
scene-get-nested-prefabs-instancesGet all the nested prefab instances of the given prefab instance. A prefab instance can have other prefab instances as children that are exposed as nested prefab instances. This tool returns all the nested prefab instances, not the direct children. You can use this tool to get the info of the nested prefab instances and perform operations like updating the nested prefabs or, in case they are containers-like objects, add objects to them. You cannot delete a nested prefab instance. A nested prefab instance also have a `prefabId` that points to an object inside the root prefab. You can modify a nested prefab instance just like any other prefab instance, you have to provide the id, the values of the properties, and update the `unlock` field. Each nested prefab instance contains its own data.
Input schema
{
  "type": "object",
  "properties": {
    "sceneId": {
      "type": "string",
      "description": "The `id` of the scene. The `id` is not the name of the scene, else a unique identifier is set in the scene data. You need to read the scene data to get the `id`."
    },
    "id": {
      "type": "string",
      "description": "The `id` of the prefab instance game object in the scene."
    }
  },
  "required": [
    "sceneId",
    "id"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
——
scene-get-scene-dataGet all objects in the current scene, including their properties.
Input schema
{
  "type": "object",
  "properties": {
    "sceneId": {
      "type": "string",
      "description": "The `id` of the scene. The `id` is not the name of the scene, else a unique identifier is set in the scene data. You need to read the scene data to get the `id`."
    }
  },
  "required": [
    "sceneId"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
——
scene-get-scene-dimensionGet the dimensions of the current scene.
Input schema
{
  "type": "object",
  "properties": {
    "sceneId": {
      "type": "string",
      "description": "The `id` of the scene. The `id` is not the name of the scene, else a unique identifier is set in the scene data. You need to read the scene data to get the `id`."
    }
  },
  "required": [
    "sceneId"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
——
scene-get-screenshotGet a screenshot of the scene.
Input schema
{
  "type": "object",
  "properties": {
    "sceneId": {
      "type": "string",
      "description": "The `id` of the scene. The `id` is not the name of the scene, else a unique identifier is set in the scene data. You need to read the scene data to get the `id`."
    },
    "x": {
      "type": "number",
      "description": "The x coordinate of the top left corner of the screenshot."
    },
    "y": {
      "type": "number",
      "description": "The y coordinate of the top left corner of the screenshot."
    },
    "width": {
      "type": "number",
      "description": "The width of the screenshot."
    },
    "height": {
      "type": "number",
      "description": "The height of the screenshot."
    }
  },
  "required": [
    "sceneId",
    "x",
    "y",
    "width",
    "height"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
——
scene-move-game-object-in-render-listSort objects in the current scene.
Input schema
{
  "type": "object",
  "properties": {
    "sceneId": {
      "type": "string",
      "description": "The `id` of the scene. The `id` is not the name of the scene, else a unique identifier is set in the scene data. You need to read the scene data to get the `id`."
    },
    "objectIds": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "The `id`s of the objects to sort."
    },
    "move": {
      "type": "string",
      "enum": [
        "Up",
        "Down",
        "Top",
        "Bottom"
      ],
      "description": "Move the objects upm down, top, or bottom in the render list."
    }
  },
  "required": [
    "sceneId",
    "objectIds",
    "move"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
——
scene-move-game-objects-to-parentMove the given objects to the given parent.
Input schema
{
  "type": "object",
  "properties": {
    "sceneId": {
      "type": "string",
      "description": "The `id` of the scene. The `id` is not the name of the scene, else a unique identifier is set in the scene data. You need to read the scene data to get the `id`."
    },
    "objectIds": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "The `id`s of the objects to move."
    },
    "parentId": {
      "type": "string",
      "description": "The `id` of the parent to move the objects to. If no parent is given, the objects will be moved to the root of the scene."
    }
  },
  "required": [
    "sceneId",
    "objectIds"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
——
scene-pack-objects-in-containerCreate a container to group the given objects. The container and objects are positioned so the container size is minimal.
Input schema
{
  "type": "object",
  "properties": {
    "sceneId": {
      "type": "string",
      "description": "The `id` of the scene. The `id` is not the name of the scene, else a unique identifier is set in the scene data. You need to read the scene data to get the `id`."
    },
    "objectIds": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "The `id`s of the objects to move."
    }
  },
  "required": [
    "sceneId",
    "objectIds"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
——
scene-remove-object-listRemove an Object List from the scene.
Input schema
{
  "type": "object",
  "properties": {
    "sceneId": {
      "type": "string",
      "description": "The `id` of the scene. The `id` is not the name of the scene, else a unique identifier is set in the scene data. You need to read the scene data to get the `id`."
    },
    "listIds": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "The ids of the object lists to remove."
    }
  },
  "required": [
    "sceneId",
    "listIds"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
——
scene-resize-editable-tilemap-layerResize an editable tilemap layer. This will resize the layer data, but it will not resize the layer game object itself. It also will update the ID of the tiles of every layer in the map.
Input schema
{
  "type": "object",
  "properties": {
    "sceneId": {
      "type": "string",
      "description": "The `id` of the scene. The `id` is not the name of the scene, else a unique identifier is set in the scene data. You need to read the scene data to get the `id`."
    },
    "layerId": {
      "type": "string",
      "description": "The `id` of the editable tilemap layer to resize. An editable tilemap layer is also a game object, so you can use the `id` of the EditableLayer game object."
    },
    "width": {
      "type": "number",
      "description": "The new width of the layer in tiles."
    },
    "height": {
      "type": "number",
      "description": "The new height of the layer in tiles."
    }
  },
  "required": [
    "sceneId",
    "layerId",
    "width",
    "height"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
——
scene-update-game-object-filter-listUpdate the list where the filter is placed. A filter could be on the internal or external filter list. The internal filters are rendered in the game object space. The external filters are rendered in the camera space.
Input schema
{
  "type": "object",
  "properties": {
    "sceneId": {
      "type": "string",
      "description": "The `id` of the scene. The `id` is not the name of the scene, else a unique identifier is set in the scene data. You need to read the scene data to get the `id`."
    },
    "filterId": {
      "type": "string",
      "description": "The `id` of the filter to update."
    },
    "internal": {
      "type": "boolean",
      "description": "If `true`, the filter is added to the internal filter list of the game object. If `false`, the filter is added to the scene's filter list."
    }
  },
  "required": [
    "sceneId",
    "filterId",
    "internal"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
——
scene-update-game-object-filtersAdd multiple filters to parent game objects in the scene
Input schema
{
  "type": "object",
  "properties": {
    "sceneId": {
      "type": "string",
      "description": "The `id` of the scene. The `id` is not the name of the scene, else a unique identifier is set in the scene data. You need to read the scene data to get the `id`."
    },
    "objects": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "id": {
            "type": "string",
            "description": "The `id` of the filter to update."
          },
          "type": {
            "type": "string",
            "enum": [
              "Glow",
              "Shadow",
              "Pixelate",
              "Blur",
              "Barrel",
              "Displacement",
              "Bokeh",
              "Blend",
              "ObjectMask",
              "TextureMask",
              "Threshold",
              "ColorMatrix"
            ]
          },
          "internal": {
            "type": "boolean",
            "default": true,
            "description": "If add it to the internal filter list of the game object. The internal filters are rendered in the space of the object. You should set padding values to make space for the filter effect. If set to `false`, the filter is added to the scene's filter list and is rendered in the space of the whole scene."
          },
          "properties": {
            "type": "object",
            "additionalProperties": {},
            "description": "The properties of the filter to add. Look the system prompt for filter definitions."
          }
        },
        "required": [
          "id",
          "type",
          "properties"
        ],
        "additionalProperties": false
      }
    }
  },
  "required": [
    "sceneId",
    "objects"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
——
scene-update-game-objectsUpdate multiple game objects in the scene. If you are updating prefab instances, then you should include the "unlock" property which contains an array of the name of the properties you are setting to the object. By default, are properties are locked in a prefab instance, so you need to unlock them before setting them, otherwise, the prefab instance will get the values defined originally in the prefab scene. It is important that you be smart when setting the unlock property, because its value will override the unlock state of the object. This means, if you are going to update a property but want to keep the values of the other properties unlocked in the prefab instance then you have to include them in your update arguments.
Input schema
{
  "type": "object",
  "properties": {
    "sceneId": {
      "type": "string",
      "description": "The `id` of the scene. The `id` is not the name of the scene, else a unique identifier is set in the scene data. You need to read the scene data to get the `id`."
    },
    "objects": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "id": {
            "type": "string",
            "description": "The `id` of the game object to update."
          },
          "type": {
            "type": "string",
            "enum": [
              "Image",
              "Sprite",
              "TileSprite",
              "NineSlice",
              "ThreeSlice",
              "Text",
              "Layer",
              "Container",
              "BitmapText",
              "Rectangle",
              "Ellipse",
              "Triangle",
              "Polygon",
              "ParticleEmitter",
              "SpineGameObject",
              "TilemapLayer",
              "EditableTilemapLayer"
            ]
          },
          "properties": {
            "type": "object",
            "additionalProperties": {},
            "description": "The properties of the game object to update. You can provide any subset of the properties, but should provide at least one property to update."
          }
        },
        "required": [
          "id",
          "type",
          "properties"
        ],
        "additionalProperties": false
      },
      "description": "The game objects to update in the scene."
    }
  },
  "required": [
    "sceneId",
    "objects"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
——
scene-update-object-listUpdate an Object List, which is an array with the ids of game objects.
Input schema
{
  "type": "object",
  "properties": {
    "sceneId": {
      "type": "string",
      "description": "The `id` of the scene. The `id` is not the name of the scene, else a unique identifier is set in the scene data. You need to read the scene data to get the `id`."
    },
    "id": {
      "type": "string",
      "description": "The id of the object list to update."
    },
    "scope": {
      "type": "string",
      "enum": [
        "LOCAL",
        "PUBLIC",
        "METHOD",
        "CLASS",
        "NESTED_PREFAB"
      ],
      "description": "The scope of the variable. By default, the editor may generate or not a variable ('local' scope). It depends on if it needs a variable to update the object just after the creation. However, you can force to generate a variable and assign a scope to it, so you can access the object from different parts of the code. When you set a 'public' scope, the editor generates a public field in the class. The same with the `class` scope, but the field is private (in TypeScript). The 'method' scope says to the editor to generate a local variable. The 'nested_prefab' scope is like the public scope but also indicates that the object is a nested prefab."
    },
    "label": {
      "type": "string",
      "description": "Label of the object. It is used to name the object in the scene and as the variable name in code."
    },
    "objectIds": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "The ids of the game objects in the list. The ids are used to reference the game objects in the scene."
    }
  },
  "required": [
    "sceneId",
    "id",
    "objectIds"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
——
scene-update-plain-objectsUpdate multiple plain objects in the scene.
Input schema
{
  "type": "object",
  "properties": {
    "sceneId": {
      "type": "string",
      "description": "The `id` of the scene. The `id` is not the name of the scene, else a unique identifier is set in the scene data. You need to read the scene data to get the `id`."
    },
    "objects": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "Tilemap",
              "Collider"
            ]
          },
          "id": {
            "type": "string",
            "description": "The `id` of the object to update."
          },
          "properties": {
            "type": "object",
            "additionalProperties": {},
            "description": "The properties of the plain object to add. You should provide all the required properties for creating the object. The required properties are part of the class constructor of the object class defined in the system prompt. You can provide a subset of the optional properties plus the required properties."
          }
        },
        "required": [
          "type",
          "id",
          "properties"
        ],
        "additionalProperties": false
      }
    }
  },
  "required": [
    "sceneId",
    "objects"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
——
scene-write-editable-tilemap-layer-dataWrite part of the tile data of an editable tilemap layer. This is useful to update a layer's data without having to send the whole layer data again.
Input schema
{
  "type": "object",
  "properties": {
    "sceneId": {
      "type": "string",
      "description": "The `id` of the scene. The `id` is not the name of the scene, else a unique identifier is set in the scene data. You need to read the scene data to get the `id`."
    },
    "layerId": {
      "type": "string",
      "description": "The `id` of the editable tilemap layer to write to. An editable tilemap layer is also a game object, so you can use the `id` of the EditableLayer game object."
    },
    "data": {
      "type": "array",
      "items": {
        "type": "array",
        "items": {
          "type": "number"
        }
      },
      "description": "The tile data to write to the layer. Each item is a tile ID, or -1 for an empty tile. The tile ID is a global ID that is computed by the index (starting from 1) of the tile in the tileset. If there are more than one tileset, then the global ID is computed by adding the length of each tileset. The data is a 2D array, where each inner array represents a row of tiles."
    },
    "x": {
      "type": "number",
      "description": "The x coordinate of the top left corner of the data to write."
    },
    "y": {
      "type": "number",
      "description": "The y coordinate of the top left corner of the data to write."
    }
  },
  "required": [
    "sceneId",
    "layerId",
    "data",
    "x",
    "y"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
——

Resources 0

Resource templates 0

Prompts 0

Changes from previous version

Compared with initial baseline using full_baseline.

RiskChangeSubject
No material changes recorded.

Confirmed vulnerabilities

SeverityFindingAdvisory
No confirmed vulnerability is published for this version.

Provenance

Artifact SHA-256: 30c21ce71abb0ede5af0edb99c1cd09a1a4ce2522efb6d5b66f865c048c765e2

Scanner: mcp-proof-engine 0.1.0.

Let’s talk about MCP security.

Share your details and our security team will contact you.