feat: add ImageHandler with EXIF extraction and comprehensive MIME detection (v5.2.0)

Implements Phase 1.5 (Comprehensive MIME Type Detection) and adds built-in image processing support to IntelligentImportAugmentation.

**New Features:**
- ImageHandler: Extracts image metadata (dimensions, format, color space) using sharp
- EXIF extraction: Camera data, GPS, timestamps using exifr library
- Support for JPEG, PNG, WebP, GIF, TIFF, BMP, SVG, HEIC, AVIF formats
- MimeTypeDetector: Unified MIME type detection with magic byte support
- FormatDetector: Enhanced with image format detection via MIME + magic bytes

**Architecture Fixes:**
- Fixed brain.import() augmentation pipeline integration (src/brainy.ts:3140-3154)
- Added parameter spreading for ImportSource objects to enable augmentation access
- Fixed metadata propagation through ImportCoordinator to final results
- Added augmentation data check in ImportCoordinator.extract()

**Integration:**
- ImageHandler registered as built-in handler alongside CSV, Excel, PDF
- Images import as 'media' entities with 'image' subtype
- Full metadata preserved in knowledge graph entities
- Configuration options: enableImage, extractEXIF, imageDefaults

**Test Coverage:**
- 15 integration tests (image-import.test.ts) - 100% passing
- 27 unit tests (image-handler.test.ts) - 100% passing
- Format detection tests for all supported image types
- Error handling and resilience tests

**Breaking Changes:** None - backward compatible

Generated with Claude Code

Co-Authored-By: Claude <noreply@anthropic.com>

tests/integration/image-import.test.ts

