pixelweaver 0.1.0

package/plugins/builtin/line-tool.ts

@@ -0,0 +1,267 @@
+/**
+ * Line Tool Plugin -- draws straight lines between two points.
+ *
+ * Registers:
+ *   - Command: `draw_line` (tier: 'frame')
+ *   - Tool: `line` (standard Bresenham)
+ *   - Tool: `line-nodoubles` (no-doubles Bresenham variant)
+ *
+ * Both tools share the `draw_line` command. The `algorithm` param determines
+ * which Bresenham variant is used. Click sets the start point, drag previews,
+ * release draws the final line.
+ */
+
+import type { PluginModule } from '../../src/lib/core/plugin-loader.js';
+import {
+  bresenhamLine,
+  bresenhamLineNoDoubles,
+  snapshotPixels,
+  applyPixels,
+  hexToRgba,
+  makeSnapshotUndo,
+} from './drawing-utils.js';
+import { setShapePreview, clearShapePreview } from '../../src/lib/canvas/shape-preview-state.svelte.js';
+import LineIcon from '~icons/lucide/pen-line';
+
+/**
+ * Snap a point to the nearest of 8 directions (horizontal, vertical, 4 diagonals)
+ * from a given origin. Used for Shift+drag line constraint.
+ * (Same algorithm as make-stroke-tool.ts -- duplicated to avoid exporting internals.)
+ */
+function snapTo8Direction(
+  originX: number,
+  originY: number,
+  x: number,
+  y: number,
+): { x: number; y: number } {
+  const dx = x - originX;
+  const dy = y - originY;
+  if (dx === 0 && dy === 0) return { x: originX, y: originY };
+  const angle = Math.atan2(dy, dx);
+  const snapped = Math.round(angle / (Math.PI / 4)) * (Math.PI / 4);
+  const dist = dx * Math.cos(snapped) + dy * Math.sin(snapped);
+  return {
+    x: originX + Math.round(dist * Math.cos(snapped)),
+    y: originY + Math.round(dist * Math.sin(snapped)),
+  };
+}
+
+export const lineToolPlugin: PluginModule = {
+  name: 'builtin/line',
+  version: '1.0.0',
+  dependencies: [],
+  register(api) {
+    api.addCommand('draw_line', {
+      tier: 'frame',
+      icon: LineIcon,
+
+      execute(params, ctx) {
+        const buffer = ctx.getActiveBuffer?.();
+        if (!buffer) return;
+
+        const algorithm = params["algorithm"];
+        const x0 = params["x0"];
+        const y0 = params["y0"];
+        const x1 = params["x1"];
+        const y1 = params["y1"];
+        const { r, g, b, a } = hexToRgba(params["color"]);
+
+        const lineFn = algorithm === 'nodoubles' ? bresenhamLineNoDoubles : bresenhamLine;
+        const points = lineFn(x0, y0, x1, y1);
+
+        const snapshot = snapshotPixels(buffer, points);
+        const pixels = points.map((p) => ({ ...p, r, g, b, a }));
+        applyPixels(buffer, pixels);
+        return snapshot;
+      },
+
+      undo: makeSnapshotUndo(),
+
+      describe(params) {
+        return `Drew line from (${String(params["x0"])},${String(params["y0"])}) to (${String(params["x1"])},${String(params["y1"])})`;
+      },
+    });
+
+    api.addToolbarItem('toolbar:drawing-tools:line', {
+      toolbarId: 'drawing-tools',
+      kind: 'tool',
+      targetId: 'line',
+      group: 'draw',
+      order: 40,
+    });
+
+    // --- Standard Bresenham tool ---
+    let lineDrawing = false;
+    let lineStartX = 0;
+    let lineStartY = 0;
+    let lineColor = '';
+
+    api.addTool('line', {
+      icon: LineIcon,
+      cursor: 'crosshair',
+
+      onPointerDown(_e, ctx) {
+        lineDrawing = true;
+        lineStartX = ctx.canvasX;
+        lineStartY = ctx.canvasY;
+        lineColor = ctx.color;
+      },
+
+      onPointerMove(e, ctx) {
+        if (!lineDrawing) return;
+
+        // Shift constrains to nearest 45-degree angle
+        let endX = ctx.canvasX;
+        let endY = ctx.canvasY;
+        if (e.shiftKey) {
+          const snapped = snapTo8Direction(lineStartX, lineStartY, endX, endY);
+          endX = snapped.x;
+          endY = snapped.y;
+        }
+
+        // Ctrl draws from midpoint: start becomes midpoint, mirror the start
+        let previewStartX = lineStartX;
+        let previewStartY = lineStartY;
+        if (e.ctrlKey) {
+          previewStartX = 2 * lineStartX - endX;
+          previewStartY = 2 * lineStartY - endY;
+        }
+
+        setShapePreview({
+          type: 'line',
+          startX: previewStartX,
+          startY: previewStartY,
+          endX,
+          endY,
+          color: lineColor,
+          filled: false,
+        });
+      },
+
+      onPointerUp(e, ctx) {
+        if (!lineDrawing) return;
+        lineDrawing = false;
+        clearShapePreview();
+
+        // Shift constrains to nearest 45-degree angle
+        let endX = ctx.canvasX;
+        let endY = ctx.canvasY;
+        if (e.shiftKey) {
+          const snapped = snapTo8Direction(lineStartX, lineStartY, endX, endY);
+          endX = snapped.x;
+          endY = snapped.y;
+        }
+
+        // Ctrl draws from midpoint: start becomes midpoint, mirror the start
+        let finalStartX = lineStartX;
+        let finalStartY = lineStartY;
+        if (e.ctrlKey) {
+          finalStartX = 2 * lineStartX - endX;
+          finalStartY = 2 * lineStartY - endY;
+        }
+
+        ctx.api.dispatch({
+          type: 'draw_line',
+          plugin: 'builtin/line',
+          version: '1.0.0',
+          params: {
+            x0: finalStartX,
+            y0: finalStartY,
+            x1: endX,
+            y1: endY,
+            color: lineColor,
+            algorithm: 'standard',
+            layerId: '',
+          },
+        });
+      },
+    });
+
+    // --- No-doubles Bresenham tool ---
+    let ndDrawing = false;
+    let ndStartX = 0;
+    let ndStartY = 0;
+    let ndColor = '';
+
+    api.addTool('line-nodoubles', {
+      icon: LineIcon,
+      cursor: 'crosshair',
+
+      onPointerDown(_e, ctx) {
+        ndDrawing = true;
+        ndStartX = ctx.canvasX;
+        ndStartY = ctx.canvasY;
+        ndColor = ctx.color;
+      },
+
+      onPointerMove(e, ctx) {
+        if (!ndDrawing) return;
+
+        // Shift constrains to nearest 45-degree angle
+        let endX = ctx.canvasX;
+        let endY = ctx.canvasY;
+        if (e.shiftKey) {
+          const snapped = snapTo8Direction(ndStartX, ndStartY, endX, endY);
+          endX = snapped.x;
+          endY = snapped.y;
+        }
+
+        // Ctrl draws from midpoint: start becomes midpoint, mirror the start
+        let previewStartX = ndStartX;
+        let previewStartY = ndStartY;
+        if (e.ctrlKey) {
+          previewStartX = 2 * ndStartX - endX;
+          previewStartY = 2 * ndStartY - endY;
+        }
+
+        setShapePreview({
+          type: 'line',
+          startX: previewStartX,
+          startY: previewStartY,
+          endX,
+          endY,
+          color: ndColor,
+          filled: false,
+        });
+      },
+
+      onPointerUp(e, ctx) {
+        if (!ndDrawing) return;
+        ndDrawing = false;
+        clearShapePreview();
+
+        // Shift constrains to nearest 45-degree angle
+        let endX = ctx.canvasX;
+        let endY = ctx.canvasY;
+        if (e.shiftKey) {
+          const snapped = snapTo8Direction(ndStartX, ndStartY, endX, endY);
+          endX = snapped.x;
+          endY = snapped.y;
+        }
+
+        // Ctrl draws from midpoint: start becomes midpoint, mirror the start
+        let finalStartX = ndStartX;
+        let finalStartY = ndStartY;
+        if (e.ctrlKey) {
+          finalStartX = 2 * ndStartX - endX;
+          finalStartY = 2 * ndStartY - endY;
+        }
+
+        ctx.api.dispatch({
+          type: 'draw_line',
+          plugin: 'builtin/line',
+          version: '1.0.0',
+          params: {
+            x0: finalStartX,
+            y0: finalStartY,
+            x1: endX,
+            y1: endY,
+            color: ndColor,
+            algorithm: 'nodoubles',
+            layerId: '',
+          },
+        });
+      },
+    });
+  },
+};

