List the typed TypeScript MCP capabilities available to the current server.

List tool folders and counts. Use this before loading a tool folder.

List concise tools in one folder. Use a parent folder to inspect its subfolders.

Search a compact subset of tools by name, description, or folder to reduce context usage.

Convert one image to pixel art with a deterministic shared palette.

Convert all image frames to pixel art and preserve animation delays.

Upscale one image or animation with deterministic nearest-neighbor pixels and preserved transparency.

Apply a deterministic accent palette to a PNG or GIF, preserve transparency and timing, and cap output colors without overwriting the source.

Fit heterogeneous sprite previews into a deterministic nearest-neighbor contact sheet and write a navigable JSON manifest.

Convert a PNG, GIF, or animated image into a GIF while preserving frames.

Inspect one asset and return compact quality violations and deterministic recommendations in one call.

Inspect up to 32 sprites in one deterministic quality pass and return a compact collection summary.

Audit an animation for duplicate frames, timing, palette drift, movement bounds, and loop seam issues.

Crop one or more raster frames to shared alpha bounds, add deterministic padding and write pivot metadata without overwriting the source.

Assemble all frames of a PNG or GIF into a deterministic PNG spritesheet and write coordinates, bottom-center pivots, and delays to a manifest.

Inspect per-frame alpha bounds, connected components, baseline, and bottom-center pivots for scene placement.

Generate a deterministic collision manifest from sprite geometry using component or union hitboxes with bounded padding.

Build one deterministic runtime bundle with an animation sheet, timing manifest, and sprite hitbox manifest.

Generate deterministic placement anchors from sprite geometry for scene composition and game-engine transforms.

Export an atlas PNG and a compact JSON manifest in one call.

Run one compact asset recipe or return its dry-run plan.

Run several compact asset recipes in order or return one batch plan.

Create a deterministic visual style contract for sprites and maps.

Analyze reference dimensions, dominant colors, contrast, edges, and transparency.

Run compact pixel-art quality checks before export.

Build a deterministic terrain tileset with adjacency variants and metadata.

Generate a seeded multi-biome map manifest and optional preview.

Generate a seeded beach map, preview, and animated wave GIF.

Extend an existing deterministic scene around its borders while preserving the original layers and landmarks.

Generate deterministic transition metadata and a preview overlay between adjacent map biomes without mutating the source map.

Apply deterministic water, earth, grass, stone, or snow granularity while preserving transparency and source data.

Apply deterministic depth-aware directional lighting to a sprite while preserving transparency and source data.

Generate a complete beach, forest, village, or cave asset pack.

Add a deterministic pixel outline around opaque sprite edges.

Apply deterministic brightness, contrast, and saturation grading to a sprite.

Generate a deterministic clipped sprite shadow from alpha data.

Generate a deterministic animated particle burst GIF for impact, healing, magic, or dust.

Generate a deterministic tangent-space normal map from sprite alpha depth.

Generate a deterministic rain overlay while preserving the source dimensions and frame timing.

Generate a deterministic idle, walk, run, jump, or attack cycle from a static or animated sprite.

Make opposite texture borders match deterministically for repeatable water, earth, stone, or grass backgrounds.

Generate a deterministic animated reflection below a waterline for oceans, beaches, and wave scenes.

Generate deterministic animated light caustics over opaque water pixels for oceans, pools, beaches, and flooded interiors.

Generate a deterministic animated day, sunset, night, and sunrise cycle while preserving transparency and source dimensions.

Generate a deterministic multi-output environmental variant pack for one source asset: rain, fire, earthquake, birds, night, movement, and water effects.

Generate one executable world preset with terrain, map, preview, and deterministic time-of-day artifacts.

Generate a deterministic compact package of selected scene effects while preserving the source: rain, particles, water motion, day/night, material grain, and directional lighting.

Compose a deterministic, reviewable multi-effect asset recipe without executing it.

Execute a deterministic composed asset recipe through the shared visual services.

Search the deterministic asset/preset library with compact results for humans and agents.

Resolve one library item and its README, preview, sprite sheet, and variants.

Resolve a ready-to-compose scene preset and its recommended MCP tools.

Compose one scene preset into compact assets and ordered layers for a single low-token request.

Audit library ids, preset references, categories, folders, and navigable asset paths before composing a scene.

Return compact category and preset navigation metadata for the asset library with minimal tokens.

Plan ordered scene layers from selected asset library ids without generating files or loading full asset details.

Compose selected library previews into a deterministic PNG and navigable manifest.

Compose selected animated library previews into a deterministic GIF and frame manifest.

Generate deterministic environmental variants for multiple asset library ids with one compact request.

Audit files referenced by a generated manifest, including missing, empty, format, and SHA-256 metadata.

Recommend a compact, deterministic set of compatible library assets for a scene, with explainable reasons and covered tags/effects.

Build a static PNG scene, animated GIF scene, and both navigation manifests through one deterministic operation.

Inspect one image and return a deterministic, non-destructive enhancement plan for an agent or human review.

Apply a deterministic enhancement plan to a new output file while preserving the source asset.

Enhance up to 24 assets in one deterministic batch, isolating per-file failures and preserving every source.

Start a compact asynchronous batch asset job and return its job id.

Read one asynchronous asset job without returning raw pixels.

Request cancellation of a queued or running asset job.

Create a new Aseprite canvas.

Add a named layer group to an Aseprite document.

Add a named layer, optionally inside a group.

Delete a named layer from an Aseprite document.

Rename a named layer.

Duplicate a layer and its cels across all frames.

Move a layer to a one-based stack position.

Set a layer blend mode supported by Aseprite.

Merge a layer into the layer below it.

Flatten all layers into one layer.

Add one animation frame.

