image-edit-tools 1.0.0

package/tests/unit/convert.test.ts

@@ -0,0 +1,55 @@
+import { describe, it, expect, beforeAll } from 'vitest'
+import { readFileSync } from 'fs'
+import { join, dirname } from 'path'
+import { fileURLToPath } from 'url'
+import { convert } from '../../src/ops/convert.js'
+import sharp from 'sharp'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+const fixture = (name: string) => readFileSync(join(__dirname, '../fixtures', name))
+
+describe('convert', () => {
+  let sampleJpeg: Buffer
+
+  beforeAll(() => {
+    sampleJpeg = fixture('sample.jpg') 
+  })
+
+  it('converts to jpeg with quality', async () => {
+    const result = await convert(sampleJpeg, { format: 'jpeg', quality: 50 })
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    const meta = await sharp(result.data).metadata()
+    expect(meta.format).toBe('jpeg')
+  })
+
+  it('converts to png with compressionLevel', async () => {
+    const result = await convert(sampleJpeg, { format: 'png', compressionLevel: 9 })
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    const meta = await sharp(result.data).metadata()
+    expect(meta.format).toBe('png')
+  })
+
+  it('converts to webp', async () => {
+    const result = await convert(sampleJpeg, { format: 'webp' })
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    const meta = await sharp(result.data).metadata()
+    expect(meta.format).toBe('webp')
+  })
+
+  it('converts to avif', async () => {
+    const result = await convert(sampleJpeg, { format: 'avif' })
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    const meta = await sharp(result.data).metadata()
+    expect(meta.format).toBe('heif') 
+  })
+
+  it('preserves metadata when stripMetadata is false', async () => {
+    const result = await convert(sampleJpeg, { format: 'jpeg', stripMetadata: false })
+    expect(result.ok).toBe(true)
+  })
+})

package/tests/unit/crop.test.ts

@@ -0,0 +1,100 @@
+import { describe, it, expect, beforeAll } from 'vitest'
+import { readFileSync } from 'fs'
+import { join, dirname } from 'path'
+import { fileURLToPath } from 'url'
+import { crop } from '../../src/ops/crop.js'
+import sharp from 'sharp'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+const fixture = (name: string) => readFileSync(join(__dirname, '../fixtures', name))
+
+describe('crop', () => {
+  let sampleJpeg: Buffer
+  let samplePng: Buffer
+
+  beforeAll(() => {
+    sampleJpeg = fixture('sample.jpg')  // 400×300
+    samplePng = fixture('sample.png')   // 400×300 with alpha
+  })
+
+  // ── Absolute mode ──────────────────────────────────────────────────────────
+
+  it('crops to exact pixel coordinates', async () => {
+    const result = await crop(sampleJpeg, { mode: 'absolute', x: 10, y: 10, width: 100, height: 80 })
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    const meta = await sharp(result.data).metadata()
+    expect(meta.width).toBe(100)
+    expect(meta.height).toBe(80)
+  })
+
+  it('preserves alpha channel when cropping a PNG', async () => {
+    const result = await crop(samplePng, { mode: 'absolute', x: 0, y: 0, width: 200, height: 200 })
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    const meta = await sharp(result.data).metadata()
+    expect(meta.hasAlpha).toBe(true)
+  })
+
+  // ── Ratio mode ─────────────────────────────────────────────────────────────
+
+  it('crops by ratio from each edge', async () => {
+    const result = await crop(sampleJpeg, {
+      mode: 'ratio', left: 0.1, top: 0.1, right: 0.1, bottom: 0.1
+    })
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    // 400 * 0.1 = 40, so width = 400 - 80 = 320
+    const meta = await sharp(result.data).metadata()
+    expect(meta.width).toBe(320)
+    expect(meta.height).toBe(240)
+  })
+
+  // ── Aspect mode ────────────────────────────────────────────────────────────
+
+  it('crops to 16:9 aspect ratio centered', async () => {
+    const result = await crop(sampleJpeg, {
+      mode: 'aspect', aspectRatio: '16:9', anchor: 'center'
+    })
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    const meta = await sharp(result.data).metadata()
+    expect(meta.width! / meta.height!).toBeCloseTo(16 / 9, 1)
+  })
+
+  // ── Error paths ────────────────────────────────────────────────────────────
+
+  it('returns error when crop region exceeds image bounds', async () => {
+    const result = await crop(sampleJpeg, { mode: 'absolute', x: 0, y: 0, width: 9999, height: 9999 })
+    expect(result.ok).toBe(false)
+    if (result.ok) return
+    expect(result.code).toBe('OUT_OF_BOUNDS')
+  })
+
+  it('returns MODEL_NOT_FOUND for unimplemented subject mode', async () => {
+    const result = await crop(sampleJpeg, { mode: 'subject' })
+    expect(result.ok).toBe(false)
+    if (result.ok) return
+    expect(result.code).toBe('MODEL_NOT_FOUND')
+  })
+
+  it('returns error for corrupt input buffer', async () => {
+    const result = await crop(Buffer.from('not an image'), { mode: 'absolute', x: 0, y: 0, width: 10, height: 10 })
+    expect(result.ok).toBe(false)
+    if (result.ok) return
+    expect(result.code).toBe('INVALID_INPUT')
+  })
+
+  it('accepts file path as input', async () => {
+    const path = join(__dirname, '../fixtures/sample.jpg')
+    const result = await crop(path, { mode: 'absolute', x: 0, y: 0, width: 100, height: 100 })
+    expect(result.ok).toBe(true)
+  })
+
+  it('accepts base64 data URI as input', async () => {
+    const base64 = `data:image/jpeg;base64,${sampleJpeg.toString('base64')}`
+    const result = await crop(base64, { mode: 'absolute', x: 0, y: 0, width: 100, height: 100 })
+    expect(result.ok).toBe(true)
+  })
+})

