diff --git a/components/canvas/canvas-with-tools.tsx b/components/canvas/canvas-with-tools.tsx
index 35cc9f3..d106d87 100644
--- a/components/canvas/canvas-with-tools.tsx
+++ b/components/canvas/canvas-with-tools.tsx
@@ -5,6 +5,7 @@ import { useCanvasStore, useLayerStore, useToolStore } from '@/store';
 import { useHistoryStore } from '@/store/history-store';
 import { useSelectionStore } from '@/store/selection-store';
 import { useTextStore } from '@/store/text-store';
+import { useContextMenuStore } from '@/store/context-menu-store';
 import { drawMarchingAnts } from '@/lib/selection-utils';
 import { getContext, drawGrid, drawCheckerboard } from '@/lib/canvas-utils';
 import { renderText } from '@/lib/text-utils';
@@ -15,6 +16,18 @@ import type { BaseTool } from '@/tools';
 import type { PointerState } from '@/types';
 import { cn } from '@/lib/utils';
 import { OnCanvasTextEditor } from './on-canvas-text-editor';
+import {
+  Scissors,
+  Copy,
+  Clipboard,
+  Undo2,
+  Redo2,
+  Layers,
+  SquareDashedMousePointer,
+  RotateCw,
+  FlipHorizontal,
+  FlipVertical,
+} from 'lucide-react';
 
 export function CanvasWithTools() {
   const canvasRef = useRef<HTMLCanvasElement>(null);
@@ -37,9 +50,10 @@ export function CanvasWithTools() {
 
   const { layers, getActiveLayer } = useLayerStore();
   const { activeTool, settings } = useToolStore();
-  const { executeCommand } = useHistoryStore();
-  const { activeSelection, selectionType, isMarching } = useSelectionStore();
+  const { executeCommand, canUndo, canRedo, undo, redo } = useHistoryStore();
+  const { activeSelection, selectionType, isMarching, clearSelection, selectAll } = useSelectionStore();
   const { textObjects, editingTextId, isOnCanvasEditorActive } = useTextStore();
+  const { showContextMenu } = useContextMenuStore();
   const [marchingOffset, setMarchingOffset] = useState(0);
 
   const [isPanning, setIsPanning] = useState(false);
@@ -421,6 +435,155 @@ export function CanvasWithTools() {
     }
   };
 
+  // Handle context menu
+  const handleContextMenu = (e: React.MouseEvent) => {
+    e.preventDefault();
+
+    const hasSelection = !!activeSelection;
+    const activeLayer = getActiveLayer();
+    const canMergeDown = activeLayer ? layers.findIndex((l) => l.id === activeLayer.id) < layers.length - 1 : false;
+
+    showContextMenu(e.clientX, e.clientY, [
+      // Clipboard operations
+      {
+        label: 'Cut',
+        icon: <Scissors className="h-4 w-4" />,
+        onClick: async () => {
+          const { cutSelection } = await import('@/lib/clipboard-operations');
+          cutSelection();
+        },
+        disabled: !hasSelection,
+      },
+      {
+        label: 'Copy',
+        icon: <Copy className="h-4 w-4" />,
+        onClick: async () => {
+          const { copySelection } = await import('@/lib/clipboard-operations');
+          copySelection();
+        },
+        disabled: !hasSelection,
+      },
+      {
+        label: 'Paste',
+        icon: <Clipboard className="h-4 w-4" />,
+        onClick: async () => {
+          const { pasteFromClipboard } = await import('@/lib/clipboard-operations');
+          await pasteFromClipboard();
+        },
+      },
+      {
+        separator: true,
+        label: '',
+        onClick: () => {},
+      },
+      // Selection operations
+      {
+        label: 'Select All',
+        icon: <SquareDashedMousePointer className="h-4 w-4" />,
+        onClick: () => selectAll(),
+        disabled: !activeLayer,
+      },
+      {
+        label: 'Deselect',
+        icon: <SquareDashedMousePointer className="h-4 w-4" />,
+        onClick: () => clearSelection(),
+        disabled: !hasSelection,
+      },
+      {
+        separator: true,
+        label: '',
+        onClick: () => {},
+      },
+      // Layer operations
+      {
+        label: 'New Layer',
+        icon: <Layers className="h-4 w-4" />,
+        onClick: async () => {
+          const { createLayerWithHistory } = await import('@/lib/layer-operations');
+          createLayerWithHistory({
+            name: `Layer ${layers.length + 1}`,
+            width,
+            height,
+          });
+        },
+      },
+      {
+        label: 'Duplicate Layer',
+        icon: <Copy className="h-4 w-4" />,
+        onClick: async () => {
+          if (!activeLayer) return;
+          const { duplicateLayerWithHistory } = await import('@/lib/layer-operations');
+          duplicateLayerWithHistory(activeLayer.id);
+        },
+        disabled: !activeLayer,
+      },
+      {
+        label: 'Merge Down',
+        icon: <Layers className="h-4 w-4" />,
+        onClick: async () => {
+          if (!activeLayer) return;
+          const { mergeLayerDownWithHistory } = await import('@/lib/layer-operations');
+          mergeLayerDownWithHistory(activeLayer.id);
+        },
+        disabled: !canMergeDown,
+      },
+      {
+        separator: true,
+        label: '',
+        onClick: () => {},
+      },
+      // Transform operations
+      {
+        label: 'Rotate 90° CW',
+        icon: <RotateCw className="h-4 w-4" />,
+        onClick: async () => {
+          if (!activeLayer) return;
+          const { rotateLayerWithHistory } = await import('@/lib/canvas-operations');
+          rotateLayerWithHistory(activeLayer.id, 90);
+        },
+        disabled: !activeLayer,
+      },
+      {
+        label: 'Flip Horizontal',
+        icon: <FlipHorizontal className="h-4 w-4" />,
+        onClick: async () => {
+          if (!activeLayer) return;
+          const { flipLayerWithHistory } = await import('@/lib/canvas-operations');
+          flipLayerWithHistory(activeLayer.id, 'horizontal');
+        },
+        disabled: !activeLayer,
+      },
+      {
+        label: 'Flip Vertical',
+        icon: <FlipVertical className="h-4 w-4" />,
+        onClick: async () => {
+          if (!activeLayer) return;
+          const { flipLayerWithHistory } = await import('@/lib/canvas-operations');
+          flipLayerWithHistory(activeLayer.id, 'vertical');
+        },
+        disabled: !activeLayer,
+      },
+      {
+        separator: true,
+        label: '',
+        onClick: () => {},
+      },
+      // Edit operations
+      {
+        label: 'Undo',
+        icon: <Undo2 className="h-4 w-4" />,
+        onClick: () => undo(),
+        disabled: !canUndo,
+      },
+      {
+        label: 'Redo',
+        icon: <Redo2 className="h-4 w-4" />,
+        onClick: () => redo(),
+        disabled: !canRedo,
+      },
+    ]);
+  };
+
   return (
     <div
       ref={containerRef}
@@ -434,6 +597,7 @@ export function CanvasWithTools() {
       onPointerMove={handlePointerMove}
       onPointerUp={handlePointerUp}
       onPointerLeave={handlePointerUp}
+      onContextMenu={handleContextMenu}
     >
       <canvas
         ref={canvasRef}
diff --git a/core/commands/index.ts b/core/commands/index.ts
index 01c79be..afff955 100644
--- a/core/commands/index.ts
+++ b/core/commands/index.ts
@@ -2,3 +2,6 @@ export * from './base-command';
 export * from './layer-commands';
 export * from './draw-command';
 export * from './move-command';
+export * from './transform-command';
+export * from './filter-command';
+export * from './selection-command';
diff --git a/lib/canvas-operations.ts b/lib/canvas-operations.ts
new file mode 100644
index 0000000..0db9356
--- /dev/null
+++ b/lib/canvas-operations.ts
@@ -0,0 +1,135 @@
+/**
+ * Canvas transformation operations
+ * Rotate, flip, and other canvas manipulations
+ */
+
+import { useHistoryStore } from '@/store/history-store';
+import { useLayerStore } from '@/store';
+import { DrawCommand } from '@/core/commands';
+
+/**
+ * Rotate a canvas by the specified degrees
+ */
+export function rotateCanvas(canvas: HTMLCanvasElement, degrees: 90 | 180 | 270): HTMLCanvasElement {
+  const tempCanvas = document.createElement('canvas');
+  const ctx = tempCanvas.getContext('2d');
+
+  if (!ctx) return canvas;
+
+  // For 90° and 270° rotations, swap width and height
+  if (degrees === 90 || degrees === 270) {
+    tempCanvas.width = canvas.height;
+    tempCanvas.height = canvas.width;
+  } else {
+    tempCanvas.width = canvas.width;
+    tempCanvas.height = canvas.height;
+  }
+
+  ctx.save();
+
+  // Translate and rotate based on degrees
+  switch (degrees) {
+    case 90:
+      ctx.translate(tempCanvas.width, 0);
+      ctx.rotate(Math.PI / 2);
+      break;
+    case 180:
+      ctx.translate(tempCanvas.width, tempCanvas.height);
+      ctx.rotate(Math.PI);
+      break;
+    case 270:
+      ctx.translate(0, tempCanvas.height);
+      ctx.rotate(-Math.PI / 2);
+      break;
+  }
+
+  ctx.drawImage(canvas, 0, 0);
+  ctx.restore();
+
+  return tempCanvas;
+}
+
+/**
+ * Flip a canvas horizontally or vertically
+ */
+export function flipCanvas(canvas: HTMLCanvasElement, direction: 'horizontal' | 'vertical'): HTMLCanvasElement {
+  const tempCanvas = document.createElement('canvas');
+  tempCanvas.width = canvas.width;
+  tempCanvas.height = canvas.height;
+
+  const ctx = tempCanvas.getContext('2d');
+  if (!ctx) return canvas;
+
+  ctx.save();
+
+  if (direction === 'horizontal') {
+    ctx.translate(tempCanvas.width, 0);
+    ctx.scale(-1, 1);
+  } else {
+    ctx.translate(0, tempCanvas.height);
+    ctx.scale(1, -1);
+  }
+
+  ctx.drawImage(canvas, 0, 0);
+  ctx.restore();
+
+  return tempCanvas;
+}
+
+/**
+ * Rotate the active layer with history support
+ */
+export function rotateLayerWithHistory(layerId: string, degrees: 90 | 180 | 270): void {
+  const { getActiveLayer } = useLayerStore.getState();
+  const layer = getActiveLayer();
+
+  if (!layer || !layer.canvas || layer.id !== layerId) return;
+
+  // Create command for history (capture before state)
+  const command = new DrawCommand(layerId, `Rotate ${degrees}°`);
+
+  const rotatedCanvas = rotateCanvas(layer.canvas, degrees);
+
+  // Replace the layer's canvas
+  const ctx = layer.canvas.getContext('2d');
+  if (!ctx) return;
+
+  // Update canvas dimensions if rotated 90° or 270°
+  if (degrees === 90 || degrees === 270) {
+    layer.canvas.width = rotatedCanvas.width;
+    layer.canvas.height = rotatedCanvas.height;
+  }
+
+  ctx.clearRect(0, 0, layer.canvas.width, layer.canvas.height);
+  ctx.drawImage(rotatedCanvas, 0, 0);
+
+  // Capture after state and execute command
+  command.captureAfterState();
+  useHistoryStore.getState().executeCommand(command);
+}
+
+/**
+ * Flip the active layer with history support
+ */
+export function flipLayerWithHistory(layerId: string, direction: 'horizontal' | 'vertical'): void {
+  const { getActiveLayer } = useLayerStore.getState();
+  const layer = getActiveLayer();
+
+  if (!layer || !layer.canvas || layer.id !== layerId) return;
+
+  // Create command for history (capture before state)
+  const command = new DrawCommand(layerId, `Flip ${direction}`);
+
+  const flippedCanvas = flipCanvas(layer.canvas, direction);
+
+  // Replace the layer's canvas
+  const ctx = layer.canvas.getContext('2d');
+  if (!ctx) return;
+
+  ctx.clearRect(0, 0, layer.canvas.width, layer.canvas.height);
+  ctx.drawImage(flippedCanvas, 0, 0);
+
+  // Capture after state and execute command
+  command.captureAfterState();
+  useHistoryStore.getState().executeCommand(command);
+}
diff --git a/lib/clipboard-operations.ts b/lib/clipboard-operations.ts
new file mode 100644
index 0000000..b52ba75
--- /dev/null
+++ b/lib/clipboard-operations.ts
@@ -0,0 +1,195 @@
+/**
+ * Clipboard operations for cut/copy/paste
+ */
+
+import { useLayerStore, useCanvasStore } from '@/store';
+import { useSelectionStore } from '@/store/selection-store';
+import { useHistoryStore } from '@/store/history-store';
+import { useToastStore } from '@/store/toast-store';
+import { DrawCommand } from '@/core/commands';
+import { createLayerWithHistory } from './layer-operations';
+
+// In-memory clipboard for canvas data
+let clipboardCanvas: HTMLCanvasElement | null = null;
+
+/**
+ * Copy the selected region to clipboard
+ */
+export function copySelection(): void {
+  const { getActiveLayer } = useLayerStore.getState();
+  const { activeSelection } = useSelectionStore.getState();
+  const { addToast } = useToastStore.getState();
+
+  const layer = getActiveLayer();
+  if (!layer || !layer.canvas) {
+    addToast('No active layer', 'error');
+    return;
+  }
+
+  if (!activeSelection) {
+    addToast('No selection to copy', 'warning');
+    return;
+  }
+
+  const { mask } = activeSelection;
+  const { bounds, data: maskData } = mask;
+  const ctx = layer.canvas.getContext('2d');
+  if (!ctx) return;
+
+  // Create a temporary canvas for the selection
+  clipboardCanvas = document.createElement('canvas');
+  clipboardCanvas.width = bounds.width;
+  clipboardCanvas.height = bounds.height;
+
+  const clipCtx = clipboardCanvas.getContext('2d');
+  if (!clipCtx) return;
+
+  // Get the image data from the layer
+  const imageData = ctx.getImageData(bounds.x, bounds.y, bounds.width, bounds.height);
+
+  // Apply mask to image data
+  for (let i = 0; i < maskData.length; i++) {
+    const alpha = maskData[i];
+    const pixelIndex = i * 4 + 3;
+    imageData.data[pixelIndex] = Math.min(imageData.data[pixelIndex], alpha);
+  }
+
+  // Put the masked image data into clipboard canvas
+  clipCtx.putImageData(imageData, 0, 0);
+
+  addToast('Selection copied', 'success');
+}
+
+/**
+ * Cut the selected region (copy + delete)
+ */
+export function cutSelection(): void {
+  const { getActiveLayer } = useLayerStore.getState();
+  const { activeSelection } = useSelectionStore.getState();
+  const { addToast } = useToastStore.getState();
+  const { executeCommand } = useHistoryStore.getState();
+
+  const layer = getActiveLayer();
+  if (!layer || !layer.canvas) {
+    addToast('No active layer', 'error');
+    return;
+  }
+
+  if (!activeSelection) {
+    addToast('No selection to cut', 'warning');
+    return;
+  }
+
+  // First, copy the selection
+  copySelection();
+
+  // Then delete the selection
+  const { mask } = activeSelection;
+  const { bounds, data: maskData } = mask;
+  const ctx = layer.canvas.getContext('2d');
+  if (!ctx) return;
+
+  // Create command for history
+  const command = new DrawCommand(layer.id, 'Cut');
+
+  // Get the image data
+  const imageData = ctx.getImageData(bounds.x, bounds.y, bounds.width, bounds.height);
+
+  // Apply mask to delete (set alpha to 0)
+  for (let i = 0; i < maskData.length; i++) {
+    const alpha = maskData[i];
+    if (alpha > 0) {
+      const pixelIndex = i * 4 + 3;
+      imageData.data[pixelIndex] = 0;
+    }
+  }
+
+  // Put the modified image data back
+  ctx.putImageData(imageData, bounds.x, bounds.y);
+
+  // Capture after state and execute command
+  command.captureAfterState();
+  executeCommand(command);
+
+  addToast('Selection cut', 'success');
+}
+
+/**
+ * Paste from clipboard
+ */
+export async function pasteFromClipboard(): Promise<void> {
+  const { width, height } = useCanvasStore.getState();
+  const { addToast } = useToastStore.getState();
+
+  // Try to paste from browser clipboard first
+  try {
+    const items = await navigator.clipboard.read();
+
+    for (const item of items) {
+      for (const type of item.types) {
+        if (type.startsWith('image/')) {
+          const blob = await item.getType(type);
+          const img = new Image();
+          const url = URL.createObjectURL(blob);
+
+          img.onload = () => {
+            // Create new layer with pasted image
+            createLayerWithHistory({
+              name: 'Pasted Layer',
+              width: img.width,
+              height: img.height,
+            });
+
+            // Draw the image onto the new layer
+            const { getActiveLayer } = useLayerStore.getState();
+            const layer = getActiveLayer();
+            if (layer && layer.canvas) {
+              const ctx = layer.canvas.getContext('2d');
+              if (ctx) {
+                ctx.drawImage(img, 0, 0);
+                addToast('Image pasted', 'success');
+              }
+            }
+
+            URL.revokeObjectURL(url);
+          };
+
+          img.src = url;
+          return;
+        }
+      }
+    }
+  } catch (error) {
+    // Clipboard API not available or no image in clipboard
+    console.warn('Clipboard API failed:', error);
+  }
+
+  // Fallback to internal clipboard
+  if (clipboardCanvas) {
+    createLayerWithHistory({
+      name: 'Pasted Layer',
+      width: clipboardCanvas.width,
+      height: clipboardCanvas.height,
+    });
+
+    // Draw the clipboard canvas onto the new layer
+    const { getActiveLayer } = useLayerStore.getState();
+    const layer = getActiveLayer();
+    if (layer && layer.canvas) {
+      const ctx = layer.canvas.getContext('2d');
+      if (ctx) {
+        ctx.drawImage(clipboardCanvas, 0, 0);
+        addToast('Selection pasted', 'success');
+      }
+    }
+  } else {
+    addToast('Nothing to paste', 'warning');
+  }
+}
+
+/**
+ * Check if clipboard has content
+ */
+export function hasClipboardContent(): boolean {
+  return clipboardCanvas !== null;
+}
diff --git a/store/selection-store.ts b/store/selection-store.ts
index 8208c0c..8aaf8b6 100644
--- a/store/selection-store.ts
+++ b/store/selection-store.ts
@@ -14,6 +14,7 @@ interface SelectionStore extends SelectionState {
   setTolerance: (tolerance: number) => void;
   setMarching: (isMarching: boolean) => void;
   clearSelection: () => void;
+  selectAll: () => void;
   invertSelection: () => void;
 }
 
@@ -60,6 +61,40 @@ export const useSelectionStore = create<SelectionStore>((set) => ({
       activeSelection: null,
     }),
 
+  selectAll: () =>
+    set(() => {
+      const { useCanvasStore, useLayerStore } = require('@/store');
+      const { width, height } = useCanvasStore.getState();
+      const { getActiveLayer } = useLayerStore.getState();
+      const activeLayer = getActiveLayer();
+
+      if (!activeLayer) return {};
+
+      // Create a mask that covers the entire canvas
+      const maskData = new Uint8Array(width * height).fill(255);
+
+      return {
+        activeSelection: {
+          id: `selection-${Date.now()}`,
+          layerId: activeLayer.id,
+          mask: {
+            width,
+            height,
+            data: maskData,
+            bounds: {
+              x: 0,
+              y: 0,
+              width,
+              height,
+            },
+          },
+          inverted: false,
+          feather: 0,
+          createdAt: Date.now(),
+        },
+      };
+    }),
+
   invertSelection: () =>
     set((state) => {
       if (state.activeSelection) {