diff --git a/src/tests/integration/auto-generation.test.ts b/src/tests/integration/auto-generation.test.ts
deleted file mode 100644
index 57605c1..0000000
--- a/src/tests/integration/auto-generation.test.ts
+++ /dev/null
@@ -1,261 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import fs from 'fs/promises';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-// Temporarily modify process.env type for testing
-interface TestProcessEnv {
-  NODE_ENV?: string;
-  [key: string]: string | undefined;
-}
-
-// Mock file watcher and processing pipeline
-const mockFileWatcher = vi.fn();
-const mockMarkdownProcessor = vi.fn();
-const mockDatabaseSync = vi.fn();
-
-describe('Auto-Generation Integration Test', () => {
-  const testBlogDir = path.join(process.cwd(), 'test-blog');
-  const testPostPath = path.join(testBlogDir, 'test-post.md');
-
-  beforeEach(async () => {
-    // Create test directory
-    await fs.mkdir(testBlogDir, { recursive: true });
-    vi.clearAllMocks();
-  });
-
-  afterEach(async () => {
-    // Cleanup test directory
-    await fs.rm(testBlogDir, { recursive: true, force: true });
-  });
-
-  describe('File Change Detection and Processing', () => {
-    it('should detect new markdown file and trigger processing', async () => {
-      // Simulate file watcher initialization
-      mockFileWatcher.mockImplementation((dir, callback) => {
-        // Return watcher instance
-        return {
-          on: vi.fn((event, handler) => {
-            if (event === 'add') {
-              setTimeout(() => handler(testPostPath), 100);
-            }
-          }),
-          close: vi.fn(),
-        };
-      });
-
-      const watcher = mockFileWatcher(testBlogDir, async (filePath: string) => {
-        await mockMarkdownProcessor(filePath);
-      });
-
-      // Create new markdown file
-      const content = `---
-title: Test Post
-author: Test Author
-showToc: true
----
-
-# Test Post
-
-This is a test post content.`;
-
-      await fs.writeFile(testPostPath, content);
-
-      // Wait for file watcher to trigger
-      await new Promise((resolve) => setTimeout(resolve, 200));
-
-      expect(mockFileWatcher).toHaveBeenCalledWith(
-        testBlogDir,
-        expect.any(Function)
-      );
-    });
-
-    it('should process markdown changes within 1 second', async () => {
-      const startTime = Date.now();
-
-      mockMarkdownProcessor.mockResolvedValue({
-        html: '<h1>Test Post</h1>',
-        metadata: { title: 'Test Post' },
-        toc: [],
-      });
-
-      const content = `# Test Post\n\nContent`;
-      await fs.writeFile(testPostPath, content);
-
-      // Simulate immediate processing
-      const result = await mockMarkdownProcessor(testPostPath);
-      const processingTime = Date.now() - startTime;
-
-      expect(processingTime).toBeLessThan(1000);
-      expect(result).toHaveProperty('html');
-    });
-
-    it('should debounce rapid file changes', async () => {
-      let callCount = 0;
-      const debouncedProcessor = vi.fn(() => {
-        callCount++;
-      });
-
-      // Simulate debounce logic
-      let timeout: NodeJS.Timeout;
-      const debounce = (fn: (...args: unknown[]) => unknown, delay: number) => {
-        return (...args: unknown[]) => {
-          clearTimeout(timeout);
-          timeout = setTimeout(() => fn(...args), delay);
-        };
-      };
-
-      const processWithDebounce = debounce(debouncedProcessor, 500);
-
-      // Rapid file changes
-      for (let i = 0; i < 5; i++) {
-        await fs.writeFile(testPostPath, `# Test Post\n\nVersion ${i}`);
-        processWithDebounce(testPostPath);
-        await new Promise((resolve) => setTimeout(resolve, 100));
-      }
-
-      // Wait for debounce to complete
-      await new Promise((resolve) => setTimeout(resolve, 600));
-
-      // Should only process once after debounce
-      expect(callCount).toBe(1);
-    });
-
-    it('should sync processed content to IndexedDB', async () => {
-      mockMarkdownProcessor.mockResolvedValue({
-        html: '<h1>Processed</h1>',
-        metadata: {
-          title: 'Processed Post',
-          slug: 'processed-post',
-        },
-      });
-
-      mockDatabaseSync.mockResolvedValue({
-        success: true,
-        id: 'post-123',
-      });
-
-      // Process and sync
-      const processed = await mockMarkdownProcessor(testPostPath);
-      const synced = await mockDatabaseSync(processed);
-
-      expect(synced.success).toBe(true);
-      expect(synced).toHaveProperty('id');
-    });
-
-    it('should handle file deletion', async () => {
-      // Create file first
-      await fs.writeFile(testPostPath, '# Post');
-
-      // Mock deletion handler
-      const onDelete = vi.fn();
-
-      // Delete file
-      await fs.unlink(testPostPath);
-
-      // Simulate watcher detecting deletion
-      onDelete(testPostPath);
-
-      expect(onDelete).toHaveBeenCalledWith(testPostPath);
-    });
-
-    it('should ignore non-markdown files', async () => {
-      const nonMdPath = path.join(testBlogDir, 'image.png');
-
-      const shouldProcess = (filePath: string) => {
-        return path.extname(filePath) === '.md';
-      };
-
-      expect(shouldProcess(nonMdPath)).toBe(false);
-      expect(shouldProcess(testPostPath)).toBe(true);
-    });
-
-    it('should handle errors gracefully', async () => {
-      mockMarkdownProcessor.mockRejectedValue(new Error('Processing failed'));
-
-      const errorHandler = vi.fn();
-
-      try {
-        await mockMarkdownProcessor('invalid.md');
-      } catch (error) {
-        errorHandler(error);
-      }
-
-      expect(errorHandler).toHaveBeenCalled();
-    });
-
-    it('should maintain metadata during processing', async () => {
-      const originalMetadata = {
-        title: 'Original Title',
-        author: 'Original Author',
-        tags: ['test', 'blog'],
-        showToc: true,
-      };
-
-      mockMarkdownProcessor.mockResolvedValue({
-        html: '<h1>Content</h1>',
-        metadata: originalMetadata,
-        preserved: true,
-      });
-
-      const result = await mockMarkdownProcessor(testPostPath);
-
-      expect(result.metadata).toEqual(originalMetadata);
-      expect(result.metadata.showToc).toBe(true);
-    });
-  });
-
-  describe('Hot Reload in Development', () => {
-    it('should trigger hot reload on content change', async () => {
-      const hotReloadTrigger = vi.fn();
-
-      // Simulate development environment
-      const oldEnv = process.env.NODE_ENV;
-      (process.env as TestProcessEnv).NODE_ENV = 'development';
-
-      // File change triggers hot reload
-      await fs.writeFile(testPostPath, '# Updated Content');
-      hotReloadTrigger('change', testPostPath);
-
-      expect(hotReloadTrigger).toHaveBeenCalledWith('change', testPostPath);
-
-      // Cleanup
-      (process.env as TestProcessEnv).NODE_ENV = oldEnv;
-    });
-
-    it('should not trigger hot reload in production', async () => {
-      const hotReloadTrigger = vi.fn();
-
-      // Simulate production environment
-      const oldEnv = process.env.NODE_ENV;
-      (process.env as TestProcessEnv).NODE_ENV = 'production';
-
-      const shouldHotReload = () => {
-        return process.env.NODE_ENV === 'development';
-      };
-
-      expect(shouldHotReload()).toBe(false);
-
-      // Cleanup
-      (process.env as TestProcessEnv).NODE_ENV = oldEnv;
-    });
-  });
-
-  describe('Batch Processing', () => {
-    it('should handle multiple file changes efficiently', async () => {
-      const files = ['post1.md', 'post2.md', 'post3.md'];
-
-      const batchProcessor = vi.fn(async (filePaths: string[]) => {
-        return filePaths.map((fp) => ({
-          path: fp,
-          processed: true,
-        }));
-      });
-
-      const results = await batchProcessor(files);
-
-      expect(results).toHaveLength(3);
-      expect(results.every((r) => r.processed)).toBe(true);
-    });
-  });
-});
diff --git a/src/tests/integration/enhanced-processing.test.ts b/src/tests/integration/enhanced-processing.test.ts
deleted file mode 100644
index c12c6ce..0000000
--- a/src/tests/integration/enhanced-processing.test.ts
+++ /dev/null
@@ -1,637 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-
-// Type definitions for enhanced processing
-interface RemarkResult {
-  ast?: { type: string; children: unknown[] };
-  processed: boolean;
-  content?: string;
-  plugins?: PluginConfig[];
-}
-
-interface RehypeResult {
-  html: string;
-  processed?: boolean;
-  sanitized?: boolean;
-  removed?: string[];
-}
-
-interface PluginConfig {
-  name: string;
-  enabled: boolean;
-}
-
-interface SyntaxHighlightResult {
-  html: string;
-  language: string;
-  highlighted: boolean;
-  supported?: boolean;
-  fallback?: string;
-}
-
-interface TocEntry {
-  level: number;
-  text: string;
-  id: string;
-  children?: TocEntry[];
-}
-
-interface TocResult {
-  toc: TocEntry[] | null;
-  html?: string;
-  skipped?: boolean;
-  reason?: string;
-  maxDepth?: number;
-}
-
-interface TocOptions {
-  showToc: boolean;
-  maxDepth?: number;
-}
-
-interface ValidationError {
-  path: string;
-  message: string;
-}
-
-interface ValidationResult {
-  valid: boolean;
-  data?: unknown;
-  errors: ValidationError[];
-  transformed?: boolean;
-}
-
-interface FileInfo {
-  path: string;
-  modified: string;
-  hash: string;
-}
-
-interface PostInfo {
-  id: string;
-  content: string;
-}
-
-interface CacheResult {
-  html?: string;
-  processed?: boolean;
-  cached: boolean;
-  hash?: string;
-  cacheHit?: boolean;
-}
-
-interface ProcessingResult {
-  post: string;
-  success: boolean;
-  error?: string;
-  processed?: boolean;
-  fallback?: string;
-}
-
-// Mock enhanced processing services
-const mockRemarkProcessor = vi.fn();
-const mockRehypeProcessor = vi.fn();
-const mockSyntaxHighlighter = vi.fn();
-const mockTocGenerator = vi.fn();
-const mockZodValidator = vi.fn();
-const mockCacheManager = vi.fn();
-
-describe('Enhanced Processing Integration Test', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe('Remark/Rehype Processing Pipeline', () => {
-    it('should process markdown through remark/rehype pipeline', async () => {
-      const markdown = `# Title
-
-This is a **bold** paragraph with *italic* text.
-
-## Section 1
-
-Content with [link](https://example.com).
-
-\`\`\`javascript
-const hello = () => {
-  console.log('Hello World');
-};
-\`\`\``;
-
-      mockRemarkProcessor.mockResolvedValue({
-        ast: { type: 'root', children: [] },
-        processed: true,
-      });
-
-      mockRehypeProcessor.mockResolvedValue({
-        html: '<h1>Title</h1><p>This is a <strong>bold</strong> paragraph...</p>',
-        processed: true,
-      });
-
-      const remarkResult = await mockRemarkProcessor(markdown);
-      const rehypeResult = await mockRehypeProcessor(remarkResult);
-
-      expect(remarkResult.processed).toBe(true);
-      expect(rehypeResult.processed).toBe(true);
-      expect(rehypeResult.html).toContain('<h1>');
-    });
-
-    it('should apply custom remark plugins', async () => {
-      const plugins = [
-        { name: 'remark-gfm', enabled: true },
-        { name: 'remark-emoji', enabled: true },
-        { name: 'remark-footnotes', enabled: true },
-      ];
-
-      mockRemarkProcessor.mockImplementation(
-        async (
-          content: string,
-          opts?: { plugins?: PluginConfig[] }
-        ): Promise<RemarkResult> => {
-          return {
-            processed: true,
-            content: content.replace(':smile:', '😊'),
-            plugins: opts?.plugins || [],
-          };
-        }
-      );
-
-      const result = await mockRemarkProcessor(':smile:', { plugins });
-
-      expect(result.content).toBe('😊');
-      expect(result.plugins).toEqual(plugins);
-    });
-
-    it('should sanitize HTML output', async () => {
-      const unsafeMarkdown = `<script>alert('XSS')</script>
-
-# Safe Content
-
-<iframe src="evil.com"></iframe>`;
-
-      mockRehypeProcessor.mockResolvedValue({
-        html: '<h1>Safe Content</h1>',
-        sanitized: true,
-        removed: ['<script>', '<iframe>'],
-      });
-
-      const result = await mockRehypeProcessor(unsafeMarkdown);
-
-      expect(result.html).not.toContain('<script>');
-      expect(result.html).not.toContain('<iframe>');
-      expect(result.sanitized).toBe(true);
-    });
-  });
-
-  describe('Syntax Highlighting', () => {
-    it('should apply syntax highlighting to code blocks', async () => {
-      const codeBlock = `\`\`\`javascript
-function fibonacci(n) {
-  if (n <= 1) return n;
-  return fibonacci(n - 1) + fibonacci(n - 2);
-}
-\`\`\``;
-
-      mockSyntaxHighlighter.mockResolvedValue({
-        html: `<pre class="language-javascript"><code class="language-javascript">
-<span class="token keyword">function</span> <span class="token function">fibonacci</span><span class="token punctuation">(</span><span class="token parameter">n</span><span class="token punctuation">)</span> <span class="token punctuation">{</span>
-  <span class="token keyword">if</span> <span class="token punctuation">(</span>n <span class="token operator"><=</span> <span class="token number">1</span><span class="token punctuation">)</span> <span class="token keyword">return</span> n<span class="token punctuation">;</span>
-  <span class="token keyword">return</span> <span class="token function">fibonacci</span><span class="token punctuation">(</span>n <span class="token operator">-</span> <span class="token number">1</span><span class="token punctuation">)</span> <span class="token operator">+</span> <span class="token function">fibonacci</span><span class="token punctuation">(</span>n <span class="token operator">-</span> <span class="token number">2</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
-<span class="token punctuation">}</span>
-</code></pre>`,
-        language: 'javascript',
-        highlighted: true,
-      });
-
-      const result = await mockSyntaxHighlighter(codeBlock);
-
-      expect(result.highlighted).toBe(true);
-      expect(result.html).toContain('token keyword');
-      expect(result.html).toContain('token function');
-      expect(result.language).toBe('javascript');
-    });
-
-    it('should support multiple languages', async () => {
-      const languages = ['javascript', 'typescript', 'python', 'rust', 'go'];
-
-      for (const lang of languages) {
-        mockSyntaxHighlighter.mockResolvedValue({
-          language: lang,
-          supported: true,
-        });
-
-        const result = await mockSyntaxHighlighter(
-          `\`\`\`${lang}\ncode\n\`\`\``
-        );
-        expect(result.supported).toBe(true);
-        expect(result.language).toBe(lang);
-      }
-    });
-
-    it('should handle unsupported languages gracefully', async () => {
-      mockSyntaxHighlighter.mockResolvedValue({
-        language: 'unknown-lang',
-        supported: false,
-        fallback: 'plaintext',
-        html: '<pre><code>code content</code></pre>',
-      });
-
-      const result = await mockSyntaxHighlighter('```unknown-lang\ncode\n```');
-
-      expect(result.supported).toBe(false);
-      expect(result.fallback).toBe('plaintext');
-      expect(result.html).toContain('<pre>');
-    });
-  });
-
-  describe('Table of Contents Generation', () => {
-    it('should generate TOC when showToc flag is true', async () => {
-      const content = `# Main Title
-
-## Section 1
-Content for section 1
-
-### Subsection 1.1
-Nested content
-
-## Section 2
-Content for section 2
-
-### Subsection 2.1
-More nested content
-
-#### Deep Section
-Very deep content`;
-
-      mockTocGenerator.mockResolvedValue({
-        toc: [
-          {
-            level: 1,
-            text: 'Main Title',
-            id: 'main-title',
-            children: [
-              {
-                level: 2,
-                text: 'Section 1',
-                id: 'section-1',
-                children: [
-                  { level: 3, text: 'Subsection 1.1', id: 'subsection-11' },
-                ],
-              },
-              {
-                level: 2,
-                text: 'Section 2',
-                id: 'section-2',
-                children: [
-                  {
-                    level: 3,
-                    text: 'Subsection 2.1',
-                    id: 'subsection-21',
-                    children: [
-                      { level: 4, text: 'Deep Section', id: 'deep-section' },
-                    ],
-                  },
-                ],
-              },
-            ],
-          },
-        ],
-        html: '<nav class="toc">...</nav>',
-      });
-
-      const result = await mockTocGenerator(content, { showToc: true });
-
-      expect(result.toc).toBeDefined();
-      expect(result.toc[0].level).toBe(1);
-      expect(result.toc[0].children).toHaveLength(2);
-    });
-
-    it('should skip TOC generation when showToc is false', async () => {
-      mockTocGenerator.mockResolvedValue({
-        toc: null,
-        skipped: true,
-        reason: 'showToc flag is false',
-      });
-
-      const result = await mockTocGenerator('# Content', { showToc: false });
-
-      expect(result.toc).toBeNull();
-      expect(result.skipped).toBe(true);
-    });
-
-    it('should limit TOC depth', async () => {
-      mockTocGenerator.mockImplementation(
-        async (content: string, opts?: TocOptions): Promise<TocResult> => {
-          const maxDepth = opts?.maxDepth || 3;
-          return {
-            toc: [
-              { level: 1, text: 'H1', id: 'h1' },
-              { level: 2, text: 'H2', id: 'h2' },
-              { level: 3, text: 'H3', id: 'h3' },
-              // H4 and beyond excluded when maxDepth is 3
-            ],
-            maxDepth,
-          };
-        }
-      );
-
-      const result = await mockTocGenerator('# H1\n## H2\n### H3\n#### H4', {
-        maxDepth: 3,
-      });
-
-      expect(result.toc).toHaveLength(3);
-      expect(result.maxDepth).toBe(3);
-    });
-  });
-
-  describe('Zod Validation', () => {
-    it('should validate frontmatter with Zod schema', async () => {
-      const frontmatter = {
-        title: 'Valid Post',
-        author: 'John Doe',
-        publishDate: '2025-01-15',
-        tags: ['blog', 'tutorial'],
-        showToc: true,
-      };
-
-      mockZodValidator.mockResolvedValue({
-        valid: true,
-        data: frontmatter,
-        errors: [],
-      });
-
-      const result = await mockZodValidator(frontmatter);
-
-      expect(result.valid).toBe(true);
-      expect(result.data).toEqual(frontmatter);
-      expect(result.errors).toHaveLength(0);
-    });
-
-    it('should report detailed validation errors', async () => {
-      const invalidFrontmatter = {
-        // Missing required fields
-        tags: 'not-an-array', // Should be array
-        showToc: 'yes', // Should be boolean
-      };
-
-      mockZodValidator.mockResolvedValue({
-        valid: false,
-        errors: [
-          { path: 'title', message: 'Required' },
-          { path: 'author', message: 'Required' },
-          { path: 'tags', message: 'Expected array, received string' },
-          { path: 'showToc', message: 'Expected boolean, received string' },
-        ],
-      });
-
-      const result = await mockZodValidator(invalidFrontmatter);
-
-      expect(result.valid).toBe(false);
-      expect(result.errors).toHaveLength(4);
-      expect(result.errors[0].path).toBe('title');
-    });
-
-    it('should coerce and transform values', async () => {
-      mockZodValidator.mockImplementation(
-        async (data: Record<string, unknown>): Promise<ValidationResult> => {
-          const transformed = {
-            ...data,
-            publishDate: new Date((data.publishDate as string) || Date.now())
-              .toISOString()
-              .split('T')[0],
-            tags: Array.isArray(data.tags) ? data.tags : [],
-            showToc: Boolean(data.showToc),
-          };
-
-          return {
-            valid: true,
-            data: transformed,
-            transformed: true,
-            errors: [],
-          };
-        }
-      );
-
-      const result = await mockZodValidator({
-        title: 'Post',
-        author: 'Author',
-        showToc: 1, // Will be coerced to true
-      });
-
-      expect(result.data.showToc).toBe(true);
-      expect(result.data.tags).toEqual([]);
-      expect(result.transformed).toBe(true);
-    });
-  });
-
-  describe('Caching and Incremental Builds', () => {
-    it('should cache processed content with hash', async () => {
-      const content = '# Cached Content';
-      const hash = 'abc123def456';
-
-      mockCacheManager.mockImplementation(
-        async (
-          key: string,
-          generator?: () => Promise<Record<string, unknown>>
-        ): Promise<CacheResult> => {
-          const cached = null; // First time, no cache
-          if (!cached && generator) {
-            const result = await generator();
-            return { ...result, cached: false, hash } as CacheResult;
-          }
-          return { cached: true } as CacheResult;
-        }
-      );
-
-      const result = await mockCacheManager(hash, async () => ({
-        html: '<h1>Cached Content</h1>',
-        processed: true,
-      }));
-
-      expect(result.cached).toBe(false);
-      expect(result.hash).toBe(hash);
-      expect(result.processed).toBe(true);
-    });
-
-    it('should return cached content on hash match', async () => {
-      const cache = new Map();
-
-      mockCacheManager.mockImplementation(
-        async (hash: string): Promise<CacheResult> => {
-          if (cache.has(hash)) {
-            return {
-              ...cache.get(hash),
-              cached: true,
-              cacheHit: true,
-            };
-          }
-
-          const processed = { html: '<h1>New</h1>' };
-          cache.set(hash, processed);
-          return { ...processed, cached: false, cacheHit: false };
-        }
-      );
-
-      // First call - cache miss
-      const result1 = await mockCacheManager('hash1');
-      expect(result1.cacheHit).toBe(false);
-
-      // Second call - cache hit
-      const result2 = await mockCacheManager('hash1');
-      expect(result2.cacheHit).toBe(true);
-    });
-
-    it('should implement incremental build strategy', async () => {
-      const files = [
-        { path: 'post1.md', modified: '2025-01-01', hash: 'hash1' },
-        { path: 'post2.md', modified: '2025-01-02', hash: 'hash2' },
-        { path: 'post3.md', modified: '2025-01-01', hash: 'hash3' },
-      ];
-
-      const lastBuild = '2025-01-01T12:00:00Z';
-
-      const needsRebuild = (file: FileInfo): boolean => {
-        return new Date(file.modified) > new Date(lastBuild);
-      };
-
-      const toRebuild = files.filter(needsRebuild);
-
-      expect(toRebuild).toHaveLength(1);
-      expect(toRebuild[0].path).toBe('post2.md');
-    });
-
-    it('should invalidate cache on dependency change', async () => {
-      const dependencies = {
-        'post1.md': ['layout.html', 'styles.css'],
-        'post2.md': ['layout.html'],
-      };
-
-      const invalidateCache = (changedFile: string) => {
-        const invalidated = [];
-        for (const [post, deps] of Object.entries(dependencies)) {
-          if (deps.includes(changedFile)) {
-            invalidated.push(post);
-          }
-        }
-        return invalidated;
-      };
-
-      const invalidated = invalidateCache('layout.html');
-
-      expect(invalidated).toContain('post1.md');
-      expect(invalidated).toContain('post2.md');
-    });
-  });
-
-  describe('Performance Optimization', () => {
-    it('should process content within performance budget', async () => {
-      const startTime = Date.now();
-
-      // Simulate processing
-      await new Promise((resolve) => setTimeout(resolve, 50));
-
-      const processingTime = Date.now() - startTime;
-
-      expect(processingTime).toBeLessThan(100); // 100ms budget
-    });
-
-    it('should batch process multiple files efficiently', async () => {
-      const files = Array.from({ length: 10 }, (_, i) => ({
-        id: `post-${i}`,
-        content: `# Post ${i}`,
-      }));
-
-      const batchProcess = async (
-        items: PostInfo[]
-      ): Promise<(PostInfo & { processed: boolean })[]> => {
-        const results = await Promise.all(
-          items.map(async (item: PostInfo) => ({
-            ...item,
-            processed: true,
-          }))
-        );
-        return results;
-      };
-
-      const startTime = Date.now();
-      const results = await batchProcess(files);
-      const totalTime = Date.now() - startTime;
-
-      expect(results).toHaveLength(10);
-      expect(totalTime).toBeLessThan(500); // Should be fast with parallel processing
-    });
-
-    it('should implement memoization for expensive operations', async () => {
-      const memo = new Map();
-      let callCount = 0;
-
-      const expensiveOperation = async (input: string) => {
-        callCount++;
-        if (memo.has(input)) {
-          return memo.get(input);
-        }
-
-        // Simulate expensive operation
-        await new Promise((resolve) => setTimeout(resolve, 100));
-        const result = `processed-${input}`;
-        memo.set(input, result);
-        return result;
-      };
-
-      // First call - expensive
-      await expensiveOperation('test');
-      expect(callCount).toBe(1);
-
-      // Second call - may or may not be memoized depending on implementation
-      await expensiveOperation('test');
-      expect(callCount).toBeLessThanOrEqual(2); // Could be 1 (memoized) or 2
-    });
-  });
-
-  describe('Error Handling and Recovery', () => {
-    it('should handle processing errors gracefully', async () => {
-      mockRemarkProcessor.mockRejectedValue(
-        new Error('Invalid markdown syntax')
-      );
-
-      const processWithErrorHandling = async (content: string) => {
-        try {
-          return await mockRemarkProcessor(content);
-        } catch (error: unknown) {
-          return {
-            processed: false,
-            error: error instanceof Error ? error.message : 'Unknown error',
-            fallback: content, // Return original content as fallback
-          };
-        }
-      };
-
-      const result = await processWithErrorHandling('Invalid {{');
-
-      expect(result.processed).toBe(false);
-      expect(result.error).toBe('Invalid markdown syntax');
-      expect(result.fallback).toBe('Invalid {{');
-    });
-
-    it('should continue processing on partial failures', async () => {
-      const posts = ['post1', 'post2-fail', 'post3'];
-      const results = [];
-
-      for (const post of posts) {
-        try {
-          if (post.includes('fail')) {
-            throw new Error(`Failed to process ${post}`);
-          }
-          results.push({ post, success: true });
-        } catch (error: unknown) {
-          results.push({
-            post,
-            success: false,
-            error: error instanceof Error ? error.message : 'Unknown error',
-          });
-        }
-      }
-
-      expect(results.filter((r) => r.success).length).toBe(2);
-      expect(results.filter((r) => !r.success).length).toBe(1);
-    });
-  });
-});