package/tests/unit/detect-faces.test.ts

@@ -0,0 +1,32 @@
+import { describe, it, expect, beforeAll, vi } from 'vitest'
+import { readFileSync } from 'fs'
+import { join, dirname } from 'path'
+import { fileURLToPath } from 'url'
+import { detectFaces } from '../../src/ops/detect-faces.js'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+const fixture = (name: string) => readFileSync(join(__dirname, '../fixtures', name))
+
+vi.mock('@xenova/transformers', async (importOriginal) => {
+  return {
+    ...(await importOriginal<typeof import('@xenova/transformers')>()),
+    pipeline: vi.fn().mockRejectedValue(new Error('Mock network failure'))
+  }
+})
+
+describe('detectFaces', () => {
+  let sampleJpeg: Buffer
+
+  beforeAll(() => {
+    sampleJpeg = fixture('sample.jpg') 
+  })
+
+  it('returns MODEL_NOT_FOUND offline', async () => {
+    const result = await detectFaces(sampleJpeg)
+    expect(result.ok).toBe(false)
+    if (!result.ok) {
+        expect(result.code).toBe('MODEL_NOT_FOUND')
+    }
+  })
+})

package/tests/unit/detect-subject.test.ts

@@ -0,0 +1,37 @@
+import { describe, it, expect, beforeAll, vi } from 'vitest'
+import { readFileSync } from 'fs'
+import { join, dirname } from 'path'
+import { fileURLToPath } from 'url'
+import { detectSubject } from '../../src/ops/detect-subject.js'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+const fixture = (name: string) => readFileSync(join(__dirname, '../fixtures', name))
+
+vi.mock('@xenova/transformers', async (importOriginal) => {
+  return {
+    ...(await importOriginal<typeof import('@xenova/transformers')>()),
+    AutoModel: {
+      from_pretrained: vi.fn().mockRejectedValue(new Error('Mock network failure'))
+    },
+    AutoProcessor: {
+      from_pretrained: vi.fn()
+    }
+  }
+})
+
+describe('detectSubject', () => {
+  let sampleJpeg: Buffer
+
+  beforeAll(() => {
+    sampleJpeg = fixture('sample.jpg') 
+  })
+
+  it('returns MODEL_NOT_FOUND when model is unavailable', async () => {
+    const result = await detectSubject(sampleJpeg)
+    expect(result.ok).toBe(false)
+    if (!result.ok) {
+      expect(result.code).toBe('MODEL_NOT_FOUND')
+    }
+  })
+})

