auvrynt 1.0.2 → 1.0.5

package/extensions/auvrynt_bridge/live_analysis.lua

@@ -0,0 +1,181 @@
+local C = require("live_common")
+local M = {}
+
+local function render_frame(sprite, frame_number, composite, layer_name)
+  if frame_number < 1 or frame_number > #sprite.frames then C.fail("Frame is outside the sprite") end
+  local image = Image(sprite.spec)
+  image:clear()
+  if composite ~= false then
+    image:drawSprite(sprite, frame_number, Point(0, 0))
+  else
+    local layer = C.find_layer(sprite.layers, layer_name) or app.activeLayer
+    if not layer or layer.isGroup or layer.isTilemap then C.fail("A normal drawable layer is required") end
+    local cel = layer:cel(frame_number)
+    if cel then image:drawImage(cel.image, cel.position) end
+  end
+  return image
+end
+
+local function image_bounds(sprite, image)
+  local min_x, min_y, max_x, max_y = sprite.width, sprite.height, -1, -1
+  local count = 0
+  for y=0,sprite.height-1 do
+    for x=0,sprite.width-1 do
+      if C.pixel_alpha(sprite, image:getPixel(x, y)) > 0 then
+        count = count + 1
+        if x < min_x then min_x = x end
+        if y < min_y then min_y = y end
+        if x > max_x then max_x = x end
+        if y > max_y then max_y = y end
+      end
+    end
+  end
+  if count == 0 then return { empty=true, pixels=0 } end
+  return {
+    empty=false,
+    pixels=count,
+    x=min_x,
+    y=min_y,
+    width=max_x-min_x+1,
+    height=max_y-min_y+1,
+    centerX=(min_x+max_x)/2,
+    centerY=(min_y+max_y)/2,
+  }
+end
+
+local function get_sprite_bounds(sprite, params)
+  local frame = C.target_frame_number(sprite, params)
+  local image = render_frame(sprite, frame, params.composite ~= false, params.layer)
+  local bounds = image_bounds(sprite, image)
+  bounds.frame = frame
+  bounds.composite = params.composite ~= false
+  return bounds
+end
+
+local function get_color_stats(sprite, params)
+  local frame = C.target_frame_number(sprite, params)
+  local image = render_frame(sprite, frame, params.composite ~= false, params.layer)
+  local counts, opaque, transparent, semitransparent = {}, 0, 0, 0
+  for y=0,sprite.height-1 do
+    for x=0,sprite.width-1 do
+      local color = C.pixel_to_color(sprite, image:getPixel(x, y))
+      if color.alpha == 0 then
+        transparent = transparent + 1
+      else
+        opaque = opaque + 1
+        if color.alpha < 255 then semitransparent = semitransparent + 1 end
+        local hex = C.color_to_hex(color)
+        counts[hex] = (counts[hex] or 0) + 1
+      end
+    end
+  end
+  local colors = {}
+  for color, count in pairs(counts) do colors[#colors+1] = { color=color, count=count } end
+  table.sort(colors, function(a, b)
+    if a.count == b.count then return a.color < b.color end
+    return a.count > b.count
+  end)
+  local limit = C.clamp(C.integer(params.limit, 256), 1, 256)
+  while #colors > limit do table.remove(colors) end
+  local unique = 0
+  for _ in pairs(counts) do unique = unique + 1 end
+  return {
+    frame=frame,
+    uniqueColors=unique,
+    opaquePixels=opaque,
+    transparentPixels=transparent,
+    semitransparentPixels=semitransparent,
+    colors=colors,
+  }
+end
+
+local function compare_frames(sprite, params)
+  local first = C.clamp(C.integer(params.frameA, 1), 1, #sprite.frames)
+  local second = C.clamp(C.integer(params.frameB, math.min(2, #sprite.frames)), 1, #sprite.frames)
+  local image_a = render_frame(sprite, first, params.composite ~= false, params.layer)
+  local image_b = render_frame(sprite, second, params.composite ~= false, params.layer)
+  local changed, min_x, min_y, max_x, max_y = 0, sprite.width, sprite.height, -1, -1
+  for y=0,sprite.height-1 do
+    for x=0,sprite.width-1 do
+      if image_a:getPixel(x, y) ~= image_b:getPixel(x, y) then
+        changed = changed + 1
+        if x < min_x then min_x = x end
+        if y < min_y then min_y = y end
+        if x > max_x then max_x = x end
+        if y > max_y then max_y = y end
+      end
+    end
+  end
+  local total = sprite.width * sprite.height
+  return {
+    frameA=first,
+    frameB=second,
+    exact=changed == 0,
+    changedPixels=changed,
+    matchPercent=total == 0 and 100 or ((total-changed)/total)*100,
+    differenceBounds=changed == 0 and nil or { x=min_x, y=min_y, width=max_x-min_x+1, height=max_y-min_y+1 },
+  }
+end
+
+local function find_tag(sprite, name)
+  if name == nil then return nil end
+  for _, tag in ipairs(sprite.tags) do if tag.name == name then return tag end end
+  return nil
+end
+
+local function validate_animation(sprite, params)
+  local tag = find_tag(sprite, params.tag)
+  if params.tag and not tag then C.fail("Tag was not found") end
+  local from = tag and tag.fromFrame.frameNumber or C.clamp(C.integer(params.from, 1), 1, #sprite.frames)
+  local to = tag and tag.toFrame.frameNumber or C.clamp(C.integer(params.to, #sprite.frames), from, #sprite.frames)
+  local frames, issues = {}, {}
+  local previous_image = nil
+  local previous_bounds = nil
+  for frame=from,to do
+    local image = render_frame(sprite, frame, true)
+    local bounds = image_bounds(sprite, image)
+    local duration = math.floor(sprite.frames[frame].duration * 1000 + 0.5)
+    local duplicate = false
+    if previous_image then
+      duplicate = true
+      for y=0,sprite.height-1 do
+        for x=0,sprite.width-1 do
+          if image:getPixel(x, y) ~= previous_image:getPixel(x, y) then duplicate = false break end
+        end
+        if not duplicate then break end
+      end
+    end
+    local movement = nil
+    if previous_bounds and not previous_bounds.empty and not bounds.empty then
+      movement = {
+        dx=bounds.centerX-previous_bounds.centerX,
+        dy=bounds.centerY-previous_bounds.centerY,
+      }
+    end
+    frames[#frames+1] = { frame=frame, durationMs=duration, bounds=bounds, duplicatePrevious=duplicate, movement=movement }
+    if bounds.empty then issues[#issues+1] = { frame=frame, type="empty_frame" } end
+    if duplicate then issues[#issues+1] = { frame=frame, type="duplicate_previous" } end
+    if duration < 16 or duration > 2000 then issues[#issues+1] = { frame=frame, type="duration_outlier", durationMs=duration } end
+    previous_image, previous_bounds = image, bounds
+  end
+  local loop = compare_frames(sprite, { frameA=from, frameB=to, composite=true })
+  return {
+    tag=tag and tag.name or nil,
+    from=from,
+    to=to,
+    frameCount=to-from+1,
+    frames=frames,
+    issues=issues,
+    loopEndpointDifference=loop,
+    valid=#issues == 0,
+  }
+end
+
+M.handlers = {
+  get_sprite_bounds=get_sprite_bounds,
+  get_color_stats=get_color_stats,
+  compare_frames=compare_frames,
+  validate_animation=validate_animation,
+}
+
+return M

package/extensions/auvrynt_bridge/live_animation.lua

@@ -0,0 +1,134 @@
+local C = require("live_common")
+local M = {}
+
+local function set_frame_range_duration(sprite, params)
+  local from = C.clamp(C.integer(params.from, 1), 1, #sprite.frames)
+  local to = C.clamp(C.integer(params.to, from), from, #sprite.frames)
+  local duration_ms = C.clamp(C.integer(params.durationMs, 100), 1, 60000)
+  app.transaction("Auvrynt Live Frame Durations", function()
+    for frame=from,to do sprite.frames[frame].duration = duration_ms / 1000 end
+  end)
+  return { from=from, to=to, durationMs=duration_ms }
+end
+
+local function duplicate_frame(sprite, params)
+  local source = C.target_frame_number(sprite, params)
+  local created
+  app.transaction("Auvrynt Live Duplicate Frame", function()
+    sprite:newFrame(source)
+    created = sprite.frames[source + 1]
+    if params.durationMs ~= nil then created.duration = C.clamp(C.integer(params.durationMs, 100), 1, 60000) / 1000 end
+  end)
+  app.activeFrame = created
+  return { source=source, frame=created.frameNumber, durationMs=math.floor(created.duration * 1000 + 0.5) }
+end
+
+local function reverse_frames(sprite, params)
+  local from = C.clamp(C.integer(params.from, 1), 1, #sprite.frames)
+  local to = C.clamp(C.integer(params.to, #sprite.frames), from, #sprite.frames)
+  local frames = {}
+  for frame=from,to do frames[#frames+1] = sprite.frames[frame] end
+  app.activeSprite = sprite
+  app.range.frames = frames
+  app.command.ReverseFrames()
+  return { from=from, to=to, count=to-from+1 }
+end
+
+local function shift_cel(sprite, params)
+  local layer, frame_number = C.active_target(sprite, params)
+  local dx, dy = C.integer(params.dx, 0), C.integer(params.dy, 0)
+  local cel = layer:cel(frame_number)
+  if not cel then C.fail("Cel does not exist") end
+  app.transaction("Auvrynt Live Shift Cel", function()
+    if params.wrap == true then
+      cel = C.get_canvas_cel(sprite, layer, frame_number, true)
+      local source = Image(cel.image)
+      local transparent = C.color_to_pixel(sprite, Color{r=0,g=0,b=0,a=0})
+      cel.image:clear(transparent)
+      for y=0,sprite.height-1 do
+        for x=0,sprite.width-1 do
+          local nx = (x + dx) % sprite.width
+          local ny = (y + dy) % sprite.height
+          cel.image:drawPixel(nx, ny, source:getPixel(x, y))
+        end
+      end
+    else
+      cel.position = Point(cel.position.x + dx, cel.position.y + dy)
+    end
+  end)
+  return { layer=layer.name, frame=frame_number, x=cel.position.x, y=cel.position.y, dx=dx, dy=dy, wrap=params.wrap == true }
+end
+
+local function flip_sprite(sprite, params)
+  local orientation = params.orientation == "vertical" and "vertical" or "horizontal"
+  app.activeSprite = sprite
+  app.command.Flip { orientation=orientation }
+  return { orientation=orientation, width=sprite.width, height=sprite.height }
+end
+
+local function rotate_sprite(sprite, params)
+  local angle = C.integer(params.angle, 90)
+  if angle ~= 90 and angle ~= 180 and angle ~= 270 and angle ~= -90 then C.fail("angle must be 90, 180, 270, or -90") end
+  app.activeSprite = sprite
+  app.command.Rotate { angle=angle, ui=false }
+  return { angle=angle, width=sprite.width, height=sprite.height }
+end
+
+local function resolve_open_sprite(params, prefix)
+  local id = params[prefix .. "Id"]
+  local filename = params[prefix .. "Filename"]
+  for _, sprite in ipairs(app.sprites) do
+    if id ~= nil and tostring(sprite.id) == tostring(id) then return sprite end
+    if filename ~= nil and sprite.filename == filename then return sprite end
+  end
+  C.fail(prefix .. " sprite was not found among open documents")
+end
+
+local function copy_between_sprites(_, params)
+  local source = resolve_open_sprite(params, "source")
+  local target = resolve_open_sprite(params, "target")
+  local source_layer = C.find_layer(source.layers, params.sourceLayer)
+  if not source_layer or source_layer.isGroup or source_layer.isTilemap then C.fail("Source drawable layer was not found") end
+  local source_frame = C.clamp(C.integer(params.sourceFrame, 1), 1, #source.frames)
+  local source_cel = source_layer:cel(source_frame)
+  if not source_cel then C.fail("Source cel does not exist") end
+  local target_layer = params.targetLayer and C.find_layer(target.layers, params.targetLayer) or nil
+  if not target_layer then
+    target_layer = target:newLayer()
+    target_layer.name = tostring(params.targetLayer or source_layer.name)
+  end
+  if target_layer.isGroup or target_layer.isTilemap then C.fail("Target must be a normal drawable layer") end
+  local target_frame = C.clamp(C.integer(params.targetFrame, 1), 1, #target.frames)
+  local created
+  app.transaction("Auvrynt Live Copy Between Sprites", function()
+    local existing = target_layer:cel(target_frame)
+    if existing then target:deleteCel(existing) end
+    created = target:newCel(
+      target_layer,
+      target_frame,
+      source_cel.image,
+      Point(source_cel.position.x + C.integer(params.offsetX, 0), source_cel.position.y + C.integer(params.offsetY, 0))
+    )
+    created.opacity = source_cel.opacity
+    created.zIndex = source_cel.zIndex
+  end)
+  app.activeSprite, app.activeLayer, app.activeFrame = target, target_layer, target.frames[target_frame]
+  return {
+    sourceId=tostring(source.id), targetId=tostring(target.id),
+    sourceLayer=source_layer.name, targetLayer=target_layer.name,
+    sourceFrame=source_frame, targetFrame=target_frame,
+    x=created.position.x, y=created.position.y,
+  }
+end
+
+M.handlers = {
+  set_frame_range_duration=set_frame_range_duration,
+  duplicate_frame=duplicate_frame,
+  reverse_frames=reverse_frames,
+  shift_cel=shift_cel,
+  flip_sprite=flip_sprite,
+  rotate_sprite=rotate_sprite,
+  copy_between_sprites=copy_between_sprites,
+}
+
+return M

package/extensions/auvrynt_bridge/live_commands.lua

@@ -0,0 +1,24 @@
+local M = {}
+local handlers = {}
+
+for _, module_name in ipairs({ "live_drawing", "live_structure", "live_palette_template", "live_selection", "live_animation", "live_analysis", "live_document", "live_effects" }) do
+  local module = require(module_name)
+  for name, handler in pairs(module.handlers) do handlers[name] = handler end
+end
+
+function M.run(sprite, request)
+  local command = request.liveCommand
+  if type(command) ~= "string" or command == "" then error("liveCommand is required", 0) end
+  local handler = handlers[command]
+  if not handler then error("Unsupported live command: " .. command, 0) end
+  return handler(sprite, request.arguments or {})
+end
+
+function M.names()
+  local result = {}
+  for name in pairs(handlers) do result[#result+1] = name end
+  table.sort(result)
+  return result
+end
+
+return M

package/extensions/auvrynt_bridge/live_common.lua

@@ -0,0 +1,130 @@
+local M = {}
+local pc = app.pixelColor
+
+function M.fail(message) error(message, 0) end
+function M.clamp(value, minimum, maximum) return math.max(minimum, math.min(maximum, value)) end
+function M.integer(value, fallback) return math.floor(tonumber(value) or fallback or 0) end
+function M.sequence_length(value)
+  if value == nil then return nil end
+  local ok, count = pcall(function() return #value end)
+  return ok and count or nil
+end
+
+function M.color_from_hex(value, fallback)
+  if type(value) ~= "string" then return fallback or Color() end
+  local hex = value:gsub("^#", "")
+  if #hex ~= 6 and #hex ~= 8 then M.fail("Colors must use #RRGGBB or #RRGGBBAA") end
+  local r, g, b = tonumber(hex:sub(1, 2), 16), tonumber(hex:sub(3, 4), 16), tonumber(hex:sub(5, 6), 16)
+  local a = #hex == 8 and tonumber(hex:sub(7, 8), 16) or 255
+  if not r or not g or not b or not a then M.fail("Invalid hexadecimal color") end
+  return Color { r=r, g=g, b=b, a=a }
+end
+
+function M.color_to_hex(color)
+  return string.format("#%02X%02X%02X%02X", color.red, color.green, color.blue, color.alpha)
+end
+
+function M.pixel_to_color(sprite, pixel)
+  if sprite.colorMode == ColorMode.RGB then
+    return Color { r=pc.rgbaR(pixel), g=pc.rgbaG(pixel), b=pc.rgbaB(pixel), a=pc.rgbaA(pixel) }
+  elseif sprite.colorMode == ColorMode.GRAY then
+    local value = pc.grayaV(pixel)
+    return Color { r=value, g=value, b=value, a=pc.grayaA(pixel) }
+  end
+  local palette = sprite.palettes[1]
+  local color = palette:getColor(pixel)
+  return Color { r=color.red, g=color.green, b=color.blue, a=pixel == sprite.transparentColor and 0 or color.alpha }
+end
+
+function M.color_to_pixel(sprite, color)
+  if sprite.colorMode == ColorMode.RGB then return pc.rgba(color.red, color.green, color.blue, color.alpha) end
+  if sprite.colorMode == ColorMode.GRAY then
+    local gray = math.floor((color.red*299 + color.green*587 + color.blue*114)/1000)
+    return pc.graya(gray, color.alpha)
+  end
+  if color.alpha == 0 then return sprite.transparentColor end
+  local palette, best, distance = sprite.palettes[1], 0, math.huge
+  for index=0,#palette-1 do
+    local candidate = palette:getColor(index)
+    local dr, dg, db, da = candidate.red-color.red, candidate.green-color.green, candidate.blue-color.blue, candidate.alpha-color.alpha
+    local current = dr*dr + dg*dg + db*db + da*da
+    if current < distance then best, distance = index, current end
+  end
+  return best
+end
+
+function M.pixel_alpha(sprite, pixel)
+  if sprite.colorMode == ColorMode.RGB then return pc.rgbaA(pixel) end
+  if sprite.colorMode == ColorMode.GRAY then return pc.grayaA(pixel) end
+  if pixel == sprite.transparentColor then return 0 end
+  return sprite.palettes[1]:getColor(pixel).alpha
+end
+
+function M.find_layer(items, name_or_id)
+  if name_or_id == nil then return nil end
+  for _, layer in ipairs(items) do
+    if layer.name == name_or_id or tostring(layer.id) == tostring(name_or_id) then return layer end
+    if layer.isGroup then
+      local nested = M.find_layer(layer.layers, name_or_id)
+      if nested then return nested end
+    end
+  end
+  return nil
+end
+
+function M.target_layer(sprite, params)
+  local layer = params.layer and M.find_layer(sprite.layers, params.layer) or app.activeLayer or sprite.layers[1]
+  if not layer then M.fail("Layer was not found") end
+  if layer.isGroup or layer.isTilemap then M.fail("A normal drawable layer is required") end
+  return layer
+end
+
+function M.target_frame_number(sprite, params)
+  local number = M.integer(params.frame, app.activeFrame and app.activeFrame.frameNumber or 1)
+  if number < 1 or number > #sprite.frames then M.fail("Frame is outside the sprite") end
+  return number
+end
+
+function M.get_canvas_cel(sprite, layer, frame_number, create)
+  local cel = layer:cel(frame_number)
+  if not cel and create then
+    local image = Image(sprite.spec)
+    image:clear()
+    cel = sprite:newCel(layer, frame_number, image, Point(0, 0))
+  end
+  if cel and create and (cel.position.x ~= 0 or cel.position.y ~= 0 or cel.image.width ~= sprite.width or cel.image.height ~= sprite.height) then
+    local image = Image(sprite.spec)
+    image:clear()
+    image:drawImage(cel.image, cel.position)
+    cel.image = image
+    cel.position = Point(0, 0)
+  end
+  return cel
+end
+
+function M.selection_allows(sprite, x, y)
+  local selection = sprite.selection
+  return selection == nil or selection.isEmpty or selection:contains(Point(x, y))
+end
+
+function M.active_target(sprite, params)
+  local layer, frame_number = M.target_layer(sprite, params), M.target_frame_number(sprite, params)
+  app.activeSprite, app.activeLayer, app.activeFrame = sprite, layer, sprite.frames[frame_number]
+  return layer, frame_number
+end
+
+function M.read_canvas(sprite, params)
+  local frame_number = M.target_frame_number(sprite, params)
+  local image = Image(sprite.spec)
+  image:clear()
+  if params.composite == true then
+    image:drawSprite(sprite, frame_number, Point(0, 0))
+  else
+    local layer = M.target_layer(sprite, params)
+    local cel = layer:cel(frame_number)
+    if cel then image:drawImage(cel.image, cel.position) end
+  end
+  return image, frame_number
+end
+
+return M

package/extensions/auvrynt_bridge/live_document.lua

@@ -0,0 +1,78 @@
+local C = require("live_common")
+local M = {}
+
+local function resize_sprite(sprite, params)
+  local width = C.clamp(C.integer(params.width, sprite.width), 1, 8192)
+  local height = C.clamp(C.integer(params.height, sprite.height), 1, 8192)
+  app.activeSprite = sprite
+  sprite:resize(width, height)
+  return { width=sprite.width, height=sprite.height }
+end
+
+local function crop_sprite(sprite, params)
+  local x = C.integer(params.x, 0)
+  local y = C.integer(params.y, 0)
+  local width = C.integer(params.width, sprite.width)
+  local height = C.integer(params.height, sprite.height)
+  if width < 1 or height < 1 then C.fail("width and height must be positive") end
+  sprite:crop(Rectangle(x, y, width, height))
+  return { width=sprite.width, height=sprite.height, source={x=x,y=y,width=width,height=height} }
+end
+
+local function flatten_sprite(sprite, _)
+  sprite:flatten()
+  app.activeLayer = sprite.layers[1]
+  return { layers=#sprite.layers, activeLayer=sprite.layers[1].name }
+end
+
+local function set_grid(sprite, params)
+  local x = C.integer(params.x, 0)
+  local y = C.integer(params.y, 0)
+  local width = C.clamp(C.integer(params.width, 8), 1, 8192)
+  local height = C.clamp(C.integer(params.height, 8), 1, 8192)
+  sprite.gridBounds = Rectangle(x, y, width, height)
+  return { x=x, y=y, width=width, height=height }
+end
+
+local function create_tileset_template(_, params)
+  local tile_size = C.clamp(C.integer(params.tileSize, 16), 1, 256)
+  local columns = C.clamp(C.integer(params.columns, 8), 1, 128)
+  local rows = C.clamp(C.integer(params.rows, 8), 1, 128)
+  local width, height = tile_size * columns, tile_size * rows
+  if width > 8192 or height > 8192 then C.fail("Tileset template exceeds Aseprite's 8192px bridge limit") end
+  local sprite = Sprite(width, height, ColorMode.RGB)
+  app.activeSprite = sprite
+  app.transaction("Auvrynt Tileset Template", function()
+    sprite.layers[1].name = "tiles"
+    sprite.gridBounds = Rectangle(0, 0, tile_size, tile_size)
+    local grid = sprite:newLayer()
+    grid.name = "grid-guide"
+    grid.opacity = C.clamp(C.integer(params.gridOpacity, 64), 0, 255)
+    local image = Image(sprite.spec)
+    image:clear()
+    local color = C.color_to_pixel(sprite, C.color_from_hex(params.gridColor or "#FFFFFFFF"))
+    for column=1,columns-1 do
+      local x = column * tile_size
+      for y=0,height-1 do image:drawPixel(x, y, color) end
+    end
+    for row=1,rows-1 do
+      local y = row * tile_size
+      for x=0,width-1 do image:drawPixel(x, y, color) end
+    end
+    sprite:newCel(grid, 1, image, Point(0, 0))
+  end)
+  return {
+    id=tostring(sprite.id), tileSize=tile_size, columns=columns, rows=rows,
+    width=width, height=height, layers={"tiles","grid-guide"},
+  }
+end
+
+M.handlers = {
+  resize_sprite=resize_sprite,
+  crop_sprite=crop_sprite,
+  flatten_sprite=flatten_sprite,
+  set_grid=set_grid,
+  create_tileset_template=create_tileset_template,
+}
+
+return M

package/extensions/auvrynt_bridge/live_drawing.lua

@@ -0,0 +1,125 @@
+local C = require("live_common")
+local M = {}
+
+local function get_pixel(sprite, params)
+  local x, y = C.integer(params.x, -1), C.integer(params.y, -1)
+  if x < 0 or y < 0 or x >= sprite.width or y >= sprite.height then C.fail("Pixel is outside the sprite") end
+  local image, frame_number = C.read_canvas(sprite, params)
+  local color = C.pixel_to_color(sprite, image:getPixel(x, y))
+  return { x=x, y=y, frame=frame_number, color=C.color_to_hex(color), r=color.red, g=color.green, b=color.blue, a=color.alpha }
+end
+
+local function get_image_data(sprite, params)
+  local image, frame_number = C.read_canvas(sprite, params)
+  local region = params.region or {}
+  local x = C.clamp(C.integer(region.x, 0), 0, sprite.width - 1)
+  local y = C.clamp(C.integer(region.y, 0), 0, sprite.height - 1)
+  local width = C.clamp(C.integer(region.width, sprite.width - x), 1, sprite.width - x)
+  local height = C.clamp(C.integer(region.height, sprite.height - y), 1, sprite.height - y)
+  if width * height > 16384 then C.fail("Live image readback is limited to 16384 pixels") end
+  local rows = {}
+  for row=0,height-1 do
+    local output = {}
+    for column=0,width-1 do output[column+1] = C.color_to_hex(C.pixel_to_color(sprite, image:getPixel(x+column, y+row))) end
+    rows[row+1] = output
+  end
+  return { frame=frame_number, x=x, y=y, width=width, height=height, composite=params.composite == true, rows=rows }
+end
+
+local function draw_tool(sprite, params, tool, point_count)
+  local layer, frame_number = C.active_target(sprite, params)
+  local points = { Point(C.integer(params.x, 0), C.integer(params.y, 0)) }
+  if point_count == 2 then
+    local x2 = params.x2 ~= nil and C.integer(params.x2, 0) or C.integer(params.x, 0) + C.integer(params.width, 1) - 1
+    local y2 = params.y2 ~= nil and C.integer(params.y2, 0) or C.integer(params.y, 0) + C.integer(params.height, 1) - 1
+    points[2] = Point(x2, y2)
+  end
+  app.transaction("Auvrynt Live " .. tool, function()
+    app.useTool {
+      tool=tool,
+      color=C.color_from_hex(params.color, app.fgColor),
+      opacity=C.clamp(C.integer(params.opacity, 255), 0, 255),
+      brush=Brush(C.clamp(C.integer(params.brushSize, 1), 1, 256)),
+      points=points,
+      layer=layer,
+      frame=sprite.frames[frame_number],
+    }
+  end)
+  return { tool=tool, frame=frame_number, layer=layer.name }
+end
+
+local function clear_image(sprite, params)
+  local layer, frame_number = C.active_target(sprite, params)
+  local fill = params.color and C.color_to_pixel(sprite, C.color_from_hex(params.color)) or C.color_to_pixel(sprite, Color{r=0,g=0,b=0,a=0})
+  local changed = 0
+  app.transaction("Auvrynt Live Clear", function()
+    local cel = C.get_canvas_cel(sprite, layer, frame_number, true)
+    for y=0,sprite.height-1 do
+      for x=0,sprite.width-1 do
+        if C.selection_allows(sprite, x, y) then cel.image:drawPixel(x, y, fill) changed = changed + 1 end
+      end
+    end
+  end)
+  return { changed=changed, frame=frame_number, layer=layer.name }
+end
+
+local function replace_color(sprite, params)
+  if type(params.fromColor) ~= "string" or type(params.toColor) ~= "string" then C.fail("fromColor and toColor are required") end
+  local layer, frame_number = C.active_target(sprite, params)
+  local from_pixel = C.color_to_pixel(sprite, C.color_from_hex(params.fromColor))
+  local to_pixel = C.color_to_pixel(sprite, C.color_from_hex(params.toColor))
+  local changed = 0
+  app.transaction("Auvrynt Live Replace Color", function()
+    local cel = C.get_canvas_cel(sprite, layer, frame_number, true)
+    for y=0,sprite.height-1 do
+      for x=0,sprite.width-1 do
+        if C.selection_allows(sprite, x, y) and cel.image:getPixel(x, y) == from_pixel then
+          cel.image:drawPixel(x, y, to_pixel)
+          changed = changed + 1
+        end
+      end
+    end
+  end)
+  return { changed=changed, frame=frame_number, layer=layer.name }
+end
+
+local function outline(sprite, params)
+  if type(params.color) ~= "string" then C.fail("color is required") end
+  local layer, frame_number = C.active_target(sprite, params)
+  local outline_pixel = C.color_to_pixel(sprite, C.color_from_hex(params.color))
+  local neighbors = params.diagonal == true
+    and { {-1,-1},{0,-1},{1,-1},{-1,0},{1,0},{-1,1},{0,1},{1,1} }
+    or { {0,-1},{-1,0},{1,0},{0,1} }
+  local changed = 0
+  app.transaction("Auvrynt Live Outline", function()
+    local cel = C.get_canvas_cel(sprite, layer, frame_number, true)
+    local source = Image(cel.image)
+    for y=0,sprite.height-1 do
+      for x=0,sprite.width-1 do
+        if C.selection_allows(sprite, x, y) and C.pixel_alpha(sprite, source:getPixel(x, y)) == 0 then
+          local adjacent = false
+          for _, offset in ipairs(neighbors) do
+            local nx, ny = x + offset[1], y + offset[2]
+            if nx >= 0 and ny >= 0 and nx < sprite.width and ny < sprite.height and C.pixel_alpha(sprite, source:getPixel(nx, ny)) > 0 then adjacent = true break end
+          end
+          if adjacent then cel.image:drawPixel(x, y, outline_pixel) changed = changed + 1 end
+        end
+      end
+    end
+  end)
+  return { changed=changed, frame=frame_number, layer=layer.name, diagonal=params.diagonal == true }
+end
+
+M.handlers = {
+  get_pixel=get_pixel,
+  get_image_data=get_image_data,
+  draw_line=function(sprite, params) return draw_tool(sprite, params, "line", 2) end,
+  draw_rect=function(sprite, params) return draw_tool(sprite, params, params.filled == false and "rectangle" or "filled_rectangle", 2) end,
+  draw_ellipse=function(sprite, params) return draw_tool(sprite, params, params.filled == false and "ellipse" or "filled_ellipse", 2) end,
+  flood_fill=function(sprite, params) return draw_tool(sprite, params, "paint_bucket", 1) end,
+  clear_image=clear_image,
+  replace_color=replace_color,
+  outline=outline,
+}
+
+return M