@@ -0,0 +1,361 @@
+/**
+ * Image Import Integration Test (v5.2.0)
+ *
+ * Tests that ImageHandler works as a built-in handler with IntelligentImportAugmentation
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { Brainy } from '../../src/brainy.js'
+import sharp from 'sharp'
+
+describe('Image Import Integration (v5.2.0)', () => {
+  let brain: Brainy
+
+  // Create test image
+  const createTestImage = async (width: number, height: number): Promise<Buffer> => {
+    const channels = 3
+    const pixelData = Buffer.alloc(width * height * channels)
+
+    // Fill with gradient
+    for (let y = 0; y < height; y++) {
+      for (let x = 0; x < width; x++) {
+        const i = (y * width + x) * channels
+        pixelData[i] = Math.floor((x / width) * 255)
+        pixelData[i + 1] = Math.floor((y / height) * 255)
+        pixelData[i + 2] = 128
+      }
+    }
+
+    return sharp(pixelData, {
+      raw: { width, height, channels }
+    })
+      .jpeg({ quality: 90 })
+      .toBuffer()
+  }
+
+  beforeEach(async () => {
+    // IntelligentImportAugmentation is enabled by default with all handlers
+    // Configure it to only enable image handler for focused testing
+    brain = new Brainy({
+      silent: true,
+      augmentations: {
+        intelligentImport: {
+          enableCSV: false,
+          enableExcel: false,
+          enablePDF: false,
+          enableImage: true // Only enable image handler for this test
+        }
+      }
+    })
+
+    await brain.init()
+  })
+
+  afterEach(async () => {
+    await brain.close()
+  })
+
+  describe('Built-in Image Handler', () => {
+    it('should automatically handle image import via IntelligentImportAugmentation', async () => {
+      const imageBuffer = await createTestImage(800, 600)
+
+      // Import image - should be automatically processed by ImageHandler
+      const result = await brain.import({
+        type: 'buffer',
+        data: imageBuffer,
+        filename: 'test-photo.jpg'
+      })
+
+      expect(result).toBeDefined()
+      expect(result.entities).toHaveLength(1)
+
+      const imageEntity = result.entities[0]
+      expect(imageEntity.type).toBe('media')
+      expect(imageEntity.metadata?.subtype).toBe('image')
+      expect(imageEntity.metadata).toBeDefined()
+    })
+
+    it('should extract image metadata via built-in handler', async () => {
+      const imageBuffer = await createTestImage(1920, 1080)
+
+      const result = await brain.import({
+        type: 'buffer',
+        data: imageBuffer,
+        filename: 'hd-photo.jpg'
+      })
+
+      const imageEntity = result.entities[0]
+      expect(imageEntity).toBeDefined()
+      expect(imageEntity.metadata).toBeDefined()
+      expect(typeof imageEntity.metadata).toBe('object')
+      expect(imageEntity.metadata.width).toBe(1920)
+      expect(imageEntity.metadata.height).toBe(1080)
+      expect(imageEntity.metadata.format).toBe('jpeg')
+    })
+
+    it('should extract EXIF data when available', async () => {
+      const imageBuffer = await createTestImage(400, 300)
+
+      const result = await brain.import({
+        type: 'buffer',
+        data: imageBuffer,
+        filename: 'camera-photo.jpg',
+        options: {
+          extractEXIF: true
+        }
+      })
+
+      const imageEntity = result.entities[0]
+      // Test image won't have EXIF, but should not crash
+      expect(imageEntity).toBeDefined()
+      expect(imageEntity.type).toBe('media')
+      expect(imageEntity.metadata?.subtype).toBe('image')
+    })
+
+    it('should allow disabling EXIF extraction via config', async () => {
+      const imageBuffer = await createTestImage(400, 300)
+
+      const result = await brain.import({
+        type: 'buffer',
+        data: imageBuffer,
+        filename: 'no-exif.jpg',
+        options: {
+          extractEXIF: false
+        }
+      })
+
+      expect(result.entities).toHaveLength(1)
+      expect(result.entities[0].type).toBe('media')
+      expect(result.entities[0].metadata?.subtype).toBe('image')
+    })
+
+    it('should handle PNG images', async () => {
+      const pngBuffer = await sharp(Buffer.alloc(100 * 100 * 4), {
+        raw: { width: 100, height: 100, channels: 4 }
+      })
+        .png()
+        .toBuffer()
+
+      const result = await brain.import({
+        type: 'buffer',
+        data: pngBuffer,
+        filename: 'logo.png'
+      })
+
+      const imageEntity = result.entities[0]
+      expect(imageEntity.metadata.format).toBe('png')
+      expect(imageEntity.metadata.hasAlpha).toBe(true)
+    })
+
+    it('should handle WebP images', async () => {
+      const webpBuffer = await sharp(Buffer.alloc(200 * 200 * 3), {
+        raw: { width: 200, height: 200, channels: 3 }
+      })
+        .webp({ quality: 90 })
+        .toBuffer()
+
+      const result = await brain.import({
+        type: 'buffer',
+        data: webpBuffer,
+        filename: 'modern.webp'
+      })
+
+      const imageEntity = result.entities[0]
+      expect(imageEntity.metadata.format).toBe('webp')
+    })
+  })
+
+  describe('Configuration', () => {
+    it('should allow disabling image handler', async () => {
+      // Create new brain with image handler disabled
+      const brainNoImage = new Brainy({
+        silent: true,
+        augmentations: {
+          intelligentImport: {
+            enableImage: false
+          }
+        }
+      })
+      await brainNoImage.init()
+
+      const imageBuffer = await createTestImage(400, 300)
+
+      // Import should still work, but won't be processed by ImageHandler
+      const result = await brainNoImage.import({
+        type: 'buffer',
+        data: imageBuffer,
+        filename: 'unprocessed.jpg'
+      })
+
+      // Should create entity but not extract image metadata
+      expect(result).toBeDefined()
+
+      await brainNoImage.close()
+    })
+
+    it('should apply imageDefaults config', async () => {
+      const brainWithDefaults = new Brainy({
+        silent: true,
+        augmentations: {
+          intelligentImport: {
+            enableImage: true,
+            imageDefaults: {
+              extractEXIF: false // Default to no EXIF extraction
+            }
+          }
+        }
+      })
+      await brainWithDefaults.init()
+
+      const imageBuffer = await createTestImage(400, 300)
+
+      const result = await brainWithDefaults.import({
+        type: 'buffer',
+        data: imageBuffer,
+        filename: 'default-config.jpg'
+      })
+
+      expect(result.entities[0].type).toBe('media')
+      expect(result.entities[0].metadata?.subtype).toBe('image')
+
+      await brainWithDefaults.close()
+    })
+  })
+
+  describe('Image Format Detection', () => {
+    it('should detect JPEG by filename', async () => {
+      const imageBuffer = await createTestImage(400, 300)
+
+      const result = await brain.import({
+        type: 'buffer',
+        data: imageBuffer,
+        filename: 'photo.jpg'
+      })
+
+      expect(result.entities[0].metadata.format).toBe('jpeg')
+    })
+
+    it('should detect JPEG by .jpeg extension', async () => {
+      const imageBuffer = await createTestImage(400, 300)
+
+      const result = await brain.import({
+        type: 'buffer',
+        data: imageBuffer,
+        filename: 'photo.jpeg'
+      })
+
+      expect(result.entities[0].metadata.format).toBe('jpeg')
+    })
+
+    it('should handle various image sizes', async () => {
+      const sizes = [
+        [100, 100],
+        [800, 600],
+        [1920, 1080],
+        [4000, 3000]
+      ]
+
+      for (const [width, height] of sizes) {
+        const imageBuffer = await createTestImage(width, height)
+
+        const result = await brain.import({
+          type: 'buffer',
+          data: imageBuffer,
+          filename: `image-${width}x${height}.jpg`
+        })
+
+        const imageEntity = result.entities[0]
+        expect(imageEntity.metadata.width).toBe(width)
+        expect(imageEntity.metadata.height).toBe(height)
+      }
+    })
+  })
+
+  describe('Error Handling', () => {
+    it('should handle invalid image data gracefully', async () => {
+      const invalidBuffer = Buffer.from('not an image')
+
+      // Brainy is resilient - invalid images still import with fallback minimal metadata
+      const result = await brain.import({
+        type: 'buffer',
+        data: invalidBuffer,
+        filename: 'invalid.jpg'
+      })
+
+      expect(result).toBeDefined()
+      expect(result.entities).toHaveLength(1)
+      expect(result.entities[0].type).toBe('media')
+      expect(result.entities[0].name).toBe('invalid.jpg')
+    })
+
+    it('should handle empty image buffer', async () => {
+      const emptyBuffer = Buffer.alloc(0)
+
+      // Brainy is resilient - empty buffers still import with fallback minimal metadata
+      const result = await brain.import({
+        type: 'buffer',
+        data: emptyBuffer,
+        filename: 'empty.jpg'
+      })
+
+      expect(result).toBeDefined()
+      expect(result.entities).toHaveLength(1)
+      expect(result.entities[0].type).toBe('media')
+      expect(result.entities[0].name).toBe('empty.jpg')
+    })
+  })
+
+  describe('Integration with Knowledge Graph', () => {
+    it('should store image entities in knowledge graph', async () => {
+      const imageBuffer = await createTestImage(800, 600)
+
+      const result = await brain.import({
+        type: 'buffer',
+        data: imageBuffer,
+        filename: 'stored-image.jpg'
+      })
+
+      // Verify entity was created with metadata in import result
+      expect(result.entities).toHaveLength(1)
+      expect(result.entities[0].metadata.width).toBe(800)
+      expect(result.entities[0].metadata.height).toBe(600)
+
+      // Query for image entities - verifies it's in the knowledge graph
+      const images = await brain.find({ type: 'media' })
+      expect(images.length).toBeGreaterThan(0)
+
+      // Verify media entities have the expected type
+      const mediaEntities = images.filter(img => img.type === 'media')
+      expect(mediaEntities.length).toBeGreaterThan(0)
+    })
+
+    it('should support querying by image metadata', async () => {
+      // Import multiple images and capture metadata from results
+      const result1 = await brain.import({
+        type: 'buffer',
+        data: await createTestImage(1920, 1080),
+        filename: 'hd.jpg'
+      })
+
+      const result2 = await brain.import({
+        type: 'buffer',
+        data: await createTestImage(800, 600),
+        filename: 'sd.jpg'
+      })
+
+      // Verify metadata in import results
+      expect(result1.entities[0].metadata.width).toBe(1920)
+      expect(result1.entities[0].metadata.height).toBe(1080)
+      expect(result2.entities[0].metadata.width).toBe(800)
+      expect(result2.entities[0].metadata.height).toBe(600)
+
+      // Query all media entities - verifies they're in the knowledge graph
+      const allImages = await brain.find({ type: 'media' })
+      expect(allImages.length).toBeGreaterThan(0)
+
+      // Verify multiple media entities were stored
+      const mediaEntities = allImages.filter(img => img.type === 'media')
+      expect(mediaEntities.length).toBeGreaterThanOrEqual(2)
+    })
+  })
+})

tests/unit/augmentations/format-handler-registry.test.ts

@@ -0,0 +1,437 @@
+/**
+ * FormatHandlerRegistry Tests (v5.2.0)
+ *
+ * Tests for MIME-based format handler registration and routing
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest'
+import { FormatHandlerRegistry } from '../../../src/augmentations/intelligentImport/FormatHandlerRegistry.js'
+import type { FormatHandler, ProcessedData } from '../../../src/augmentations/intelligentImport/types.js'
+
+describe('FormatHandlerRegistry (v5.2.0)', () => {
+  let registry: FormatHandlerRegistry
+
+  // Mock handlers for testing
+  const createMockHandler = (format: string): FormatHandler => ({
+    format,
+    async process(): Promise<ProcessedData> {
+      return {
+        format,
+        data: [],
+        metadata: {
+          rowCount: 0,
+          fields: [],
+          processingTime: 0
+        }
+      }
+    },
+    canHandle(): boolean {
+      return true
+    }
+  })
+
+  beforeEach(() => {
+    registry = new FormatHandlerRegistry()
+  })
+
+  describe('Handler Registration', () => {
+    it('should register handler with MIME types and extensions', () => {
+      const csvHandler = createMockHandler('csv')
+
+      registry.registerHandler({
+        name: 'csv',
+        mimeTypes: ['text/csv', 'application/csv'],
+        extensions: ['.csv', '.tsv'],
+        loader: async () => csvHandler
+      })
+
+      expect(registry.hasHandler('csv')).toBe(true)
+      expect(registry.getRegisteredHandlers()).toContain('csv')
+    })
+
+    it('should register multiple handlers', () => {
+      registry.registerHandler({
+        name: 'csv',
+        mimeTypes: ['text/csv'],
+        extensions: ['.csv'],
+        loader: async () => createMockHandler('csv')
+      })
+
+      registry.registerHandler({
+        name: 'excel',
+        mimeTypes: ['application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'],
+        extensions: ['.xlsx'],
+        loader: async () => createMockHandler('excel')
+      })
+
+      const handlers = registry.getRegisteredHandlers()
+      expect(handlers).toContain('csv')
+      expect(handlers).toContain('excel')
+      expect(handlers).toHaveLength(2)
+    })
+
+    it('should normalize extensions (remove leading dots)', () => {
+      registry.registerHandler({
+        name: 'test',
+        mimeTypes: [],
+        extensions: ['.txt', 'md'], // Mixed with/without dots
+        loader: async () => createMockHandler('test')
+      })
+
+      expect(registry.hasHandler('test')).toBe(true)
+    })
+  })
+
+  describe('MIME Type Routing', () => {
+    beforeEach(() => {
+      registry.registerHandler({
+        name: 'csv',
+        mimeTypes: ['text/csv', 'application/csv'],
+        extensions: ['.csv', '.tsv'],
+        loader: async () => createMockHandler('csv')
+      })
+
+      registry.registerHandler({
+        name: 'excel',
+        mimeTypes: [
+          'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+          'application/vnd.ms-excel'
+        ],
+        extensions: ['.xlsx', '.xls'],
+        loader: async () => createMockHandler('excel')
+      })
+
+      registry.registerHandler({
+        name: 'pdf',
+        mimeTypes: ['application/pdf'],
+        extensions: ['.pdf'],
+        loader: async () => createMockHandler('pdf')
+      })
+    })
+
+    it('should get handler by MIME type', async () => {
+      const handler = await registry.getHandlerByMimeType('text/csv')
+      expect(handler).toBeDefined()
+      expect(handler?.format).toBe('csv')
+    })
+
+    it('should get handler by Excel MIME type', async () => {
+      const handler = await registry.getHandlerByMimeType(
+        'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
+      )
+      expect(handler).toBeDefined()
+      expect(handler?.format).toBe('excel')
+    })
+
+    it('should get handler by legacy Excel MIME type', async () => {
+      const handler = await registry.getHandlerByMimeType('application/vnd.ms-excel')
+      expect(handler).toBeDefined()
+      expect(handler?.format).toBe('excel')
+    })
+
+    it('should return null for unknown MIME type', async () => {
+      const handler = await registry.getHandlerByMimeType('application/unknown')
+      expect(handler).toBeNull()
+    })
+
+    it('should list handlers for a MIME type', () => {
+      const handlers = registry.getHandlersForMimeType('text/csv')
+      expect(handlers).toContain('csv')
+    })
+  })
+
+  describe('Extension Routing', () => {
+    beforeEach(() => {
+      registry.registerHandler({
+        name: 'csv',
+        mimeTypes: ['text/csv'],
+        extensions: ['.csv', '.tsv'],
+        loader: async () => createMockHandler('csv')
+      })
+
+      registry.registerHandler({
+        name: 'excel',
+        mimeTypes: ['application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'],
+        extensions: ['.xlsx', '.xls'],
+        loader: async () => createMockHandler('excel')
+      })
+    })
+
+    it('should get handler by extension (with dot)', async () => {
+      const handler = await registry.getHandlerByExtension('.csv')
+      expect(handler).toBeDefined()
+      expect(handler?.format).toBe('csv')
+    })
+
+    it('should get handler by extension (without dot)', async () => {
+      const handler = await registry.getHandlerByExtension('csv')
+      expect(handler).toBeDefined()
+      expect(handler?.format).toBe('csv')
+    })
+
+    it('should handle case-insensitive extensions', async () => {
+      const handler = await registry.getHandlerByExtension('.XLSX')
+      expect(handler).toBeDefined()
+      expect(handler?.format).toBe('excel')
+    })
+
+    it('should return null for unknown extension', async () => {
+      const handler = await registry.getHandlerByExtension('.xyz')
+      expect(handler).toBeNull()
+    })
+  })
+
+  describe('Filename-Based Handler Selection', () => {
+    beforeEach(() => {
+      registry.registerHandler({
+        name: 'csv',
+        mimeTypes: ['text/csv'],
+        extensions: ['.csv'],
+        loader: async () => createMockHandler('csv')
+      })
+
+      registry.registerHandler({
+        name: 'excel',
+        mimeTypes: ['application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'],
+        extensions: ['.xlsx'],
+        loader: async () => createMockHandler('excel')
+      })
+    })
+
+    it('should get handler by filename (MIME detection)', async () => {
+      const handler = await registry.getHandler('data.xlsx')
+      expect(handler).toBeDefined()
+      expect(handler?.format).toBe('excel')
+    })
+
+    it('should get handler by filename (extension fallback)', async () => {
+      const handler = await registry.getHandler('report.csv')
+      expect(handler).toBeDefined()
+      expect(handler?.format).toBe('csv')
+    })
+
+    it('should handle full paths', async () => {
+      const handler = await registry.getHandler('/path/to/file.xlsx')
+      expect(handler).toBeDefined()
+      expect(handler?.format).toBe('excel')
+    })
+
+    it('should return null for unsupported filename', async () => {
+      const handler = await registry.getHandler('document.txt')
+      expect(handler).toBeNull()
+    })
+  })
+
+  describe('Lazy Loading', () => {
+    it('should lazy-load handlers on first access', async () => {
+      let loadCount = 0
+
+      registry.registerHandler({
+        name: 'csv',
+        mimeTypes: ['text/csv'],
+        extensions: ['.csv'],
+        loader: async () => {
+          loadCount++
+          return createMockHandler('csv')
+        }
+      })
+
+      expect(loadCount).toBe(0)
+
+      const handler1 = await registry.getHandlerByName('csv')
+      expect(loadCount).toBe(1)
+      expect(handler1?.format).toBe('csv')
+
+      // Second access should use cached instance
+      const handler2 = await registry.getHandlerByName('csv')
+      expect(loadCount).toBe(1) // Still 1, not 2
+      expect(handler2).toBe(handler1) // Same instance
+    })
+
+    it('should cache handler instances', async () => {
+      registry.registerHandler({
+        name: 'csv',
+        mimeTypes: ['text/csv'],
+        extensions: ['.csv'],
+        loader: async () => createMockHandler('csv')
+      })
+
+      const handler1 = await registry.getHandlerByExtension('.csv')
+      const handler2 = await registry.getHandlerByMimeType('text/csv')
+
+      expect(handler2).toBe(handler1) // Same cached instance
+    })
+
+    it('should handle loader errors gracefully', async () => {
+      registry.registerHandler({
+        name: 'failing',
+        mimeTypes: ['application/x-failing'],
+        extensions: ['.fail'],
+        loader: async () => {
+          throw new Error('Handler failed to load')
+        }
+      })
+
+      const handler = await registry.getHandlerByExtension('.fail')
+      expect(handler).toBeNull()
+    })
+  })
+
+  describe('Interface Compatibility', () => {
+    it('should implement HandlerRegistry interface', () => {
+      // Check required properties exist
+      expect(registry.handlers).toBeDefined()
+      expect(registry.loaded).toBeDefined()
+      expect(typeof registry.register).toBe('function')
+      expect(typeof registry.getHandler).toBe('function')
+    })
+
+    it('should support register() method for backward compatibility', async () => {
+      const csvHandler = createMockHandler('csv')
+
+      registry.register(['.csv', '.tsv'], async () => csvHandler)
+
+      const handler = await registry.getHandler('.csv')
+      expect(handler).toBe(csvHandler)
+    })
+
+    it('should populate handlers Map for backward compatibility', () => {
+      registry.registerHandler({
+        name: 'csv',
+        mimeTypes: ['text/csv'],
+        extensions: ['.csv'],
+        loader: async () => createMockHandler('csv')
+      })
+
+      expect(registry.handlers.has('csv')).toBe(true)
+      expect(typeof registry.handlers.get('csv')).toBe('function')
+    })
+
+    it('should populate loaded Map after loading', async () => {
+      registry.registerHandler({
+        name: 'csv',
+        mimeTypes: ['text/csv'],
+        extensions: ['.csv'],
+        loader: async () => createMockHandler('csv')
+      })
+
+      expect(registry.loaded.has('csv')).toBe(false)
+
+      await registry.getHandlerByName('csv')
+
+      expect(registry.loaded.has('csv')).toBe(true)
+    })
+  })
+
+  describe('Multiple Handlers Per MIME Type', () => {
+    it('should support multiple handlers for same MIME type', () => {
+      registry.registerHandler({
+        name: 'csv-basic',
+        mimeTypes: ['text/csv'],
+        extensions: ['.csv'],
+        loader: async () => createMockHandler('csv-basic')
+      })
+
+      registry.registerHandler({
+        name: 'csv-advanced',
+        mimeTypes: ['text/csv'],
+        extensions: ['.csv'],
+        loader: async () => createMockHandler('csv-advanced')
+      })
+
+      const handlers = registry.getHandlersForMimeType('text/csv')
+      expect(handlers).toHaveLength(2)
+      expect(handlers).toContain('csv-basic')
+      expect(handlers).toContain('csv-advanced')
+    })
+
+    it('should return first matching handler', async () => {
+      registry.registerHandler({
+        name: 'csv-basic',
+        mimeTypes: ['text/csv'],
+        extensions: ['.csv'],
+        loader: async () => createMockHandler('csv-basic')
+      })
+
+      registry.registerHandler({
+        name: 'csv-advanced',
+        mimeTypes: ['text/csv'],
+        extensions: ['.csv'],
+        loader: async () => createMockHandler('csv-advanced')
+      })
+
+      // Should return first registered handler
+      const handler = await registry.getHandlerByMimeType('text/csv')
+      expect(handler?.format).toBe('csv-basic')
+    })
+  })
+
+  describe('Registry Management', () => {
+    it('should clear all handlers', () => {
+      registry.registerHandler({
+        name: 'csv',
+        mimeTypes: ['text/csv'],
+        extensions: ['.csv'],
+        loader: async () => createMockHandler('csv')
+      })
+
+      expect(registry.hasHandler('csv')).toBe(true)
+
+      registry.clear()
+
+      expect(registry.hasHandler('csv')).toBe(false)
+      expect(registry.getRegisteredHandlers()).toHaveLength(0)
+    })
+
+    it('should check if handler is registered', () => {
+      expect(registry.hasHandler('csv')).toBe(false)
+
+      registry.registerHandler({
+        name: 'csv',
+        mimeTypes: ['text/csv'],
+        extensions: ['.csv'],
+        loader: async () => createMockHandler('csv')
+      })
+
+      expect(registry.hasHandler('csv')).toBe(true)
+      expect(registry.hasHandler('excel')).toBe(false)
+    })
+  })
+
+  describe('Edge Cases', () => {
+    it('should handle files without extensions', async () => {
+      registry.registerHandler({
+        name: 'csv',
+        mimeTypes: ['text/csv'],
+        extensions: ['.csv'],
+        loader: async () => createMockHandler('csv')
+      })
+
+      const handler = await registry.getHandler('data')
+      expect(handler).toBeNull()
+    })
+
+    it('should handle empty extension list', () => {
+      registry.registerHandler({
+        name: 'special',
+        mimeTypes: ['application/x-special'],
+        extensions: [],
+        loader: async () => createMockHandler('special')
+      })
+
+      expect(registry.hasHandler('special')).toBe(true)
+    })
+
+    it('should handle empty MIME type list', async () => {
+      registry.registerHandler({
+        name: 'extension-only',
+        mimeTypes: [],
+        extensions: ['.xyz'],
+        loader: async () => createMockHandler('extension-only')
+      })
+
+      const handler = await registry.getHandlerByExtension('.xyz')
+      expect(handler?.format).toBe('extension-only')
+    })
+  })
+})

tests/unit/augmentations/image-handler.test.ts

@@ -0,0 +1,316 @@
+/**
+ * ImageHandler Tests (v5.2.0)
+ *
+ * Tests for image processing with EXIF extraction and metadata extraction
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest'
+import { ImageHandler } from '../../../src/augmentations/intelligentImport/handlers/imageHandler.js'
+import sharp from 'sharp'
+
+describe('ImageHandler (v5.2.0)', () => {
+  let handler: ImageHandler
+
+  // Create test images programmatically
+  const createTestImage = async (
+    width: number,
+    height: number,
+    format: 'jpeg' | 'png' | 'webp' = 'jpeg'
+  ): Promise<Buffer> => {
+    // Create a simple colored rectangle
+    const channels = format === 'png' ? 4 : 3 // PNG has alpha, JPEG doesn't
+    const pixelData = Buffer.alloc(width * height * channels)
+
+    // Fill with gradient colors
+    for (let y = 0; y < height; y++) {
+      for (let x = 0; x < width; x++) {
+        const i = (y * width + x) * channels
+        pixelData[i] = Math.floor((x / width) * 255) // Red gradient
+        pixelData[i + 1] = Math.floor((y / height) * 255) // Green gradient
+        pixelData[i + 2] = 128 // Blue constant
+        if (channels === 4) {
+          pixelData[i + 3] = 255 // Alpha (opaque)
+        }
+      }
+    }
+
+    // Convert raw pixel data to image format
+    let image = sharp(pixelData, {
+      raw: {
+        width,
+        height,
+        channels
+      }
+    })
+
+    if (format === 'jpeg') {
+      image = image.jpeg({ quality: 90 })
+    } else if (format === 'png') {
+      image = image.png()
+    } else if (format === 'webp') {
+      image = image.webp({ quality: 90 })
+    }
+
+    return image.toBuffer()
+  }
+
+  beforeEach(() => {
+    handler = new ImageHandler()
+  })
+
+  describe('Handler Detection', () => {
+    it('should identify as image format handler', () => {
+      expect(handler.format).toBe('image')
+    })
+
+    it('should handle JPEG files by filename', () => {
+      expect(handler.canHandle({ filename: 'photo.jpg' })).toBe(true)
+      expect(handler.canHandle({ filename: 'photo.jpeg' })).toBe(true)
+    })
+
+    it('should handle PNG files by filename', () => {
+      expect(handler.canHandle({ filename: 'logo.png' })).toBe(true)
+    })
+
+    it('should handle WebP files by filename', () => {
+      expect(handler.canHandle({ filename: 'image.webp' })).toBe(true)
+    })
+
+    it('should handle other image formats', () => {
+      expect(handler.canHandle({ filename: 'photo.gif' })).toBe(true)
+      expect(handler.canHandle({ filename: 'photo.tiff' })).toBe(true)
+      expect(handler.canHandle({ filename: 'photo.bmp' })).toBe(true)
+      expect(handler.canHandle({ filename: 'icon.svg' })).toBe(true)
+    })
+
+    it('should handle images by extension', () => {
+      expect(handler.canHandle({ ext: '.jpg' })).toBe(true)
+      expect(handler.canHandle({ ext: 'png' })).toBe(true)
+    })
+
+    it('should reject non-image files', () => {
+      expect(handler.canHandle({ filename: 'document.pdf' })).toBe(false)
+      expect(handler.canHandle({ filename: 'data.csv' })).toBe(false)
+      expect(handler.canHandle({ filename: 'text.txt' })).toBe(false)
+    })
+
+    it('should detect JPEG by magic bytes', async () => {
+      const jpegBuffer = await createTestImage(100, 100, 'jpeg')
+      expect(handler.canHandle(jpegBuffer)).toBe(true)
+    })
+
+    it('should detect PNG by magic bytes', async () => {
+      const pngBuffer = await createTestImage(100, 100, 'png')
+      expect(handler.canHandle(pngBuffer)).toBe(true)
+    })
+  })
+
+  describe('Image Metadata Extraction', () => {
+    it('should extract JPEG metadata', async () => {
+      const imageBuffer = await createTestImage(800, 600, 'jpeg')
+
+      const result = await handler.process(imageBuffer, {
+        extractEXIF: false
+      })
+
+      expect(result.format).toBe('image')
+      expect(result.data).toHaveLength(1)
+
+      const imageData = result.data[0]
+      expect(imageData.type).toBe('media')
+      expect(imageData.metadata).toBeDefined()
+      expect(imageData.metadata.subtype).toBe('image')
+      expect(imageData.metadata.width).toBe(800)
+      expect(imageData.metadata.height).toBe(600)
+      expect(imageData.metadata.format).toBe('jpeg')
+    })
+
+    it('should extract PNG metadata', async () => {
+      const imageBuffer = await createTestImage(400, 300, 'png')
+
+      const result = await handler.process(imageBuffer, {
+        extractEXIF: false
+      })
+
+      const imageData = result.data[0]
+      expect(imageData.metadata.width).toBe(400)
+      expect(imageData.metadata.height).toBe(300)
+      expect(imageData.metadata.format).toBe('png')
+      expect(imageData.metadata.hasAlpha).toBe(true)
+    })
+
+    it('should extract WebP metadata', async () => {
+      const imageBuffer = await createTestImage(500, 500, 'webp')
+
+      const result = await handler.process(imageBuffer, {
+        extractEXIF: false
+      })
+
+      const imageData = result.data[0]
+      expect(imageData.metadata.width).toBe(500)
+      expect(imageData.metadata.height).toBe(500)
+      expect(imageData.metadata.format).toBe('webp')
+    })
+
+    it('should include image size in bytes', async () => {
+      const imageBuffer = await createTestImage(200, 200, 'jpeg')
+
+      const result = await handler.process(imageBuffer)
+
+      const imageData = result.data[0]
+      expect(imageData.metadata.size).toBe(imageBuffer.length)
+      expect(imageData.metadata.size).toBeGreaterThan(0)
+    })
+
+    it('should include color space and channels', async () => {
+      const imageBuffer = await createTestImage(100, 100, 'jpeg')
+
+      const result = await handler.process(imageBuffer, {
+        extractEXIF: false
+      })
+
+      const imageData = result.data[0]
+      expect(imageData.metadata.space).toBeDefined()
+      expect(imageData.metadata.channels).toBeGreaterThan(0)
+      expect(imageData.metadata.depth).toBeDefined()
+    })
+
+    it('should include processing time in metadata', async () => {
+      const imageBuffer = await createTestImage(800, 600, 'jpeg')
+
+      const result = await handler.process(imageBuffer)
+
+      expect(result.metadata.processingTime).toBeGreaterThan(0)
+      expect(result.metadata.processingTime).toBeLessThan(5000)
+    })
+
+    it('should include image metadata in result metadata', async () => {
+      const imageBuffer = await createTestImage(800, 600, 'jpeg')
+
+      const result = await handler.process(imageBuffer)
+
+      expect(result.metadata.imageMetadata).toBeDefined()
+      expect(result.metadata.imageMetadata.width).toBe(800)
+      expect(result.metadata.imageMetadata.height).toBe(600)
+    })
+  })
+
+  describe('EXIF Data Extraction', () => {
+    it('should handle images without EXIF data', async () => {
+      const imageBuffer = await createTestImage(800, 600, 'jpeg')
+
+      const result = await handler.process(imageBuffer, {
+        extractEXIF: true
+      })
+
+      const imageData = result.data[0]
+      // Should not crash, EXIF will be undefined
+      expect(imageData.metadata.exif).toBeUndefined()
+    })
+
+    it('should extract EXIF by default', async () => {
+      const imageBuffer = await createTestImage(800, 600, 'jpeg')
+
+      // Default: EXIF extraction enabled
+      const result = await handler.process(imageBuffer)
+
+      // Will be undefined for test images, but should not crash
+      expect(result.metadata.exifData).toBeUndefined()
+    })
+
+    it('should allow disabling EXIF extraction', async () => {
+      const imageBuffer = await createTestImage(800, 600, 'jpeg')
+
+      const result = await handler.process(imageBuffer, {
+        extractEXIF: false
+      })
+
+      const imageData = result.data[0]
+      expect(imageData.metadata.exif).toBeUndefined()
+    })
+  })
+
+  describe('Error Handling', () => {
+    it('should throw error for invalid image data', async () => {
+      const invalidBuffer = Buffer.from('not an image', 'utf-8')
+
+      await expect(handler.process(invalidBuffer)).rejects.toThrow('Image processing failed')
+    })
+
+    it('should throw error for empty buffer', async () => {
+      const emptyBuffer = Buffer.alloc(0)
+
+      await expect(handler.process(emptyBuffer)).rejects.toThrow()
+    })
+  })
+
+  describe('Format Support', () => {
+    it('should process JPEG images', async () => {
+      const imageBuffer = await createTestImage(200, 200, 'jpeg')
+
+      const result = await handler.process(imageBuffer, {
+        extractEXIF: false
+      })
+
+      expect(result.data[0].metadata.format).toBe('jpeg')
+    })
+
+    it('should process PNG images', async () => {
+      const imageBuffer = await createTestImage(200, 200, 'png')
+
+      const result = await handler.process(imageBuffer, {
+        extractEXIF: false
+      })
+
+      expect(result.data[0].metadata.format).toBe('png')
+    })
+
+    it('should process WebP images', async () => {
+      const imageBuffer = await createTestImage(200, 200, 'webp')
+
+      const result = await handler.process(imageBuffer, {
+        extractEXIF: false
+      })
+
+      expect(result.data[0].metadata.format).toBe('webp')
+    })
+
+    it('should handle various image dimensions', async () => {
+      const sizes = [
+        [100, 100],
+        [1920, 1080],
+        [400, 300],
+        [1000, 500]
+      ]
+
+      for (const [width, height] of sizes) {
+        const imageBuffer = await createTestImage(width, height, 'jpeg')
+        const result = await handler.process(imageBuffer, { extractEXIF: false })
+
+        expect(result.data[0].metadata.width).toBe(width)
+        expect(result.data[0].metadata.height).toBe(height)
+      }
+    })
+  })
+
+  describe('Integration with BaseFormatHandler', () => {
+    it('should inherit MIME type detection from BaseFormatHandler', () => {
+      // getMimeType is protected, but we can verify behavior
+      expect(handler.canHandle({ filename: 'test.jpg' })).toBe(true)
+      expect(handler.canHandle({ filename: 'test.png' })).toBe(true)
+    })
+
+    it('should provide structured ProcessedData', async () => {
+      const imageBuffer = await createTestImage(200, 200, 'jpeg')
+
+      const result = await handler.process(imageBuffer)
+
+      // Should match ProcessedData interface
+      expect(result).toHaveProperty('format')
+      expect(result).toHaveProperty('data')
+      expect(result).toHaveProperty('metadata')
+      expect(result.format).toBe('image')
+      expect(Array.isArray(result.data)).toBe(true)
+    })
+  })
+})

tests/unit/vfs/blob-storage-integration.test.ts

@@ -0,0 +1,187 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { Brainy } from '../../../src/brainy.js'
+import { VirtualFileSystem } from '../../../src/vfs/VirtualFileSystem.js'
+import * as fs from 'fs/promises'
+import * as path from 'path'
+
+/**
+ * v5.2.0: Test unified BlobStorage integration with VFS
+ *
+ * This test verifies that:
+ * 1. All files (small, medium, large) use BlobStorage
+ * 2. No size-based branching occurs
+ * 3. Content is stored and retrieved correctly
+ * 4. Deduplication works automatically
+ *
+ * Note: Uses FileSystemStorage because BlobStorage is only available
+ * in COW-enabled storage adapters (not MemoryStorage)
+ */
+describe('VFS Unified BlobStorage (v5.2.0)', () => {
+  let brain: Brainy
+  let vfs: VirtualFileSystem
+  let testDir: string
+
+  beforeEach(async () => {
+    // Create temporary directory for test storage
+    testDir = path.join('/tmp', `brainy-test-blob-${Date.now()}-${Math.random().toString(36).slice(2)}`)
+    await fs.mkdir(testDir, { recursive: true })
+
+    brain = new Brainy({
+      storage: {
+        type: 'filesystem',
+        options: { path: testDir }
+      },
+      silent: true
+    })
+    await brain.init()
+    vfs = brain.vfs
+  })
+
+  afterEach(async () => {
+    await brain.close()
+
+    // Clean up temporary directory
+    try {
+      await fs.rm(testDir, { recursive: true, force: true })
+    } catch (error) {
+      // Ignore cleanup errors
+    }
+  })
+
+  describe('Unified Storage Path', () => {
+    it('should store small files (<100KB) in BlobStorage', async () => {
+      const content = 'Small file content'
+      await vfs.writeFile('/small.txt', content)
+
+      // Get entity directly using VFS API
+      const entity = await vfs.getEntity('/small.txt')
+
+      expect(entity.metadata.vfsType).toBe('file')
+      expect(entity.metadata.storage?.type).toBe('blob')
+      expect(entity.metadata.storage?.hash).toBeDefined()
+
+      const readContent = await vfs.readFile('/small.txt')
+      expect(readContent.toString()).toBe(content)
+    })
+
+    it('should store medium files (100KB-10MB) in BlobStorage', async () => {
+      const content = Buffer.alloc(200_000, 'M') // 200KB
+      await vfs.writeFile('/medium.bin', content)
+
+      const entity = await vfs.getEntity('/medium.bin')
+
+      expect(entity.metadata.vfsType).toBe('file')
+      expect(entity.metadata.storage?.type).toBe('blob')
+      expect(entity.metadata.storage?.hash).toBeDefined()
+
+      const readContent = await vfs.readFile('/medium.bin')
+      expect(Buffer.compare(readContent, content)).toBe(0)
+    })
+
+    it('should store large files (>10MB) in BlobStorage', async () => {
+      const content = Buffer.alloc(11_000_000, 'L') // 11MB
+      await vfs.writeFile('/large.bin', content)
+
+      const entity = await vfs.getEntity('/large.bin')
+
+      expect(entity.metadata.vfsType).toBe('file')
+      expect(entity.metadata.storage?.type).toBe('blob')
+      expect(entity.metadata.storage?.hash).toBeDefined()
+
+      const readContent = await vfs.readFile('/large.bin')
+      expect(Buffer.compare(readContent, content)).toBe(0)
+    })
+  })
+
+  describe('Deduplication', () => {
+    it('should deduplicate identical files', async () => {
+      const content = 'Duplicate content test'
+
+      // Write same content to two different paths
+      await vfs.writeFile('/file1.txt', content)
+      await vfs.writeFile('/file2.txt', content)
+
+      // Get entities directly
+      const entity1 = await vfs.getEntity('/file1.txt')
+      const entity2 = await vfs.getEntity('/file2.txt')
+
+      // Both should have blob storage
+      expect(entity1.metadata.storage?.type).toBe('blob')
+      expect(entity2.metadata.storage?.type).toBe('blob')
+
+      // But same blob hash (deduplicated)
+      const hash1 = entity1.metadata.storage?.hash
+      const hash2 = entity2.metadata.storage?.hash
+
+      expect(hash1).toBeDefined()
+      expect(hash2).toBeDefined()
+      expect(hash1).toBe(hash2) // Same content = same hash
+    })
+  })
+
+  describe('File Operations', () => {
+    it('should update files correctly', async () => {
+      await vfs.writeFile('/update.txt', 'Original content')
+      await vfs.writeFile('/update.txt', 'Updated content')
+
+      const content = await vfs.readFile('/update.txt')
+      expect(content.toString()).toBe('Updated content')
+    })
+
+    it('should delete files and decrement blob refs', async () => {
+      await vfs.writeFile('/delete.txt', 'Delete me')
+
+      await vfs.unlink('/delete.txt')
+
+      await expect(vfs.readFile('/delete.txt')).rejects.toThrow()
+    })
+
+    it('should append to files', async () => {
+      await vfs.writeFile('/append.txt', 'First part')
+      await vfs.appendFile('/append.txt', ' Second part')
+
+      const content = await vfs.readFile('/append.txt')
+      expect(content.toString()).toBe('First part Second part')
+    })
+  })
+
+  describe('Binary Files', () => {
+    it('should handle binary files correctly', async () => {
+      const binary = Buffer.from([0x00, 0xFF, 0xAB, 0xCD, 0xEF])
+      await vfs.writeFile('/binary.dat', binary)
+
+      const read = await vfs.readFile('/binary.dat')
+      expect(Buffer.compare(read, binary)).toBe(0)
+    })
+
+    it('should preserve binary file integrity', async () => {
+      // Create a buffer with various byte patterns
+      const buffer = Buffer.alloc(1000)
+      for (let i = 0; i < 1000; i++) {
+        buffer[i] = i % 256
+      }
+
+      await vfs.writeFile('/integrity.bin', buffer)
+      const read = await vfs.readFile('/integrity.bin')
+
+      expect(Buffer.compare(read, buffer)).toBe(0)
+      expect(read.length).toBe(buffer.length)
+    })
+  })
+
+  describe('Metadata', () => {
+    it('should store correct metadata', async () => {
+      const content = 'Test file'
+      await vfs.writeFile('/meta.txt', content)
+
+      const entity = await vfs.getEntity('/meta.txt')
+
+      expect(entity.metadata.size).toBe(content.length)
+      expect(entity.metadata.vfsType).toBe('file')
+      expect(entity.metadata.storage?.type).toBe('blob')
+      expect(entity.metadata.storage?.size).toBe(content.length)
+      expect(entity.metadata.mimeType).toBeDefined()
+    })
+  })
+
+})