package/tests/unit/extract-text.test.ts

@@ -0,0 +1,34 @@
+import { describe, it, expect, beforeAll, vi } from 'vitest'
+import { readFileSync } from 'fs'
+import { join, dirname } from 'path'
+import { fileURLToPath } from 'url'
+import { extractText } from '../../src/ops/extract-text.js'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+const fixture = (name: string) => readFileSync(join(__dirname, '../fixtures', name))
+
+vi.mock('tesseract.js', () => {
+  return {
+    default: {
+      recognize: vi.fn().mockResolvedValue({
+        data: { text: 'Mocked text' }
+      })
+    }
+  }
+})
+
+describe('extractText', () => {
+  let sampleJpeg: Buffer
+
+  beforeAll(() => {
+    sampleJpeg = fixture('sample.jpg') 
+  })
+
+  it('extracts text', async () => {
+    const result = await extractText(sampleJpeg)
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    expect(result.data).toBe('Mocked text')
+  })
+})

package/tests/unit/filter.test.ts

@@ -0,0 +1,39 @@
+import { describe, it, expect, beforeAll } from 'vitest'
+import { readFileSync } from 'fs'
+import { join, dirname } from 'path'
+import { fileURLToPath } from 'url'
+import { filter } from '../../src/ops/filter.js'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+const fixture = (name: string) => readFileSync(join(__dirname, '../fixtures', name))
+
+describe('filter', () => {
+  let sampleJpeg: Buffer
+
+  beforeAll(() => {
+    sampleJpeg = fixture('sample.jpg') // 400x300
+  })
+
+  // Test all presets
+  const presets = ['grayscale', 'sepia', 'invert', 'vintage', 'unsharp'] as const
+  for (const preset of presets) {
+    it(`applies ${preset} preset`, async () => {
+      const result = await filter(sampleJpeg, { preset })
+      expect(result.ok).toBe(true)
+    })
+  }
+
+  it('applies blur preset with radius', async () => {
+    const result = await filter(sampleJpeg, { preset: 'blur', radius: 10 })
+    expect(result.ok).toBe(true)
+  })
+
+  it('fails blur preset if radius is missing or invalid', async () => {
+    // TypeScript should stop missing radius, but casting to verify runtime validation
+    const result = await filter(sampleJpeg, { preset: 'blur', radius: -5 } as any)
+    expect(result.ok).toBe(false)
+    if (result.ok) return
+    expect(result.code).toBe('INVALID_INPUT')
+  })
+})

package/tests/unit/get-dominant-colors.test.ts