package/plugins/builtin/make-stroke-tool.ts

@@ -0,0 +1,271 @@
+/**
+ * Stroke Tool Factory -- eliminates duplication between pencil and eraser tools.
+ *
+ * Both tools share identical structure: a command (execute/undo/describe),
+ * stroke state with Bresenham interpolation, pointer handlers, and toolbar
+ * registration. They differ only in configuration: command name, color
+ * resolution, icon, toolbar order, and describe verb.
+ *
+ * Usage:
+ *   export const myToolPlugin = makeStrokeTool({ ... config ... });
+ */
+
+import type { PluginModule } from '../../src/lib/core/plugin-loader.js';
+import type { CommandType } from '../../src/lib/core/command-params.js';
+import type { ToolContext, ToolOption } from '../../src/lib/core/plugin-types.js';
+import type { PixelData } from './drawing-utils.js';
+import { bresenhamLine, snapshotPixels, applyPixels, makeSnapshotUndo, hexToRgba } from './drawing-utils.js';
+import { getToolOptionValue } from '../../src/lib/core/tool-options-state.svelte.js';
+import { getForegroundColor, getBackgroundColor } from '../../src/lib/color/color-state.svelte.js';
+
+/**
+ * Snap a point to the nearest of 8 directions (horizontal, vertical, 4 diagonals)
+ * from a given origin. Used for Shift+drag line constraint.
+ *
+ * Calculates the angle from origin to the point, rounds to the nearest 45-degree
+ * increment, then projects the point onto that axis-aligned or diagonal line.
+ */
+function snapTo8Direction(
+  originX: number,
+  originY: number,
+  x: number,
+  y: number,
+): { x: number; y: number } {
+  const dx = x - originX;
+  const dy = y - originY;
+
+  // No movement -- nothing to snap
+  if (dx === 0 && dy === 0) return { x: originX, y: originY };
+
+  // atan2 gives angle in radians; convert to 0..360 range
+  const angle = Math.atan2(dy, dx);
+  // Round to nearest 45 degrees (PI/4 radians)
+  const snapped = Math.round(angle / (Math.PI / 4)) * (Math.PI / 4);
+
+  // Distance from origin to the current point, projected onto the snapped direction
+  const dist = dx * Math.cos(snapped) + dy * Math.sin(snapped);
+
+  return {
+    x: originX + Math.round(dist * Math.cos(snapped)),
+    y: originY + Math.round(dist * Math.sin(snapped)),
+  };
+}
+
+/** RGBA color value returned by resolveColor. */
+export interface RGBA {
+  r: number;
+  g: number;
+  b: number;
+  a: number;
+}
+
+/** Configuration for a stroke-based drawing tool. */
+export interface StrokeToolConfig<T extends string = string> {
+  /** Plugin name, e.g. 'builtin/pencil' */
+  pluginName: string;
+  /** Command name, e.g. 'draw_pixels' -- typed as a literal when T extends CommandType */
+  commandName: T;
+  /** Tool ID, e.g. 'pencil' */
+  toolId: string;
+  /** Svelte icon component */
+  icon: string | import('svelte').Component;
+  /** Toolbar sort order within the group */
+  toolbarOrder: number;
+  /** Toolbar group, e.g. 'draw' */
+  toolbarGroup: string;
+  /** Verb for describe(), e.g. 'Drew' or 'Erased' */
+  describeVerb: string;
+  /** Resolve the RGBA color for a stroke. Called once at pointer-down and cached. */
+  resolveColor: (ctx: ToolContext) => RGBA;
+}
+
+/**
+ * Create a PluginModule for a stroke-based drawing tool.
+ *
+ * The returned plugin registers a command (with undo support via snapshotPixels)
+ * and a tool with Bresenham-interpolated pointer handlers.
+ *
+ * When T extends CommandType (a known command in CommandParamsMap), the typed
+ * addCommand overload is used and params are fully typed. The string fallback
+ * supports future tools whose command isn't yet in the map.
+ */
+export function makeStrokeTool<T extends CommandType>(config: StrokeToolConfig<T>): PluginModule;
+export function makeStrokeTool(config: StrokeToolConfig<string>): PluginModule;
+export function makeStrokeTool(config: StrokeToolConfig<string>): PluginModule {
+  return {
+    name: config.pluginName,
+    version: '1.0.0',
+    dependencies: [],
+    register(api) {
+      api.addCommand(config.commandName, {
+        tier: 'frame',
+
+        execute(params, ctx) {
+          const buffer = ctx.getActiveBuffer?.();
+          if (!buffer) return;
+
+          const pixels = params["pixels"] as PixelData[];
+          const points = pixels.map(p => ({ x: p.x, y: p.y }));
+          const snapshot = snapshotPixels(buffer, points);
+          applyPixels(buffer, pixels);
+          return snapshot;
+        },
+
+        undo: makeSnapshotUndo(),
+
+        describe(params) {
+          const pixels = params["pixels"] as PixelData[];
+          return `${config.describeVerb} ${String(pixels.length)} pixel(s)`;
+        },
+      });
+
+      // -- Stroke state for pointer handlers --
+      let drawing = false;
+      let lastX = 0;
+      let lastY = 0;
+      // Start point of the stroke, used for Shift+drag 8-direction constraint
+      let startX = 0;
+      let startY = 0;
+      let strokePixels: Map<string, PixelData> = new Map();
+      let strokeColor: RGBA = { r: 0, g: 0, b: 0, a: 0 };
+      let strokeLayerId = '';
+      // Ctrl+drag swaps the color: pencil uses bg instead of fg,
+      // eraser uses fg instead of transparent. Latched at stroke start.
+      let ctrlSwap = false;
+
+      api.addToolbarItem(`toolbar:drawing-tools:${config.toolId}`, {
+        toolbarId: 'drawing-tools',
+        kind: 'tool',
+        targetId: config.toolId,
+        group: config.toolbarGroup,
+        order: config.toolbarOrder,
+      });
+
+      /** Brush size preset choices for stroke tools. */
+      const brushSizeOption: ToolOption = {
+        id: 'size',
+        label: 'Size',
+        type: 'select',
+        choices: [
+          { value: 1, label: '1' },
+          { value: 2, label: '2' },
+          { value: 4, label: '4' },
+          { value: 8, label: '8' },
+        ],
+        defaultValue: 1,
+      };
+
+      /**
+       * Stamp an NxN square of pixels centered on (cx, cy) into the stroke map.
+       * For size 1, this is just the single pixel. For larger sizes, the square
+       * extends floor((size-1)/2) pixels in each direction from center.
+       *
+       * Alpha is modulated by pointer pressure (0-1). A pressure of 0 means
+       * "no pressure support" (e.g. mouse) and is treated as full opacity.
+       */
+      function stampSquare(
+        cx: number,
+        cy: number,
+        size: number,
+        color: RGBA,
+        pressure: number,
+        target: Map<string, PixelData>,
+      ): void {
+        const half = Math.floor((size - 1) / 2);
+        const { r, g, b, a } = color;
+        // Mice and trackpads report pressure 0; treat as full opacity.
+        const effectivePressure = pressure > 0 ? pressure : 1.0;
+        const modulatedAlpha = Math.round(a * effectivePressure);
+        for (let dy = -half; dy <= -half + size - 1; dy++) {
+          for (let dx = -half; dx <= -half + size - 1; dx++) {
+            const px = cx + dx;
+            const py = cy + dy;
+            const key = `${String(px)},${String(py)}`;
+            if (!target.has(key)) {
+              target.set(key, { x: px, y: py, r, g, b, a: modulatedAlpha });
+            }
+          }
+        }
+      }
+
+      api.addTool(config.toolId, {
+        icon: config.icon,
+        cursor: 'crosshair',
+        options: [brushSizeOption],
+
+        onPointerDown(_e, ctx) {
+          drawing = true;
+          lastX = ctx.canvasX;
+          lastY = ctx.canvasY;
+          startX = ctx.canvasX;
+          startY = ctx.canvasY;
+          ctrlSwap = _e.ctrlKey;
+
+          if (ctrlSwap) {
+            // Ctrl held: swap the color. If the tool normally paints transparent
+            // (eraser), paint with foreground instead. Otherwise (pencil), paint
+            // with the background color.
+            const normal = config.resolveColor(ctx);
+            const isTransparent = normal.r === 0 && normal.g === 0 && normal.b === 0 && normal.a === 0;
+            strokeColor = isTransparent
+              ? hexToRgba(getForegroundColor())
+              : hexToRgba(getBackgroundColor());
+          } else {
+            strokeColor = config.resolveColor(ctx);
+          }
+
+          strokeLayerId = '';
+          strokePixels = new Map();
+
+          // Stamp the first point at the current brush size
+          const size = (getToolOptionValue(config.toolId, 'size') as number) || 1;
+          stampSquare(ctx.canvasX, ctx.canvasY, size, strokeColor, ctx.pressure, strokePixels);
+        },
+
+        onPointerMove(e, ctx) {
+          if (!drawing) return;
+
+          // Shift+drag: constrain to nearest 8-direction line from stroke start
+          let targetX = ctx.canvasX;
+          let targetY = ctx.canvasY;
+          if (e.shiftKey) {
+            const snapped = snapTo8Direction(startX, startY, ctx.canvasX, ctx.canvasY);
+            targetX = snapped.x;
+            targetY = snapped.y;
+          }
+
+          const size = (getToolOptionValue(config.toolId, 'size') as number) || 1;
+          // Interpolate between last position and current to fill gaps
+          const line = bresenhamLine(lastX, lastY, targetX, targetY);
+          for (const p of line) {
+            stampSquare(p.x, p.y, size, strokeColor, ctx.pressure, strokePixels);
+          }
+
+          lastX = targetX;
+          lastY = targetY;
+        },
+
+        onPointerUp(_e, ctx) {
+          if (!drawing) return;
+          drawing = false;
+          ctrlSwap = false;
+
+          const pixels = Array.from(strokePixels.values());
+          if (pixels.length === 0) return;
+
+          ctx.api.dispatch({
+            type: config.commandName,
+            plugin: config.pluginName,
+            version: '1.0.0',
+            params: {
+              pixels,
+              layerId: strokeLayerId,
+            },
+          });
+
+          strokePixels = new Map();
+        },
+      });
+    },
+  };
+}