tests/unit/vfs/mime-type-detection.test.ts

@@ -0,0 +1,230 @@
+/**
+ * Comprehensive MIME Type Detection Tests (v5.2.0)
+ *
+ * Verifies that MimeTypeDetector correctly identifies:
+ * - Standard types (via mime library)
+ * - Custom developer types (shell, configs, modern languages)
+ * - Office formats (Microsoft, OpenDocument)
+ * - Special files (Dockerfile, Makefile, dotfiles)
+ */
+
+import { describe, it, expect } from 'vitest'
+import { mimeDetector } from '../../../src/vfs/MimeTypeDetector.js'
+
+describe('MimeTypeDetector (v5.2.0)', () => {
+  describe('Code Files - Programming Languages', () => {
+    it('should detect TypeScript files', () => {
+      expect(mimeDetector.detectMimeType('file.ts')).toBe('text/typescript')
+      expect(mimeDetector.detectMimeType('component.tsx')).toBe('text/typescript')
+    })
+
+    it('should detect JavaScript files', () => {
+      // mime library returns text/javascript for .js (IANA standard)
+      expect(mimeDetector.detectMimeType('file.js')).toBe('text/javascript')
+      expect(mimeDetector.detectMimeType('component.jsx')).toBe('text/javascript')
+      expect(mimeDetector.detectMimeType('module.mjs')).toBe('text/javascript')
+    })
+
+    it('should detect modern languages', () => {
+      expect(mimeDetector.detectMimeType('file.kt')).toBe('text/x-kotlin')
+      expect(mimeDetector.detectMimeType('file.swift')).toBe('text/x-swift')
+      expect(mimeDetector.detectMimeType('file.dart')).toBe('text/x-dart')
+      expect(mimeDetector.detectMimeType('script.lua')).toBe('text/x-lua')
+      expect(mimeDetector.detectMimeType('app.scala')).toBe('text/x-scala')
+    })
+
+    it('should detect traditional languages', () => {
+      expect(mimeDetector.detectMimeType('script.py')).toBe('text/x-python')
+      expect(mimeDetector.detectMimeType('main.go')).toBe('text/x-go')
+      expect(mimeDetector.detectMimeType('lib.rs')).toBe('text/x-rust')
+      expect(mimeDetector.detectMimeType('App.java')).toBe('text/x-java')
+      expect(mimeDetector.detectMimeType('main.c')).toBe('text/x-c')
+      expect(mimeDetector.detectMimeType('main.cpp')).toBe('text/x-c++')
+    })
+
+    it('should detect functional languages', () => {
+      expect(mimeDetector.detectMimeType('main.hs')).toBe('text/x-haskell')
+      expect(mimeDetector.detectMimeType('core.clj')).toBe('text/x-clojure')
+      expect(mimeDetector.detectMimeType('server.erl')).toBe('text/x-erlang')
+      expect(mimeDetector.detectMimeType('lib.ex')).toBe('text/x-elixir')
+    })
+  })
+
+  describe('Shell Scripts', () => {
+    it('should detect various shell script types', () => {
+      expect(mimeDetector.detectMimeType('script.sh')).toBe('application/x-sh')
+      expect(mimeDetector.detectMimeType('setup.bash')).toBe('text/x-shellscript')
+      expect(mimeDetector.detectMimeType('config.zsh')).toBe('text/x-shellscript')
+      expect(mimeDetector.detectMimeType('functions.fish')).toBe('text/x-shellscript')
+    })
+  })
+
+  describe('Configuration Files', () => {
+    it('should detect config file formats', () => {
+      expect(mimeDetector.detectMimeType('.env')).toBe('text/x-env')
+      expect(mimeDetector.detectMimeType('config.ini')).toBe('text/x-ini')
+      expect(mimeDetector.detectMimeType('app.properties')).toBe('text/x-java-properties')
+      expect(mimeDetector.detectMimeType('settings.conf')).toBe('text/plain')
+    })
+
+    it('should detect dotfiles', () => {
+      expect(mimeDetector.detectMimeType('.gitignore')).toBe('text/plain')
+      expect(mimeDetector.detectMimeType('.dockerignore')).toBe('text/plain')
+      expect(mimeDetector.detectMimeType('.npmignore')).toBe('text/plain')
+      expect(mimeDetector.detectMimeType('.editorconfig')).toBe('text/plain')
+    })
+  })
+
+  describe('Build & Project Files', () => {
+    it('should detect special build files', () => {
+      expect(mimeDetector.detectMimeType('Dockerfile')).toBe('text/x-dockerfile')
+      expect(mimeDetector.detectMimeType('Makefile')).toBe('text/x-makefile')
+      expect(mimeDetector.detectMimeType('build.gradle')).toBe('text/x-gradle')
+      expect(mimeDetector.detectMimeType('CMakeLists.txt.cmake')).toBe('text/x-cmake')
+    })
+  })
+
+  describe('Web Framework Components', () => {
+    it('should detect modern web frameworks', () => {
+      expect(mimeDetector.detectMimeType('Component.vue')).toBe('text/x-vue')
+      expect(mimeDetector.detectMimeType('Page.svelte')).toBe('text/x-svelte')
+      expect(mimeDetector.detectMimeType('layout.astro')).toBe('text/x-astro')
+    })
+
+    it('should detect style preprocessors', () => {
+      expect(mimeDetector.detectMimeType('styles.scss')).toBe('text/x-scss')
+      expect(mimeDetector.detectMimeType('theme.sass')).toBe('text/x-sass')
+      expect(mimeDetector.detectMimeType('main.less')).toBe('text/x-less')
+    })
+  })
+
+  describe('Data Formats', () => {
+    it('should detect standard data formats', () => {
+      expect(mimeDetector.detectMimeType('data.json')).toBe('application/json')
+      expect(mimeDetector.detectMimeType('config.yaml')).toBe('text/yaml')
+      expect(mimeDetector.detectMimeType('config.yml')).toBe('text/yaml')
+      expect(mimeDetector.detectMimeType('data.xml')).toBe('text/xml')
+      expect(mimeDetector.detectMimeType('data.csv')).toBe('text/csv')
+    })
+
+    it('should detect big data formats', () => {
+      expect(mimeDetector.detectMimeType('data.parquet')).toBe('application/vnd.apache.parquet')
+      expect(mimeDetector.detectMimeType('schema.avro')).toBe('application/avro')
+      expect(mimeDetector.detectMimeType('api.proto')).toBe('text/x-protobuf')
+    })
+  })
+
+  describe('Office Formats - Microsoft Office', () => {
+    it('should detect Word documents', () => {
+      expect(mimeDetector.detectMimeType('document.docx'))
+        .toBe('application/vnd.openxmlformats-officedocument.wordprocessingml.document')
+      expect(mimeDetector.detectMimeType('template.dotx'))
+        .toBe('application/vnd.openxmlformats-officedocument.wordprocessingml.template')
+    })
+
+    it('should detect Excel spreadsheets', () => {
+      expect(mimeDetector.detectMimeType('spreadsheet.xlsx'))
+        .toBe('application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')
+      expect(mimeDetector.detectMimeType('template.xltx'))
+        .toBe('application/vnd.openxmlformats-officedocument.spreadsheetml.template')
+    })
+
+    it('should detect PowerPoint presentations', () => {
+      expect(mimeDetector.detectMimeType('presentation.pptx'))
+        .toBe('application/vnd.openxmlformats-officedocument.presentationml.presentation')
+    })
+  })
+
+  describe('Office Formats - OpenDocument', () => {
+    it('should detect OpenDocument formats', () => {
+      expect(mimeDetector.detectMimeType('document.odt')).toBe('application/vnd.oasis.opendocument.text')
+      expect(mimeDetector.detectMimeType('spreadsheet.ods')).toBe('application/vnd.oasis.opendocument.spreadsheet')
+      expect(mimeDetector.detectMimeType('presentation.odp')).toBe('application/vnd.oasis.opendocument.presentation')
+    })
+  })
+
+  describe('Media Files', () => {
+    it('should detect image formats', () => {
+      expect(mimeDetector.detectMimeType('photo.jpg')).toBe('image/jpeg')
+      expect(mimeDetector.detectMimeType('logo.png')).toBe('image/png')
+      expect(mimeDetector.detectMimeType('icon.svg')).toBe('image/svg+xml')
+      expect(mimeDetector.detectMimeType('graphic.webp')).toBe('image/webp')
+    })
+
+    it('should detect video formats', () => {
+      expect(mimeDetector.detectMimeType('video.mp4')).toBe('video/mp4')
+      expect(mimeDetector.detectMimeType('movie.mov')).toBe('video/quicktime')
+      expect(mimeDetector.detectMimeType('clip.webm')).toBe('video/webm')
+    })
+
+    it('should detect audio formats', () => {
+      expect(mimeDetector.detectMimeType('song.mp3')).toBe('audio/mpeg')
+      expect(mimeDetector.detectMimeType('sound.wav')).toBe('audio/wav')
+      expect(mimeDetector.detectMimeType('podcast.ogg')).toBe('audio/ogg')
+    })
+  })
+
+  describe('Text File Detection', () => {
+    it('should identify text files correctly', () => {
+      // Code files
+      expect(mimeDetector.isTextFile('text/typescript')).toBe(true)
+      expect(mimeDetector.isTextFile('text/x-python')).toBe(true)
+      expect(mimeDetector.isTextFile('application/javascript')).toBe(true)
+
+      // Data formats
+      expect(mimeDetector.isTextFile('application/json')).toBe(true)
+      expect(mimeDetector.isTextFile('text/yaml')).toBe(true)
+      expect(mimeDetector.isTextFile('text/xml')).toBe(true)
+
+      // Binary files
+      expect(mimeDetector.isTextFile('image/png')).toBe(false)
+      expect(mimeDetector.isTextFile('video/mp4')).toBe(false)
+      expect(mimeDetector.isTextFile('application/pdf')).toBe(false)
+    })
+  })
+
+  describe('Edge Cases', () => {
+    it('should handle files without extensions', () => {
+      expect(mimeDetector.detectMimeType('Dockerfile')).toBe('text/x-dockerfile')
+      expect(mimeDetector.detectMimeType('Makefile')).toBe('text/x-makefile')
+    })
+
+    it('should handle unknown extensions', () => {
+      expect(mimeDetector.detectMimeType('file.unknown')).toBe('application/octet-stream')
+      expect(mimeDetector.detectMimeType('random.foobar123')).toBe('application/octet-stream')
+    })
+
+    it('should handle case variations', () => {
+      expect(mimeDetector.detectMimeType('FILE.TS')).toBe('text/typescript')
+      expect(mimeDetector.detectMimeType('DoCtUmEnT.JSON')).toBe('application/json')
+    })
+  })
+
+  describe('Coverage Verification', () => {
+    it('should handle 40+ file types from mime library', () => {
+      // Standard web types (from mime library)
+      expect(mimeDetector.detectMimeType('page.html')).toBe('text/html')
+      expect(mimeDetector.detectMimeType('style.css')).toBe('text/css')
+      expect(mimeDetector.detectMimeType('doc.pdf')).toBe('application/pdf')
+      expect(mimeDetector.detectMimeType('archive.zip')).toBe('application/zip')
+      expect(mimeDetector.detectMimeType('data.tar')).toBe('application/x-tar')
+    })
+
+    it('should handle 50+ custom types', () => {
+      // All custom types should be defined
+      const customTypes = [
+        ['.bash', 'text/x-shellscript'],
+        ['.kt', 'text/x-kotlin'],
+        ['.swift', 'text/x-swift'],
+        ['.dart', 'text/x-dart'],
+        ['.env', 'text/x-env'],
+        ['.vue', 'text/x-vue'],
+        ['.parquet', 'application/vnd.apache.parquet']
+      ]
+
+      customTypes.forEach(([ext, expected]) => {
+        expect(mimeDetector.detectMimeType(`file${ext}`)).toBe(expected)
+      })
+    })
+  })
+})