@@ -0,0 +1,25 @@
+import { describe, it, expect, beforeAll } from 'vitest'
+import { readFileSync } from 'fs'
+import { join, dirname } from 'path'
+import { fileURLToPath } from 'url'
+import { getDominantColors } from '../../src/ops/get-dominant-colors.js'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+const fixture = (name: string) => readFileSync(join(__dirname, '../fixtures', name))
+
+describe('getDominantColors', () => {
+  let sampleJpeg: Buffer
+
+  beforeAll(() => {
+    sampleJpeg = fixture('sample.jpg') 
+  })
+
+  it('returns exactly count dominant colors as hex', async () => {
+    const result = await getDominantColors(sampleJpeg, 3)
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    expect(result.data).toHaveLength(3)
+    expect(result.data[0]).toMatch(/^#[0-9a-fA-F]{6}$/)
+  })
+})

package/tests/unit/get-metadata.test.ts

@@ -0,0 +1,36 @@
+import { describe, it, expect, beforeAll } from 'vitest'
+import { readFileSync } from 'fs'
+import { join, dirname } from 'path'
+import { fileURLToPath } from 'url'
+import { getMetadata } from '../../src/ops/get-metadata.js'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+const fixture = (name: string) => readFileSync(join(__dirname, '../fixtures', name))
+
+describe('getMetadata', () => {
+  let sampleJpeg: Buffer
+  let samplePng: Buffer
+
+  beforeAll(() => {
+    sampleJpeg = fixture('sample.jpg') 
+    samplePng = fixture('sample.png')
+  })
+
+  it('returns metadata for jpeg', async () => {
+    const result = await getMetadata(sampleJpeg)
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    expect(result.data.width).toBe(400)
+    expect(result.data.height).toBe(300)
+    expect(result.data.format).toBe('jpeg')
+  })
+
+  it('returns metadata for png', async () => {
+    const result = await getMetadata(samplePng)
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    expect(result.data.format).toBe('png')
+    expect(result.data.hasAlpha).toBe(true)
+  })
+})

package/tests/unit/mcp.test.ts

@@ -0,0 +1,104 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const serverPath = join(__dirname, '../../src/mcp/index.ts');
+
+describe('MCP E2E', () => {
+  let client: Client;
+  let transport: StdioClientTransport;
+
+  beforeAll(async () => {
+    // spawn node with module loader for TS or fallback to npx tsx.
+    // Vitest runs within node so we can spawn a child process.
+    transport = new StdioClientTransport({
+      command: 'npx',
+      args: ['tsx', serverPath],
+    });
+    client = new Client({ name: 'test-client', version: '1.0.0' }, { capabilities: {} });
+    await client.connect(transport);
+  });
+
+  afterAll(async () => {
+    await transport.close();
+  });
+
+  it('lists all expected tools including image_batch', async () => {
+    const response = await client.listTools();
+    const toolNames = response.tools.map((t: any) => t.name);
+    
+    const expected = [
+      'image_crop', 'image_resize', 'image_pad', 'image_adjust', 'image_filter',
+      'image_blur_region', 'image_add_text', 'image_composite', 'image_watermark',
+      'image_remove_bg', 'image_convert', 'image_optimize', 'image_get_metadata',
+      'image_get_dominant_colors', 'image_detect_faces', 'image_extract_text',
+      'image_pipeline', 'image_batch'
+    ];
+    
+    for (const name of expected) {
+      expect(toolNames).toContain(name);
+    }
+  });
+
+  it('calls image_get_metadata tool successfully and unwraps result', async () => {
+    const b64 = 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII=';
+    const image = `data:image/png;base64,${b64}`;
+
+    const result = await client.callTool({
+      name: 'image_get_metadata',
+      arguments: { image }
+    });
+
+    expect(result.content).toBeDefined();
+    const content = result.content as any[];
+    expect(content[0].type).toBe('text');
+    const res = JSON.parse(content[0].text);
+    
+    expect(res.width).toBe(1);
+    expect(res.height).toBe(1);
+    expect(res.format).toBe('png');
+  });
+
+  it('calls image_convert tool successfully', async () => {
+    const b64 = 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII=';
+    const image = `data:image/png;base64,${b64}`;
+
+    const result = await client.callTool({
+      name: 'image_convert',
+      arguments: { image, format: 'jpeg' }
+    });
+
+    const content = result.content as any[];
+    const res = JSON.parse(content[0].text);
+    expect(res.ok).toBe(true);
+    expect(res.data).toMatch(/^data:image\/jpeg;base64,/);
+  });
+
+  it('handles unknown tool call gracefully by returning correct JSON error structure', async () => {
+    // The image-edit-tools MCP server currently returns standard JSON response with an error property,
+    // rather than throwing a protocol-level JSON-RPC error.
+    const result = await client.callTool({ name: 'image_unknown_tool', arguments: {} });
+    const content = result.content as any[];
+    const res = JSON.parse(content[0].text);
+    
+    expect(res.error).toBeDefined();
+    expect(res.error).toContain('not implemented');
+    expect(res.code).toBe('INVALID_INPUT');
+  });
+
+  it('handles invalid arguments gracefully inside tool execution', async () => {
+    const result = await client.callTool({
+      name: 'image_crop',
+      arguments: { image: 'invalid-image-data', mode: 'absolute', x: 0, y: 0, width: 100, height: 100 }
+    });
+    
+    const content = result.content as any[];
+    const res = JSON.parse(content[0].text);
+    expect(res.error).toBeDefined();
+    expect(res.code).toBe('INVALID_INPUT'); // file not found or invalid input
+  });
+});

package/tests/unit/optimize.test.ts

@@ -0,0 +1,47 @@
+import { describe, it, expect, beforeAll } from 'vitest'
+import { readFileSync } from 'fs'
+import { join, dirname } from 'path'
+import { fileURLToPath } from 'url'
+import { optimize } from '../../src/ops/optimize.js'
+import sharp from 'sharp'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+const fixture = (name: string) => readFileSync(join(__dirname, '../fixtures', name))
+
+describe('optimize', () => {
+  let sampleJpeg: Buffer
+  let samplePng: Buffer
+
+  beforeAll(() => {
+    sampleJpeg = fixture('sample.jpg') 
+    samplePng = fixture('sample.png')
+  })
+
+  it('reduces file size below target maxSizeKB', async () => {
+    const startSize = sampleJpeg.length
+    
+    // We expect the dummy jpg from sharp to be very small, maybe < 10KB.
+    // If it's already < 10KB, optimization just maintains or matches it.
+    const result = await optimize(sampleJpeg, { maxSizeKB: 10, autoFormat: false })
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    expect(result.data.length).toBeLessThanOrEqual(10 * 1024 + 1024) 
+  })
+
+  it('resizes using maxDimension', async () => {
+    const result = await optimize(sampleJpeg, { maxDimension: 100 })
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    const meta = await sharp(result.data).metadata()
+    expect(Math.max(meta.width!, meta.height!)).toBe(100)
+  })
+
+  it('selects webp for alpha by default', async () => {
+    const result = await optimize(samplePng, {}) 
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    const meta = await sharp(result.data).metadata()
+    expect(meta.format).toBe('webp')
+  })
+})

package/tests/unit/overlay.test.ts

@@ -0,0 +1,39 @@
+import { describe, it, expect, beforeAll } from 'vitest'
+import { readFileSync } from 'fs'
+import { join, dirname } from 'path'
+import { fileURLToPath } from 'url'
+import { overlay } from '../../src/ops/overlay.js'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+const fixture = (name: string) => readFileSync(join(__dirname, '../fixtures', name))
+
+describe('overlay', () => {
+  let sampleJpeg: Buffer
+  let logoPng: Buffer
+
+  beforeAll(() => {
+    sampleJpeg = fixture('sample.jpg') // 400x300
+    logoPng = fixture('logo.png')      // 100x100
+  })
+
+  it('adds overlay with default options', async () => {
+    const result = await overlay(sampleJpeg, logoPng)
+    expect(result.ok).toBe(true)
+  })
+
+  it('adds overlay using gravity', async () => {
+    const result = await overlay(sampleJpeg, logoPng, { gravity: 'SouthEast' })
+    expect(result.ok).toBe(true)
+  })
+
+  it('adds overlay using offsets and opacity', async () => {
+    const result = await overlay(sampleJpeg, logoPng, { offsetX: 50, offsetY: 50, opacity: 0.5 })
+    expect(result.ok).toBe(true)
+  })
+
+  it('supports blend modes', async () => {
+    const result = await overlay(sampleJpeg, logoPng, { blend: 'multiply' })
+    expect(result.ok).toBe(true)
+  })
+})

package/tests/unit/pad.test.ts

@@ -0,0 +1,56 @@
+import { describe, it, expect, beforeAll } from 'vitest'
+import { readFileSync } from 'fs'
+import { join, dirname } from 'path'
+import { fileURLToPath } from 'url'
+import { pad } from '../../src/ops/pad.js'
+import sharp from 'sharp'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+const fixture = (name: string) => readFileSync(join(__dirname, '../fixtures', name))
+
+describe('pad', () => {
+  let sampleJpeg: Buffer
+
+  beforeAll(() => {
+    sampleJpeg = fixture('sample.jpg') // 400x300
+  })
+
+  it('pads individual edges', async () => {
+    const result = await pad(sampleJpeg, { top: 10, bottom: 20, left: 5, right: 15 })
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    const meta = await sharp(result.data).metadata()
+    expect(meta.width).toBe(400 + 5 + 15)
+    expect(meta.height).toBe(300 + 10 + 20)
+  })
+
+  it('pads to square size', async () => {
+    const result = await pad(sampleJpeg, { size: 500 })
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    const meta = await sharp(result.data).metadata()
+    expect(meta.width).toBe(500)
+    expect(meta.height).toBe(500)
+  })
+
+  it('uses transparent background', async () => {
+    const result = await pad(sampleJpeg, { top: 10, color: 'transparent' })
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    const meta = await sharp(result.data).metadata()
+    expect(meta.hasAlpha).toBe(true)
+  })
+
+  it('parses hex color', async () => {
+    const result = await pad(sampleJpeg, { top: 10, color: '#ff0000' })
+    expect(result.ok).toBe(true)
+  })
+
+  it('returns error for negative padding', async () => {
+    const result = await pad(sampleJpeg, { top: -10 })
+    expect(result.ok).toBe(false)
+    if (result.ok) return
+    expect(result.code).toBe('INVALID_INPUT')
+  })
+})

package/tests/unit/pipeline.test.ts

@@ -0,0 +1,48 @@
+import { describe, it, expect, beforeAll } from 'vitest'
+import { readFileSync } from 'fs'
+import { join, dirname } from 'path'
+import { fileURLToPath } from 'url'
+import { pipeline } from '../../src/ops/pipeline.js'
+import sharp from 'sharp'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+const fixture = (name: string) => readFileSync(join(__dirname, '../fixtures', name))
+
+describe('pipeline', () => {
+  let sampleJpeg: Buffer
+
+  beforeAll(() => {
+    sampleJpeg = fixture('sample.jpg') 
+  })
+
+  it('runs multiple operations sequentially', async () => {
+    const result = await pipeline(sampleJpeg, [
+      { op: 'resize', width: 200, height: 200, fit: 'fill' },
+      { op: 'adjust', brightness: 10 },
+      { op: 'convert', format: 'png' }
+    ])
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    const meta = await sharp(result.data).metadata()
+    expect(meta.width).toBe(200)
+    expect(meta.height).toBe(200)
+    expect(meta.format).toBe('png')
+  })
+
+  it('returns original loaded buffer for empty pipeline', async () => {
+    const result = await pipeline(sampleJpeg, [])
+    expect(result.ok).toBe(true)
+  })
+
+  it('returns error with step index if operation fails', async () => {
+    const result = await pipeline(sampleJpeg, [
+      { op: 'resize', width: 200, height: 200 },
+      { op: 'crop', mode: 'absolute', x: 500, y: 500, width: 10, height: 10 }
+    ])
+    expect(result.ok).toBe(false)
+    if (result.ok) return
+    expect(result.step).toBe(1)
+    expect(result.code).toBe('OUT_OF_BOUNDS')
+  })
+})