Add a deterministic number of animation frames.

Set the active animation frame by one-based index.

Set one animation frame duration in milliseconds.

Set all animation frame durations in milliseconds.

Set a named layer visibility.

Set a named layer opacity from 0 to 255.

Draw explicit pixels on the active cel.

Draw a Bresenham line with optional pixel thickness.

Draw a filled or outlined pixel-art rectangle on the active Aseprite layer.

Fill a contiguous area from a seed pixel.

Draw an ellipse-bounded circle.

Draw explicit pixels on a named layer and animation frame, creating the cel when requested.

Draw a Bresenham line on a named layer and animation frame.

Draw a filled or outlined rectangle on a named layer and animation frame.

Fill a contiguous area on a named layer and animation frame.

Draw an ellipse-bounded circle on a named layer and animation frame.

Draw a filled or outlined polygon on a named layer and animation frame.

Draw a polyline on a named layer and animation frame.

Apply a horizontal or vertical linear gradient to a rectangle on a named layer and animation frame.

Draw a filled or outlined ellipse on a named layer and animation frame.

Export a sprite to a selected image format and confirm that Aseprite wrote an output file.

Copy a sprite to another Aseprite document, refusing to overwrite by default.

Export one animation frame as a PNG with nearest-neighbor integer scaling.

Export each layer as a PNG and confirm that at least one new layer file was written.

Export an animation tag as an image or animation file after validating that the tag exists.

Import an image into a named layer and frame, creating the layer when it does not exist.

Create an empty cel at a layer and frame when one does not already exist.

Delete a cel from a named layer and frame.

Copy one layer cel to another frame, replacing the destination by default.

Copy all cels from one frame to another frame or append a new frame.

Set one cel position, optionally creating it from a source cel.

Tween cel positions linearly across a frame range.

Offset cel positions across a frame range.

Propagate all source-frame cels to a frame range.

Delete one animation frame while keeping at least one frame in the sprite.

Delete an existing animation tag.

Validate onion-skin settings for batch workflows; Aseprite UI-only settings are reported explicitly.

Render neighboring animation frames as translucent onion-skin ghosts into a PNG.

Compare two flattened animation frames and return changed-pixel metrics as JSON.

Set one cel opacity from 0 to 255.

Return JSON color usage statistics for one flattened frame.

Return the active sprite palette as a JSON color array.

Apply a controlled hexadecimal palette to a document.

Extract and persist an optimized palette with a bounded color count.

Remap explicit RGB colors across a layer frame range while preserving alpha.

List built-in retro palette presets.

Apply a built-in retro palette preset to the sprite.

Generate a hue-shifted dark-to-light pixel-art color ramp.

Snap opaque pixels to the nearest color in the active palette.

Convert a sprite to RGB, grayscale, or indexed color mode.

Read one RGBA pixel from a cel.

Read a rectangular RGBA region from a cel as JSON.

Read one RGBA pixel from the visible flattened composite.

Read a visible flattened composite region as JSON.

Move a rectangular region within a cel, clearing its source.

Copy a rectangular region to a layer and frame destination.

Erase a rectangular region to transparency.

Erase opaque pixels matching a color within channel tolerance.

Flip a layer cel horizontally or vertically.

Rotate a layer cel 90, 180, or 270 degrees clockwise.

Resize the sprite canvas and its content.

Crop the sprite canvas to a rectangle.

List discoverable TrueType and OpenType fonts.

Measure a text run without changing a sprite.

Rasterize and draw text into a sprite layer and frame.

Draw pixels onto a tilemap tileset tile.

Place tile indices on a tilemap frame by grid coordinates.

Read the tile index at a tilemap grid coordinate.

Read tile size, tileset count, and map dimensions.

Create a named rectangular slice.

Set a slice 9-patch center rectangle.

Set a slice pivot point.

List slice bounds, centers, and pivots as JSON.

Delete a named slice.

Ensure cels exist for named layers across a frame range.

Audit animation cels, overlaps, and declared frame ranges.

Normalize animation cels and optionally repair out-of-range activity.

Serve a validated local directory over HTTP for visual asset preview.

Stop a preview server started by this MCP process.

Copy selected animation layers and cels from one Aseprite document into another.

Read sprite dimensions, color mode, frame durations, layers, and tags as JSON.

Append one or more copies of an inclusive animation frame range.

Copy selected layer cels from one source frame across a frame range.

Tween cel positions across frames with deterministic easing.

Apply sine-wave position offsets to cels across frames.

Tween cel opacity from 0 to 255 across frames with easing.

Scale a source cel across frames with easing and a stable anchor.

Set the active layer by name, optionally creating it.

Return a concise deterministic guide for character, environment, or general animation workflows.

Run a bounded, trusted Aseprite Lua script as an escape hatch; dedicated tools are preferred.

Create a deterministic, auditable TypeScript plan for a layered character and its Godot exports.

Create a deterministic, auditable TypeScript plan for a tilemap scene and its Godot exports.

Apply Aseprite native outline to a selected layer and frame.

Apply Aseprite native hue, saturation, and lightness adjustment.

Apply Aseprite native brightness and contrast adjustment.

Apply Aseprite native color inversion.

Replace a cel color while preserving alpha and allowing channel tolerance.

Shift hue, saturation, and lightness on an opaque cel while preserving alpha.

Apply a built-in Aseprite convolution matrix to a layer and frame.

List the built-in convolution matrices supported by Aseprite.

Fill a rectangle with a two-color Bayer-dithered gradient.

Fill a rectangle with a uniform Bayer-dithered mix of two colors.

Create or update an animation tag.

Create a tilemap layer and set the Aseprite grid.

Validate required layers and the requested frame range before export.

Export a spritesheet and optional frame metadata for Godot.