package/plugins/builtin/noise-dither.test.ts

@@ -0,0 +1,151 @@
+/**
+ * Tests for noise and dither tools.
+ *
+ * Covers noise density, seeded reproducibility, and dither patterns.
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import { PixelBuffer } from '../../src/lib/canvas/pixel-buffer.js';
+import { commandRegistry } from '../../src/lib/core/registries.svelte.js';
+import { dispatch, undoLast, _resetForTesting as resetDispatcher, setContext } from '../../src/lib/core/dispatcher.js';
+import type { Command } from '../../src/lib/core/commands.js';
+import type { CommandType, ParamsOf } from '../../src/lib/core/command-params.js';
+import { createPluginAPI } from '../../src/lib/core/plugin-api.js';
+
+import { noiseToolPlugin, computeNoise, mulberry32 } from './noise-tool.js';
+import { ditherToolPlugin, computeDither } from './dither-tool.js';
+
+// --- Helpers ---
+
+// Typed overload: validates params when type is a known command literal
+function makeCommand<T extends CommandType>(type: T, params: ParamsOf<T>): Command;
+// String fallback: for dynamic/unknown command types in tests
+function makeCommand(type: string, params?: Record<string, unknown>): Command;
+function makeCommand(type: string, params: Record<string, unknown> = {}): Command {
+  return { type, plugin: 'test', version: '1.0.0', params, timestamp: Date.now(), id: crypto.randomUUID() };
+}
+
+function setupBuffer(width = 16, height = 16): PixelBuffer {
+  const buffer = new PixelBuffer(width, height);
+  setContext({ getActiveBuffer: () => buffer });
+  return buffer;
+}
+
+// --- Noise Tests ---
+
+describe('Noise Tool', () => {
+  beforeEach(() => {
+    resetDispatcher();
+    const api = createPluginAPI('builtin/noise');
+    noiseToolPlugin.register(api);
+  });
+
+  it('should register the draw_noise command', () => {
+    expect(commandRegistry.get('draw_noise')).toBeDefined();
+  });
+
+  it('noise at density 0.5 fills roughly half the pixels', () => {
+    const totalPixels = 32 * 32;
+    const pixels = computeNoise(0, 0, 32, 32, ['#FF0000'], 0.5, 42);
+
+    // Allow +/- 15% tolerance for statistical variation
+    const ratio = pixels.length / totalPixels;
+    expect(ratio).toBeGreaterThan(0.35);
+    expect(ratio).toBeLessThan(0.65);
+  });
+
+  it('seeded noise is reproducible', () => {
+    const seed = 12345;
+    const a = computeNoise(0, 0, 16, 16, ['#FF0000', '#00FF00'], 0.5, seed);
+    const b = computeNoise(0, 0, 16, 16, ['#FF0000', '#00FF00'], 0.5, seed);
+
+    expect(a.length).toBe(b.length);
+    for (let i = 0; i < a.length; i++) {
+      expect(a[i]?.x).toBe(b[i]?.x);
+      expect(a[i]?.y).toBe(b[i]?.y);
+      expect(a[i]?.r).toBe(b[i]?.r);
+      expect(a[i]?.g).toBe(b[i]?.g);
+      expect(a[i]?.b).toBe(b[i]?.b);
+    }
+  });
+
+  it('noise at density 0 produces no pixels', () => {
+    const pixels = computeNoise(0, 0, 10, 10, ['#FF0000'], 0, 42);
+    expect(pixels.length).toBe(0);
+  });
+
+  it('mulberry32 PRNG produces values in [0, 1)', () => {
+    const rng = mulberry32(42);
+    for (let i = 0; i < 100; i++) {
+      const v = rng();
+      expect(v).toBeGreaterThanOrEqual(0);
+      expect(v).toBeLessThan(1);
+    }
+  });
+});
+
+// --- Dither Tests ---
+
+describe('Dither Tool', () => {
+  beforeEach(() => {
+    resetDispatcher();
+    const api = createPluginAPI('builtin/dither');
+    ditherToolPlugin.register(api);
+  });
+
+  it('should register the draw_dither command', () => {
+    expect(commandRegistry.get('draw_dither')).toBeDefined();
+  });
+
+  it('dither 2x2 produces expected pattern', () => {
+    // 2x2 region with 2x2 matrix
+    const pixels = computeDither(0, 0, 2, 2, '#FF0000', '#0000FF', 2);
+
+    // Bayer 2x2: [[0, 2], [3, 1]]
+    // threshold = value / 4: [[0.0, 0.5], [0.75, 0.25]]
+    // With t=0.5 (the blend level), pixels with threshold < 0.5 get color1 (blue)
+    // (0,0): threshold 0.0 < 0.5 -> blue
+    // (1,0): threshold 0.5 NOT < 0.5 -> red
+    // (0,1): threshold 0.75 NOT < 0.5 -> red
+    // (1,1): threshold 0.25 < 0.5 -> blue
+    const p00 = pixels.find((p) => p.x === 0 && p.y === 0);
+    const p10 = pixels.find((p) => p.x === 1 && p.y === 0);
+    const p01 = pixels.find((p) => p.x === 0 && p.y === 1);
+    const p11 = pixels.find((p) => p.x === 1 && p.y === 1);
+    if (!p00 || !p10 || !p01 || !p11) throw new Error('missing dither pixel');
+
+    expect(p00.b).toBe(255); // blue
+    expect(p10.r).toBe(255); // red
+    expect(p01.r).toBe(255); // red
+    expect(p11.b).toBe(255); // blue
+  });
+
+  it('dither 4x4 produces a non-uniform pattern', () => {
+    const pixels = computeDither(0, 0, 4, 4, '#FFFFFF', '#000000', 4);
+    const colors = new Set<string>();
+    for (const p of pixels) {
+      colors.add(`${String(p.r)},${String(p.g)},${String(p.b)}`);
+    }
+    expect(colors.size).toBe(2);
+  });
+
+  it('dither command undoes correctly', () => {
+    const buffer = setupBuffer(4, 4);
+
+    dispatch(makeCommand('draw_dither', {
+      x: 0, y: 0, w: 4, h: 4,
+      color0: '#FF0000', color1: '#0000FF',
+      matrixSize: 2,
+      layerId: '',
+    }));
+
+    // Buffer should have dither pattern
+    const [r] = buffer.getPixel(0, 0);
+    expect(r === 255 || r === 0).toBe(true);
+
+    undoLast();
+
+    // Should be back to transparent
+    expect(buffer.getPixel(0, 0)).toEqual([0, 0, 0, 0]);
+  });
+});