fix: Correct inlet/outlet types for all stages and add comprehensive tests

Fixes and improvements:

1. Corrected Stage Type Declarations
   - DataSourceStage: NONE inlet, SOURCE_ITEMS outlet (was incorrectly set to TEXT_BUFFER)
   - CameraStage: TEXT_BUFFER inlet/outlet (post-render transformation, was SOURCE_ITEMS)
   - All other stages correctly declare their inlet/outlet types
   - ImageToTextStage: Removed unused ImageItem import

2. Test Suite Organization
   - Moved TestInletOutletTypeValidation class to proper location
   - Added pytest and DataType/StageError imports to test file header
   - Removed duplicate imports
   - All 5 type validation tests passing

3. Type Validation Coverage
   - Type mismatch detection raises StageError at build time
   - Compatible types pass validation
   - DataType.ANY accepts everything
   - Multiple inlet types supported
   - Display stage restrictions enforced

All data flows now properly validated:
- Source (SOURCE_ITEMS) → Render (TEXT_BUFFER) → Effects/Camera (TEXT_BUFFER) → Display

Tests: 507 tests passing

tests/test_pipeline.py

@@ -4,6 +4,8 @@ Tests for the new unified pipeline architecture.
 
 from unittest.mock import MagicMock
 
+import pytest
+
 from engine.pipeline import (
     Pipeline,
     PipelineConfig,
@@ -13,6 +15,7 @@ from engine.pipeline import (
     create_default_pipeline,
     discover_stages,
 )
+from engine.pipeline.core import DataType, StageError
 
 
 class TestStageRegistry:
@@ -1066,3 +1069,214 @@ class TestOverlayStages:
         pipeline.build()
 
         assert pipeline.get_render_order("test") == 42
+
+
+class TestInletOutletTypeValidation:
+    """Test type validation between connected stages."""
+
+    def test_type_mismatch_raises_error(self):
+        """Type mismatch between stages raises StageError."""
+
+        class ProducerStage(Stage):
+            name = "producer"
+            category = "test"
+
+            @property
+            def inlet_types(self):
+                return {DataType.NONE}
+
+            @property
+            def outlet_types(self):
+                return {DataType.SOURCE_ITEMS}
+
+            def process(self, data, ctx):
+                return data
+
+        class ConsumerStage(Stage):
+            name = "consumer"
+            category = "test"
+
+            @property
+            def dependencies(self):
+                return {"test.producer"}
+
+            @property
+            def inlet_types(self):
+                return {DataType.TEXT_BUFFER}  # Incompatible!
+
+            @property
+            def outlet_types(self):
+                return {DataType.TEXT_BUFFER}
+
+            def process(self, data, ctx):
+                return data
+
+        pipeline = Pipeline()
+        pipeline.add_stage("producer", ProducerStage())
+        pipeline.add_stage("consumer", ConsumerStage())
+
+        with pytest.raises(StageError) as exc_info:
+            pipeline.build()
+
+        assert "Type mismatch" in str(exc_info.value)
+        assert "TEXT_BUFFER" in str(exc_info.value)
+        assert "SOURCE_ITEMS" in str(exc_info.value)
+
+    def test_compatible_types_pass_validation(self):
+        """Compatible types pass validation."""
+
+        class ProducerStage(Stage):
+            name = "producer"
+            category = "test"
+
+            @property
+            def inlet_types(self):
+                return {DataType.NONE}
+
+            @property
+            def outlet_types(self):
+                return {DataType.SOURCE_ITEMS}
+
+            def process(self, data, ctx):
+                return data
+
+        class ConsumerStage(Stage):
+            name = "consumer"
+            category = "test"
+
+            @property
+            def dependencies(self):
+                return {"test.producer"}
+
+            @property
+            def inlet_types(self):
+                return {DataType.SOURCE_ITEMS}  # Compatible!
+
+            @property
+            def outlet_types(self):
+                return {DataType.TEXT_BUFFER}
+
+            def process(self, data, ctx):
+                return data
+
+        pipeline = Pipeline()
+        pipeline.add_stage("producer", ProducerStage())
+        pipeline.add_stage("consumer", ConsumerStage())
+
+        # Should not raise
+        pipeline.build()
+
+    def test_any_type_accepts_everything(self):
+        """DataType.ANY accepts any upstream type."""
+
+        class ProducerStage(Stage):
+            name = "producer"
+            category = "test"
+
+            @property
+            def inlet_types(self):
+                return {DataType.NONE}
+
+            @property
+            def outlet_types(self):
+                return {DataType.SOURCE_ITEMS}
+
+            def process(self, data, ctx):
+                return data
+
+        class ConsumerStage(Stage):
+            name = "consumer"
+            category = "test"
+
+            @property
+            def dependencies(self):
+                return {"test.producer"}
+
+            @property
+            def inlet_types(self):
+                return {DataType.ANY}  # Accepts anything
+
+            @property
+            def outlet_types(self):
+                return {DataType.TEXT_BUFFER}
+
+            def process(self, data, ctx):
+                return data
+
+        pipeline = Pipeline()
+        pipeline.add_stage("producer", ProducerStage())
+        pipeline.add_stage("consumer", ConsumerStage())
+
+        # Should not raise because consumer accepts ANY
+        pipeline.build()
+
+    def test_multiple_compatible_types(self):
+        """Stage can declare multiple inlet types."""
+
+        class ProducerStage(Stage):
+            name = "producer"
+            category = "test"
+
+            @property
+            def inlet_types(self):
+                return {DataType.NONE}
+
+            @property
+            def outlet_types(self):
+                return {DataType.SOURCE_ITEMS}
+
+            def process(self, data, ctx):
+                return data
+
+        class ConsumerStage(Stage):
+            name = "consumer"
+            category = "test"
+
+            @property
+            def dependencies(self):
+                return {"test.producer"}
+
+            @property
+            def inlet_types(self):
+                return {DataType.SOURCE_ITEMS, DataType.TEXT_BUFFER}
+
+            @property
+            def outlet_types(self):
+                return {DataType.TEXT_BUFFER}
+
+            def process(self, data, ctx):
+                return data
+
+        pipeline = Pipeline()
+        pipeline.add_stage("producer", ProducerStage())
+        pipeline.add_stage("consumer", ConsumerStage())
+
+        # Should not raise because consumer accepts SOURCE_ITEMS
+        pipeline.build()
+
+    def test_display_must_accept_text_buffer(self):
+        """Display stages must accept TEXT_BUFFER type."""
+
+        class BadDisplayStage(Stage):
+            name = "display"
+            category = "display"
+
+            @property
+            def inlet_types(self):
+                return {DataType.SOURCE_ITEMS}  # Wrong type for display!
+
+            @property
+            def outlet_types(self):
+                return {DataType.NONE}
+
+            def process(self, data, ctx):
+                return data
+
+        pipeline = Pipeline()
+        pipeline.add_stage("display", BadDisplayStage())
+
+        with pytest.raises(StageError) as exc_info:
+            pipeline.build()
+
+        assert "display" in str(exc_info.value).lower()
+        assert "TEXT_BUFFER" in str(exc_info.value)