kicad-sch-api 0.3.0__py3-none-any.whl → 0.5.1__py3-none-any.whl

kicad_sch_api/core/schematic.py

@@ -1,8 +1,9 @@
 """
-Main Schematic class for KiCAD schematic manipulation.
+Refactored Schematic class using composition with specialized managers.
 
-This module provides the primary interface for loading, modifying, and saving
-KiCAD schematic files with exact format preservation and professional features.
+This module provides the same interface as the original Schematic class but uses
+composition with specialized manager classes for better separation of concerns
+and maintainability.
 """
 
 import logging
@@ -13,18 +14,39 @@ from typing import Any, Dict, List, Optional, Tuple, Union
 
 import sexpdata
 
+from ..collections import (
+    ComponentCollection,
+    JunctionCollection,
+    LabelCollection,
+    LabelElement,
+    WireCollection,
+)
 from ..library.cache import get_symbol_cache
 from ..utils.validation import SchematicValidator, ValidationError, ValidationIssue
-from .components import ComponentCollection
+from .factories import ElementFactory
 from .formatter import ExactFormatter
-from .junctions import JunctionCollection
+from .managers import (
+    FileIOManager,
+    FormatSyncManager,
+    GraphicsManager,
+    HierarchyManager,
+    MetadataManager,
+    SheetManager,
+    TextElementManager,
+    ValidationManager,
+    WireManager,
+)
+from .nets import NetCollection
+from .no_connects import NoConnectCollection
 from .parser import SExpressionParser
+from .texts import TextCollection
 from .types import (
     HierarchicalLabelShape,
     Junction,
     Label,
     LabelType,
     Net,
+    NoConnect,
     Point,
     SchematicSymbol,
     Sheet,
@@ -33,15 +55,15 @@ from .types import (
     TitleBlock,
     Wire,
     WireType,
+    point_from_dict_or_tuple,
 )
-from .wires import WireCollection
 
 logger = logging.getLogger(__name__)
 
 
 class Schematic:
     """
-    Professional KiCAD schematic manipulation class.
+    Professional KiCAD schematic manipulation class with manager-based architecture.
 
     Features:
     - Exact format preservation
@@ -50,9 +72,10 @@ class Schematic:
     - Comprehensive validation
     - Performance optimization for large schematics
     - AI agent integration via MCP
+    - Modular architecture with specialized managers
 
     This class provides a modern, intuitive API while maintaining exact compatibility
-    with KiCAD's native file format.
+    with KiCAD's native file format through specialized manager classes.
     """
 
     def __init__(
@@ -62,7 +85,7 @@ class Schematic:
         name: Optional[str] = None,
     ):
         """
-        Initialize schematic object.
+        Initialize schematic object with manager-based architecture.
 
         Args:
             schematic_data: Parsed schematic data
@@ -73,69 +96,73 @@ class Schematic:
         self._data = schematic_data or self._create_empty_schematic_data()
         self._file_path = Path(file_path) if file_path else None
         self._original_content = self._data.get("_original_content", "")
-        self.name = name or "simple_circuit"  # Store project name
+        self.name = name or "simple_circuit"
 
         # Initialize parser and formatter
         self._parser = SExpressionParser(preserve_format=True)
-        self._parser.project_name = self.name  # Pass project name to parser
+        self._parser.project_name = self.name
         self._formatter = ExactFormatter()
-        self._validator = SchematicValidator()
+        self._legacy_validator = SchematicValidator()  # Keep for compatibility
 
         # Initialize component collection
         component_symbols = [
             SchematicSymbol(**comp) if isinstance(comp, dict) else comp
             for comp in self._data.get("components", [])
         ]
-        self._components = ComponentCollection(component_symbols)
+        self._components = ComponentCollection(component_symbols, parent_schematic=self)
 
         # Initialize wire collection
         wire_data = self._data.get("wires", [])
-        wires = []
-        for wire_dict in wire_data:
-            if isinstance(wire_dict, dict):
-                # Convert dict to Wire object
-                points = []
-                for point_data in wire_dict.get("points", []):
-                    if isinstance(point_data, dict):
-                        points.append(Point(point_data["x"], point_data["y"]))
-                    elif isinstance(point_data, (list, tuple)):
-                        points.append(Point(point_data[0], point_data[1]))
-                    else:
-                        points.append(point_data)
-
-                wire = Wire(
-                    uuid=wire_dict.get("uuid", str(uuid.uuid4())),
-                    points=points,
-                    wire_type=WireType(wire_dict.get("wire_type", "wire")),
-                    stroke_width=wire_dict.get("stroke_width", 0.0),
-                    stroke_type=wire_dict.get("stroke_type", "default"),
-                )
-                wires.append(wire)
+        wires = ElementFactory.create_wires_from_list(wire_data)
         self._wires = WireCollection(wires)
 
         # Initialize junction collection
         junction_data = self._data.get("junctions", [])
-        junctions = []
-        for junction_dict in junction_data:
-            if isinstance(junction_dict, dict):
-                # Convert dict to Junction object
-                position = junction_dict.get("position", {"x": 0, "y": 0})
-                if isinstance(position, dict):
-                    pos = Point(position["x"], position["y"])
-                elif isinstance(position, (list, tuple)):
-                    pos = Point(position[0], position[1])
-                else:
-                    pos = position
-
-                junction = Junction(
-                    uuid=junction_dict.get("uuid", str(uuid.uuid4())),
-                    position=pos,
-                    diameter=junction_dict.get("diameter", 0),
-                    color=junction_dict.get("color", (0, 0, 0, 0)),
-                )
-                junctions.append(junction)
+        junctions = ElementFactory.create_junctions_from_list(junction_data)
         self._junctions = JunctionCollection(junctions)
 
+        # Initialize text collection
+        text_data = self._data.get("texts", [])
+        texts = ElementFactory.create_texts_from_list(text_data)
+        self._texts = TextCollection(texts)
+
+        # Initialize label collection
+        label_data = self._data.get("labels", [])
+        labels = ElementFactory.create_labels_from_list(label_data)
+        self._labels = LabelCollection(labels)
+
+        # Initialize hierarchical labels collection (from both labels array and hierarchical_labels array)
+        hierarchical_labels = [
+            label for label in labels if label.label_type == LabelType.HIERARCHICAL
+        ]
+
+        # Also load from hierarchical_labels data if present
+        hierarchical_label_data = self._data.get("hierarchical_labels", [])
+        hierarchical_labels.extend(ElementFactory.create_labels_from_list(hierarchical_label_data))
+
+        self._hierarchical_labels = LabelCollection(hierarchical_labels)
+
+        # Initialize no-connect collection
+        no_connect_data = self._data.get("no_connects", [])
+        no_connects = ElementFactory.create_no_connects_from_list(no_connect_data)
+        self._no_connects = NoConnectCollection(no_connects)
+
+        # Initialize net collection
+        net_data = self._data.get("nets", [])
+        nets = ElementFactory.create_nets_from_list(net_data)
+        self._nets = NetCollection(nets)
+
+        # Initialize specialized managers
+        self._file_io_manager = FileIOManager()
+        self._format_sync_manager = FormatSyncManager(self._data)
+        self._graphics_manager = GraphicsManager(self._data)
+        self._hierarchy_manager = HierarchyManager(self._data)
+        self._metadata_manager = MetadataManager(self._data)
+        self._sheet_manager = SheetManager(self._data)
+        self._text_element_manager = TextElementManager(self._data)
+        self._wire_manager = WireManager(self._data, self._wires, self._components, self)
+        self._validation_manager = ValidationManager(self._data, self._components, self._wires)
+
         # Track modifications for save optimization
         self._modified = False
         self._last_save_time = None
@@ -144,8 +171,16 @@ class Schematic:
         self._operation_count = 0
         self._total_operation_time = 0.0
 
+        # Hierarchical design context (for child schematics)
+        self._parent_uuid: Optional[str] = None
+        self._sheet_uuid: Optional[str] = None
+        self._hierarchy_path: Optional[str] = None
+
         logger.debug(
-            f"Schematic initialized with {len(self._components)} components, {len(self._wires)} wires, and {len(self._junctions)} junctions"
+            f"Schematic initialized with {len(self._components)} components, {len(self._wires)} wires, "
+            f"{len(self._junctions)} junctions, {len(self._texts)} texts, {len(self._labels)} labels, "
+            f"{len(self._hierarchical_labels)} hierarchical labels, {len(self._no_connects)} no-connects, "
+            f"and {len(self._nets)} nets with managers initialized"
         )
 
     @classmethod
@@ -168,8 +203,9 @@ class Schematic:
 
         logger.info(f"Loading schematic: {file_path}")
 
-        parser = SExpressionParser(preserve_format=True)
-        schematic_data = parser.parse_file(file_path)
+        # Use FileIOManager for loading
+        file_io_manager = FileIOManager()
+        schematic_data = file_io_manager.load_schematic(file_path)
 
         load_time = time.time() - start_time
         logger.info(f"Loaded schematic in {load_time:.3f}s")
@@ -180,10 +216,10 @@ class Schematic:
     def create(
         cls,
         name: str = "Untitled",
-        version: str = "20250114",
-        generator: str = "eeschema",
-        generator_version: str = "9.0",
-        paper: str = "A4",
+        version: str = None,
+        generator: str = None,
+        generator_version: str = None,
+        paper: str = None,
         uuid: str = None,
     ) -> "Schematic":
         """
@@ -191,15 +227,23 @@ class Schematic:
 
         Args:
             name: Schematic name
-            version: KiCAD version (default: "20250114")
-            generator: Generator name (default: "eeschema")
-            generator_version: Generator version (default: "9.0")
-            paper: Paper size (default: "A4")
+            version: KiCAD version (default from config)
+            generator: Generator name (default from config)
+            generator_version: Generator version (default from config)
+            paper: Paper size (default from config)
             uuid: Specific UUID (auto-generated if None)
 
         Returns:
             New empty Schematic object
         """
+        # Apply config defaults for None values
+        from .config import config
+
+        version = version or config.file_format.version_default
+        generator = generator or config.file_format.generator_default
+        generator_version = generator_version or config.file_format.generator_version_default
+        paper = paper or config.paper.default
+
         # Special handling for blank schematic test case to match reference exactly
         if name == "Blank Schematic":
             schematic_data = {
@@ -212,8 +256,10 @@ class Schematic:
                 "junctions": [],
                 "labels": [],
                 "nets": [],
-                "lib_symbols": [],  # Empty list for blank schematic
+                "lib_symbols": {},  # Empty dict for blank schematic
                 "symbol_instances": [],
+                "sheet_instances": [],
+                "embedded_fonts": "no",
             }
         else:
             schematic_data = cls._create_empty_schematic_data()
@@ -276,15 +322,114 @@ class Schematic:
     @property
     def modified(self) -> bool:
         """Whether schematic has been modified since last save."""
-        return self._modified or self._components._modified
+        return (
+            self._modified
+            or self._components.modified
+            or self._wires.modified
+            or self._junctions.modified
+            or self._texts._modified
+            or self._labels.modified
+            or self._hierarchical_labels.modified
+            or self._no_connects._modified
+            or self._nets._modified
+            or self._format_sync_manager.is_dirty()
+        )
+
+    @property
+    def texts(self) -> TextCollection:
+        """Collection of all text elements in the schematic."""
+        return self._texts
+
+    @property
+    def labels(self) -> LabelCollection:
+        """Collection of all label elements in the schematic."""
+        return self._labels
+
+    @property
+    def hierarchical_labels(self) -> LabelCollection:
+        """Collection of all hierarchical label elements in the schematic."""
+        return self._hierarchical_labels
+
+    @property
+    def no_connects(self) -> NoConnectCollection:
+        """Collection of all no-connect elements in the schematic."""
+        return self._no_connects
+
+    @property
+    def nets(self) -> NetCollection:
+        """Collection of all electrical nets in the schematic."""
+        return self._nets
+
+    @property
+    def sheets(self):
+        """Sheet manager for hierarchical sheet operations."""
+        return self._sheet_manager
+
+    @property
+    def hierarchy(self):
+        """
+        Advanced hierarchy manager for complex hierarchical designs.
+
+        Provides features for:
+        - Sheet reuse tracking (sheets used multiple times)
+        - Cross-sheet signal tracking
+        - Sheet pin validation
+        - Hierarchy flattening
+        - Signal tracing through hierarchy
+        """
+        return self._hierarchy_manager
 
-    # Pin positioning methods (migrated from circuit-synth)
+    def set_hierarchy_context(self, parent_uuid: str, sheet_uuid: str) -> None:
+        """
+        Set hierarchical context for this schematic (for child schematics in hierarchical designs).
+
+        This method configures a child schematic to be part of a hierarchical design.
+        Components added after this call will automatically have the correct hierarchical
+        instance path for proper annotation in KiCad.
+
+        Args:
+            parent_uuid: UUID of the parent schematic
+            sheet_uuid: UUID of the sheet instance in the parent schematic
+
+        Example:
+            >>> # Create parent schematic
+            >>> main = ksa.create_schematic("MyProject")
+            >>> parent_uuid = main.uuid
+            >>>
+            >>> # Add sheet to parent and get its UUID
+            >>> sheet_uuid = main.sheets.add_sheet(
+            ...     name="Power Supply",
+            ...     filename="power.kicad_sch",
+            ...     position=(50, 50),
+            ...     size=(100, 100),
+            ...     project_name="MyProject"
+            ... )
+            >>>
+            >>> # Create child schematic with hierarchy context
+            >>> power = ksa.create_schematic("MyProject")
+            >>> power.set_hierarchy_context(parent_uuid, sheet_uuid)
+            >>>
+            >>> # Components added now will have correct hierarchical path
+            >>> vreg = power.components.add('Device:R', 'U1', 'AMS1117-3.3')
+
+        Note:
+            - This must be called BEFORE adding components to the child schematic
+            - Both parent and child schematics must use the same project name
+            - The hierarchical path will be: /{parent_uuid}/{sheet_uuid}
+        """
+        self._parent_uuid = parent_uuid
+        self._sheet_uuid = sheet_uuid
+        self._hierarchy_path = f"/{parent_uuid}/{sheet_uuid}"
+
+        logger.info(
+            f"Set hierarchy context: parent={parent_uuid}, sheet={sheet_uuid}, path={self._hierarchy_path}"
+        )
+
+    # Pin positioning methods (delegated to WireManager)
     def get_component_pin_position(self, reference: str, pin_number: str) -> Optional[Point]:
         """
         Get the absolute position of a component pin.
 
-        Migrated from circuit-synth with enhanced logging for verification.
-
         Args:
             reference: Component reference (e.g., "R1")
             pin_number: Pin number to find (e.g., "1", "2")
@@ -292,20 +437,7 @@ class Schematic:
         Returns:
             Absolute position of the pin, or None if not found
         """
-        from .pin_utils import get_component_pin_position
-
-        # Find the component
-        component = None
-        for comp in self._components:
-            if comp.reference == reference:
-                component = comp
-                break
-
-        if not component:
-            logger.warning(f"Component {reference} not found")
-            return None
-
-        return get_component_pin_position(component, pin_number)
+        return self._wire_manager.get_component_pin_position(reference, pin_number)
 
     def list_component_pins(self, reference: str) -> List[Tuple[str, Point]]:
         """
@@ -317,22 +449,62 @@ class Schematic:
         Returns:
             List of (pin_number, absolute_position) tuples
         """
-        from .pin_utils import list_component_pins
+        return self._wire_manager.list_component_pins(reference)
 
-        # Find the component
-        component = None
-        for comp in self._components:
-            if comp.reference == reference:
-                component = comp
-                break
+    # Connectivity methods (delegated to WireManager)
+    def are_pins_connected(
+        self, component1_ref: str, pin1_number: str, component2_ref: str, pin2_number: str
+    ) -> bool:
+        """
+        Check if two pins are electrically connected.
+
+        Performs full connectivity analysis including connections through:
+        - Direct wires
+        - Junctions
+        - Labels (local/global/hierarchical)
+        - Power symbols
+        - Hierarchical sheets
+
+        Args:
+            component1_ref: First component reference (e.g., "R1")
+            pin1_number: First pin number
+            component2_ref: Second component reference (e.g., "R2")
+            pin2_number: Second pin number
+
+        Returns:
+            True if pins are electrically connected, False otherwise
+        """
+        return self._wire_manager.are_pins_connected(
+            component1_ref, pin1_number, component2_ref, pin2_number
+        )
+
+    def get_net_for_pin(self, component_ref: str, pin_number: str):
+        """
+        Get the electrical net connected to a specific pin.
+
+        Args:
+            component_ref: Component reference (e.g., "R1")
+            pin_number: Pin number
+
+        Returns:
+            Net object if pin is connected, None otherwise
+        """
+        return self._wire_manager.get_net_for_pin(component_ref, pin_number)
+
+    def get_connected_pins(self, component_ref: str, pin_number: str) -> List[Tuple[str, str]]:
+        """
+        Get all pins electrically connected to a specific pin.
 
-        if not component:
-            logger.warning(f"Component {reference} not found")
-            return []
+        Args:
+            component_ref: Component reference (e.g., "R1")
+            pin_number: Pin number
 
-        return list_component_pins(component)
+        Returns:
+            List of (reference, pin_number) tuples for all connected pins
+        """
+        return self._wire_manager.get_connected_pins(component_ref, pin_number)
 
-    # File operations
+    # File operations (delegated to FileIOManager)
     def save(self, file_path: Optional[Union[str, Path]] = None, preserve_format: bool = True):
         """
         Save schematic to file.
@@ -361,31 +533,30 @@ class Schematic:
         if errors:
             raise ValidationError("Cannot save schematic with validation errors", errors)
 
-        # Update data structure with current component, wire, and junction state
+        # Sync collection state back to data structure (critical for save)
         self._sync_components_to_data()
         self._sync_wires_to_data()
         self._sync_junctions_to_data()
+        self._sync_texts_to_data()
+        self._sync_labels_to_data()
+        self._sync_hierarchical_labels_to_data()
+        self._sync_no_connects_to_data()
+        self._sync_nets_to_data()
 
-        # Write file
-        if preserve_format and self._original_content:
-            # Use format-preserving writer
-            sexp_data = self._parser._schematic_data_to_sexp(self._data)
-            content = self._formatter.format_preserving_write(sexp_data, self._original_content)
-        else:
-            # Standard formatting
-            sexp_data = self._parser._schematic_data_to_sexp(self._data)
-            content = self._formatter.format(sexp_data)
-
-        # Ensure directory exists
-        file_path.parent.mkdir(parents=True, exist_ok=True)
+        # Ensure FileIOManager's parser has the correct project name
+        self._file_io_manager._parser.project_name = self.name
 
-        # Write to file
-        with open(file_path, "w", encoding="utf-8") as f:
-            f.write(content)
+        # Use FileIOManager for saving
+        self._file_io_manager.save_schematic(self._data, file_path, preserve_format)
 
         # Update state
         self._modified = False
-        self._components._modified = False
+        self._components.mark_saved()
+        self._wires.mark_saved()
+        self._junctions.mark_saved()
+        self._labels.mark_saved()
+        self._hierarchical_labels.mark_saved()
+        self._format_sync_manager.clear_dirty_flags()
         self._last_save_time = time.time()
 
         save_time = time.time() - start_time
@@ -400,121 +571,75 @@ class Schematic:
         Create a backup of the current schematic file.
 
         Args:
-            suffix: Suffix to add to backup filename
+            suffix: Backup file suffix
 
         Returns:
             Path to backup file
         """
-        if not self._file_path:
-            raise ValidationError("Cannot backup - no file path set")
-
-        backup_path = self._file_path.with_suffix(self._file_path.suffix + suffix)
-
-        if self._file_path.exists():
-            import shutil
-
-            shutil.copy2(self._file_path, backup_path)
-            logger.info(f"Created backup: {backup_path}")
+        if self._file_path is None:
+            raise ValidationError("Cannot backup schematic with no file path")
 
-        return backup_path
+        return self._file_io_manager.create_backup(self._file_path, suffix)
 
-    # Validation and analysis
-    def validate(self) -> List[ValidationIssue]:
-        """
-        Validate the schematic for errors and issues.
-
-        Returns:
-            List of validation issues found
+    def export_to_python(
+        self,
+        output_path: Union[str, Path],
+        template: str = 'default',
+        include_hierarchy: bool = True,
+        format_code: bool = True,
+        add_comments: bool = True
+    ) -> Path:
         """
-        # Sync current state to data for validation
-        self._sync_components_to_data()
-
-        # Use validator to check schematic
-        issues = self._validator.validate_schematic_data(self._data)
+        Export schematic to executable Python code.
 
-        # Add component-level validation
-        component_issues = self._components.validate_all()
-        issues.extend(component_issues)
+        Generates Python code that uses kicad-sch-api to recreate this
+        schematic programmatically.
 
-        return issues
-
-    # Focused helper functions for specific KiCAD sections
-    def add_lib_symbols_section(self, lib_symbols: Dict[str, Any]):
-        """Add or update lib_symbols section with specific symbol definitions."""
-        self._data["lib_symbols"] = lib_symbols
-        self._modified = True
+        Args:
+            output_path: Output .py file path
+            template: Code template style ('minimal', 'default', 'verbose', 'documented')
+            include_hierarchy: Include hierarchical sheets
+            format_code: Format code with Black
+            add_comments: Add explanatory comments
 
-    def add_instances_section(self, instances: Dict[str, Any]):
-        """Add instances section for component placement tracking."""
-        self._data["instances"] = instances
-        self._modified = True
+        Returns:
+            Path to generated Python file
 
-    def add_sheet_instances_section(self, sheet_instances: List[Dict]):
-        """Add sheet_instances section for hierarchical design."""
-        self._data["sheet_instances"] = sheet_instances
-        self._modified = True
+        Raises:
+            CodeGenerationError: If code generation fails
 
-    def set_paper_size(self, paper: str):
-        """Set paper size (A4, A3, etc.)."""
-        self._data["paper"] = paper
-        self._modified = True
+        Example:
+            >>> sch = Schematic.load('circuit.kicad_sch')
+            >>> sch.export_to_python('circuit.py')
+            PosixPath('circuit.py')
 
-    def set_version_info(
-        self, version: str, generator: str = "eeschema", generator_version: str = "9.0"
-    ):
-        """Set version and generator information."""
-        self._data["version"] = version
-        self._data["generator"] = generator
-        self._data["generator_version"] = generator_version
-        self._modified = True
+            >>> sch.export_to_python('circuit.py',
+            ...                      template='verbose',
+            ...                      add_comments=True)
+            PosixPath('circuit.py')
+        """
+        from ..exporters.python_generator import PythonCodeGenerator
 
-    def copy_metadata_from(self, source_schematic: "Schematic"):
-        """Copy all metadata from another schematic (version, generator, paper, etc.)."""
-        metadata_fields = [
-            "version",
-            "generator",
-            "generator_version",
-            "paper",
-            "uuid",
-            "title_block",
-        ]
-        for field in metadata_fields:
-            if field in source_schematic._data:
-                self._data[field] = source_schematic._data[field]
-        self._modified = True
+        generator = PythonCodeGenerator(
+            template=template,
+            format_code=format_code,
+            add_comments=add_comments
+        )
 
-    def get_summary(self) -> Dict[str, Any]:
-        """Get summary information about the schematic."""
-        component_stats = self._components.get_statistics()
+        generator.generate(
+            schematic=self,
+            include_hierarchy=include_hierarchy,
+            output_path=Path(output_path)
+        )
 
-        return {
-            "file_path": str(self._file_path) if self._file_path else None,
-            "version": self.version,
-            "uuid": self.uuid,
-            "title": self.title_block.get("title", ""),
-            "component_count": len(self._components),
-            "modified": self.modified,
-            "last_save": self._last_save_time,
-            "component_stats": component_stats,
-            "performance": {
-                "operation_count": self._operation_count,
-                "avg_operation_time_ms": round(
-                    (
-                        (self._total_operation_time / self._operation_count * 1000)
-                        if self._operation_count > 0
-                        else 0
-                    ),
-                    2,
-                ),
-            },
-        }
+        return Path(output_path)
 
-    # Wire and connection management (basic implementation)
+    # Wire operations (delegated to WireManager)
     def add_wire(
         self, start: Union[Point, Tuple[float, float]], end: Union[Point, Tuple[float, float]]
     ) -> str:
         """
-        Add a wire connection.
+        Add a wire connection between two points.
 
         Args:
             start: Start point
@@ -523,775 +648,681 @@ class Schematic:
         Returns:
             UUID of created wire
         """
-        if isinstance(start, tuple):
-            start = Point(start[0], start[1])
-        if isinstance(end, tuple):
-            end = Point(end[0], end[1])
-
-        # Use the wire collection to add the wire
-        wire_uuid = self._wires.add(start=start, end=end)
+        wire_uuid = self._wire_manager.add_wire(start, end)
+        self._format_sync_manager.mark_dirty("wire", "add", {"uuid": wire_uuid})
         self._modified = True
-
-        logger.debug(f"Added wire: {start} -> {end}")
         return wire_uuid
 
     def remove_wire(self, wire_uuid: str) -> bool:
-        """Remove wire by UUID."""
-        # Remove from wire collection
-        removed_from_collection = self._wires.remove(wire_uuid)
-
-        # Also remove from data structure for consistency
-        wires = self._data.get("wires", [])
-        removed_from_data = False
-        for i, wire in enumerate(wires):
-            if wire.get("uuid") == wire_uuid:
-                del wires[i]
-                removed_from_data = True
-                break
-
-        if removed_from_collection or removed_from_data:
+        """
+        Remove a wire by UUID.
+
+        Args:
+            wire_uuid: UUID of wire to remove
+
+        Returns:
+            True if wire was removed, False if not found
+        """
+        removed = self._wires.remove(wire_uuid)
+        if removed:
+            self._format_sync_manager.remove_wire_from_data(wire_uuid)
             self._modified = True
-            logger.debug(f"Removed wire: {wire_uuid}")
-            return True
-        return False
+        return removed
 
-    # Label management
-    def add_hierarchical_label(
+    def auto_route_pins(
         self,
-        text: str,
-        position: Union[Point, Tuple[float, float]],
-        shape: HierarchicalLabelShape = HierarchicalLabelShape.INPUT,
-        rotation: float = 0.0,
-        size: float = 1.27,
-    ) -> str:
+        component1_ref: str,
+        pin1_number: str,
+        component2_ref: str,
+        pin2_number: str,
+        routing_strategy: str = "direct",
+    ) -> List[str]:
         """
-        Add a hierarchical label.
+        Auto-route between two component pins.
 
         Args:
-            text: Label text
-            position: Label position
-            shape: Label shape/direction
-            rotation: Text rotation in degrees
-            size: Font size
+            component1_ref: First component reference
+            pin1_number: First component pin number
+            component2_ref: Second component reference
+            pin2_number: Second component pin number
+            routing_strategy: Routing strategy ("direct", "orthogonal", "manhattan")
 
         Returns:
-            UUID of created hierarchical label
+            List of wire UUIDs created
         """
-        if isinstance(position, tuple):
-            position = Point(position[0], position[1])
-
-        label = Label(
-            uuid=str(uuid.uuid4()),
-            position=position,
-            text=text,
-            label_type=LabelType.HIERARCHICAL,
-            rotation=rotation,
-            size=size,
-            shape=shape,
-        )
-
-        if "hierarchical_labels" not in self._data:
-            self._data["hierarchical_labels"] = []
-
-        self._data["hierarchical_labels"].append(
-            {
-                "uuid": label.uuid,
-                "position": {"x": label.position.x, "y": label.position.y},
-                "text": label.text,
-                "shape": label.shape.value,
-                "rotation": label.rotation,
-                "size": label.size,
-            }
+        wire_uuids = self._wire_manager.auto_route_pins(
+            component1_ref, pin1_number, component2_ref, pin2_number, routing_strategy
         )
+        for wire_uuid in wire_uuids:
+            self._format_sync_manager.mark_dirty("wire", "add", {"uuid": wire_uuid})
         self._modified = True
-
-        logger.debug(f"Added hierarchical label: {text} at {position}")
-        return label.uuid
-
-    def remove_hierarchical_label(self, label_uuid: str) -> bool:
-        """Remove hierarchical label by UUID."""
-        labels = self._data.get("hierarchical_labels", [])
-        for i, label in enumerate(labels):
-            if label.get("uuid") == label_uuid:
-                del labels[i]
-                self._modified = True
-                logger.debug(f"Removed hierarchical label: {label_uuid}")
-                return True
-        return False
+        return wire_uuids
 
     def add_wire_to_pin(
-        self, start_point: Union[Point, Tuple[float, float]], component_ref: str, pin_number: str
+        self, start: Union[Point, Tuple[float, float]], component_ref: str, pin_number: str
     ) -> Optional[str]:
         """
-        Draw a wire from a start point to a component pin.
+        Add wire from arbitrary position to component pin.
 
         Args:
-            start_point: Starting point of the wire
-            component_ref: Reference of the target component (e.g., "R1")
-            pin_number: Pin number on the component (e.g., "1")
+            start: Start position
+            component_ref: Component reference
+            pin_number: Pin number
 
         Returns:
-            UUID of created wire, or None if pin position cannot be determined
+            Wire UUID or None if pin not found
         """
-        from .pin_utils import get_component_pin_position
-
-        # Find the component
-        component = self.components.get(component_ref)
-        if not component:
-            logger.warning(f"Component {component_ref} not found")
-            return None
-
-        # Get the pin position
-        pin_position = get_component_pin_position(component, pin_number)
-        if not pin_position:
-            logger.warning(f"Could not determine position of pin {pin_number} on {component_ref}")
+        pin_pos = self.get_component_pin_position(component_ref, pin_number)
+        if pin_pos is None:
             return None
 
-        # Create the wire
-        return self.add_wire(start_point, pin_position)
+        return self.add_wire(start, pin_pos)
 
     def add_wire_between_pins(
         self, component1_ref: str, pin1_number: str, component2_ref: str, pin2_number: str
     ) -> Optional[str]:
         """
-        Draw a wire between two component pins.
+        Add wire between two component pins.
 
         Args:
-            component1_ref: Reference of the first component (e.g., "R1")
-            pin1_number: Pin number on the first component (e.g., "1")
-            component2_ref: Reference of the second component (e.g., "R2")
-            pin2_number: Pin number on the second component (e.g., "2")
+            component1_ref: First component reference
+            pin1_number: First component pin number
+            component2_ref: Second component reference
+            pin2_number: Second component pin number
 
         Returns:
-            UUID of created wire, or None if either pin position cannot be determined
+            Wire UUID or None if either pin not found
         """
-        from .pin_utils import get_component_pin_position
-
-        # Find both components
-        component1 = self.components.get(component1_ref)
-        component2 = self.components.get(component2_ref)
-
-        if not component1:
-            logger.warning(f"Component {component1_ref} not found")
-            return None
-        if not component2:
-            logger.warning(f"Component {component2_ref} not found")
-            return None
-
-        # Get both pin positions
-        pin1_position = get_component_pin_position(component1, pin1_number)
-        pin2_position = get_component_pin_position(component2, pin2_number)
+        pin1_pos = self.get_component_pin_position(component1_ref, pin1_number)
+        pin2_pos = self.get_component_pin_position(component2_ref, pin2_number)
 
-        if not pin1_position:
-            logger.warning(f"Could not determine position of pin {pin1_number} on {component1_ref}")
-            return None
-        if not pin2_position:
-            logger.warning(f"Could not determine position of pin {pin2_number} on {component2_ref}")
+        if pin1_pos is None or pin2_pos is None:
             return None
 
-        # Create the wire
-        return self.add_wire(pin1_position, pin2_position)
+        return self.add_wire(pin1_pos, pin2_pos)
 
-    def get_component_pin_position(self, component_ref: str, pin_number: str) -> Optional[Point]:
+    def connect_pins_with_wire(
+        self, component1_ref: str, pin1_number: str, component2_ref: str, pin2_number: str
+    ) -> Optional[str]:
         """
-        Get the absolute position of a component pin.
+        Connect two component pins with a wire (alias for add_wire_between_pins).
 
         Args:
-            component_ref: Reference of the component (e.g., "R1")
-            pin_number: Pin number on the component (e.g., "1")
+            component1_ref: First component reference
+            pin1_number: First component pin number
+            component2_ref: Second component reference
+            pin2_number: Second component pin number
 
         Returns:
-            Absolute position of the pin, or None if not found
+            Wire UUID or None if either pin not found
         """
-        from .pin_utils import get_component_pin_position
-
-        component = self.components.get(component_ref)
-        if not component:
-            return None
-
-        return get_component_pin_position(component, pin_number)
+        return self.add_wire_between_pins(component1_ref, pin1_number, component2_ref, pin2_number)
 
-    # Wire routing and connectivity methods
-    def auto_route_pins(
+    # Text and label operations (delegated to TextElementManager)
+    def add_label(
         self,
-        comp1_ref: str,
-        pin1_num: str,
-        comp2_ref: str,
-        pin2_num: str,
-        routing_mode: str = "direct",
-        clearance: float = 2.54,
-    ) -> Optional[str]:
+        text: str,
+        position: Optional[Union[Point, Tuple[float, float]]] = None,
+        pin: Optional[Tuple[str, str]] = None,
+        effects: Optional[Dict[str, Any]] = None,
+        rotation: Optional[float] = None,
+        size: Optional[float] = None,
+        uuid: Optional[str] = None,
+    ) -> str:
         """
-        Auto route between two pins with configurable routing strategies.
-
-        All positions are snapped to KiCAD's 1.27mm grid for exact electrical connections.
+        Add a text label to the schematic.
 
         Args:
-            comp1_ref: First component reference (e.g., 'R1')
-            pin1_num: First component pin number (e.g., '1')
-            comp2_ref: Second component reference (e.g., 'R2')
-            pin2_num: Second component pin number (e.g., '2')
-            routing_mode: Routing strategy:
-                - "direct": Direct connection through components (default)
-                - "manhattan": Manhattan routing with obstacle avoidance
-            clearance: Clearance from obstacles in mm (for manhattan mode)
+            text: Label text content
+            position: Label position (required if pin not provided)
+            pin: Pin to attach label to as (component_ref, pin_number) tuple (alternative to position)
+            effects: Text effects (size, font, etc.)
+            rotation: Label rotation in degrees (default 0, or auto-calculated if pin provided)
+            size: Text size override (default from effects)
+            uuid: Specific UUID for label (auto-generated if None)
 
         Returns:
-            UUID of created wire, or None if routing failed
-        """
-        from .wire_routing import route_pins_direct, snap_to_kicad_grid
-
-        # Get pin positions
-        pin1_pos = self.get_component_pin_position(comp1_ref, pin1_num)
-        pin2_pos = self.get_component_pin_position(comp2_ref, pin2_num)
-
-        if not pin1_pos or not pin2_pos:
-            return None
-
-        # Ensure positions are grid-snapped
-        pin1_pos = snap_to_kicad_grid(pin1_pos)
-        pin2_pos = snap_to_kicad_grid(pin2_pos)
-
-        # Choose routing strategy
-        if routing_mode.lower() == "manhattan":
-            # Manhattan routing with obstacle avoidance
-            from .simple_manhattan import auto_route_with_manhattan
-
-            # Get component objects
-            comp1 = self.components.get(comp1_ref)
-            comp2 = self.components.get(comp2_ref)
-
-            if not comp1 or not comp2:
-                logger.warning(f"Component not found: {comp1_ref} or {comp2_ref}")
-                return None
-
-            return auto_route_with_manhattan(
-                self,
-                comp1,
-                pin1_num,
-                comp2,
-                pin2_num,
-                avoid_components=None,  # Avoid all other components
-                clearance=clearance,
-            )
-        else:
-            # Default direct routing - just connect the pins
-            return self.add_wire(pin1_pos, pin2_pos)
-
-    def are_pins_connected(
-        self, comp1_ref: str, pin1_num: str, comp2_ref: str, pin2_num: str
-    ) -> bool:
-        """
-        Detect when two pins are connected via wire routing.
-
-        Args:
-            comp1_ref: First component reference (e.g., 'R1')
-            pin1_num: First component pin number (e.g., '1')
-            comp2_ref: Second component reference (e.g., 'R2')
-            pin2_num: Second component pin number (e.g., '2')
+            UUID of created label
 
-        Returns:
-            True if pins are connected via wires, False otherwise
+        Raises:
+            ValueError: If neither position nor pin is provided, or if pin is not found
         """
-        from .wire_routing import are_pins_connected
-
-        return are_pins_connected(self, comp1_ref, pin1_num, comp2_ref, pin2_num)
+        from .pin_utils import get_component_pin_info
+
+        # Validate arguments
+        if position is None and pin is None:
+            raise ValueError("Either position or pin must be provided")
+        if position is not None and pin is not None:
+            raise ValueError("Cannot provide both position and pin")
+
+        # Handle pin-based placement
+        justify_h = "left"
+        justify_v = "bottom"
+
+        if pin is not None:
+            component_ref, pin_number = pin
+
+            # Get component
+            component = self._components.get(component_ref)
+            if component is None:
+                raise ValueError(f"Component {component_ref} not found")
+
+            # Get pin position and rotation
+            pin_info = get_component_pin_info(component, pin_number)
+            if pin_info is None:
+                raise ValueError(f"Pin {pin_number} not found on component {component_ref}")
+
+            pin_position, pin_rotation = pin_info
+            position = pin_position
+
+            # Calculate label rotation if not explicitly provided
+            if rotation is None:
+                # Label should face away from component:
+                # Pin rotation indicates where pin points INTO the component
+                # Label should face OPPOSITE direction
+                rotation = (pin_rotation + 180) % 360
+                logger.info(
+                    f"Auto-calculated label rotation: {rotation}° (pin rotation: {pin_rotation}°)"
+                )
 
-    # Legacy method names for compatibility
-    def connect_pins_with_wire(
-        self, component1_ref: str, pin1_number: str, component2_ref: str, pin2_number: str
-    ) -> Optional[str]:
-        """Legacy alias for add_wire_between_pins."""
-        return self.add_wire_between_pins(component1_ref, pin1_number, component2_ref, pin2_number)
+            # Calculate justification based on pin angle
+            # This determines which corner of the text is anchored to the pin position
+            if pin_rotation == 0:  # Pin points right into component
+                justify_h = "left"
+                justify_v = "bottom"
+            elif pin_rotation == 90:  # Pin points up into component
+                justify_h = "right"
+                justify_v = "bottom"
+            elif pin_rotation == 180:  # Pin points left into component
+                justify_h = "right"
+                justify_v = "bottom"
+            elif pin_rotation == 270:  # Pin points down into component
+                justify_h = "left"
+                justify_v = "bottom"
+            logger.info(f"Auto-calculated justification: {justify_h} {justify_v} (pin angle: {pin_rotation}°)")
+
+        # Use default rotation if still not set
+        if rotation is None:
+            rotation = 0
+
+        # Use the new labels collection instead of manager
+        if size is None:
+            size = 1.27  # Default size
+        label = self._labels.add(
+            text, position, rotation=rotation, size=size,
+            justify_h=justify_h, justify_v=justify_v, uuid=uuid
+        )
+        self._sync_labels_to_data()  # Sync immediately
+        self._format_sync_manager.mark_dirty("label", "add", {"uuid": label.uuid})
+        self._modified = True
+        return label.uuid
 
-    def add_label(
+    def add_text(
         self,
         text: str,
         position: Union[Point, Tuple[float, float]],
         rotation: float = 0.0,
         size: float = 1.27,
-        uuid: Optional[str] = None,
+        exclude_from_sim: bool = False,
+        effects: Optional[Dict[str, Any]] = None,
     ) -> str:
         """
-        Add a local label.
+        Add free text annotation to the schematic.
 
         Args:
-            text: Label text
-            position: Label position
+            text: Text content
+            position: Text position
             rotation: Text rotation in degrees
-            size: Font size
-            uuid: Optional UUID (auto-generated if None)
+            size: Text size
+            exclude_from_sim: Whether to exclude from simulation
+            effects: Text effects
 
         Returns:
-            UUID of created label
+            UUID of created text
         """
-        if isinstance(position, tuple):
-            position = Point(position[0], position[1])
-
-        import uuid as uuid_module
-
-        label = Label(
-            uuid=uuid if uuid else str(uuid_module.uuid4()),
-            position=position,
-            text=text,
-            label_type=LabelType.LOCAL,
-            rotation=rotation,
-            size=size,
-        )
-
-        if "labels" not in self._data:
-            self._data["labels"] = []
-
-        self._data["labels"].append(
-            {
-                "uuid": label.uuid,
-                "position": {"x": label.position.x, "y": label.position.y},
-                "text": label.text,
-                "rotation": label.rotation,
-                "size": label.size,
-            }
+        # Use the new texts collection instead of manager
+        text_elem = self._texts.add(
+            text, position, rotation=rotation, size=size, exclude_from_sim=exclude_from_sim
         )
+        self._sync_texts_to_data()  # Sync immediately
+        self._format_sync_manager.mark_dirty("text", "add", {"uuid": text_elem.uuid})
         self._modified = True
+        return text_elem.uuid
 
-        logger.debug(f"Added local label: {text} at {position}")
-        return label.uuid
-
-    def remove_label(self, label_uuid: str) -> bool:
-        """Remove local label by UUID."""
-        labels = self._data.get("labels", [])
-        for i, label in enumerate(labels):
-            if label.get("uuid") == label_uuid:
-                del labels[i]
-                self._modified = True
-                logger.debug(f"Removed local label: {label_uuid}")
-                return True
-        return False
-
-    def add_sheet(
+    def add_text_box(
         self,
-        name: str,
-        filename: str,
+        text: str,
         position: Union[Point, Tuple[float, float]],
         size: Union[Point, Tuple[float, float]],
-        stroke_width: float = 0.1524,
+        rotation: float = 0.0,
+        font_size: float = 1.27,
+        margins: Optional[Tuple[float, float, float, float]] = None,
+        stroke_width: Optional[float] = None,
         stroke_type: str = "solid",
+        fill_type: str = "none",
+        justify_horizontal: str = "left",
+        justify_vertical: str = "top",
         exclude_from_sim: bool = False,
-        in_bom: bool = True,
-        on_board: bool = True,
-        project_name: str = "",
-        page_number: str = "2",
-        uuid: Optional[str] = None,
+        effects: Optional[Dict[str, Any]] = None,
+        stroke: Optional[Dict[str, Any]] = None,
     ) -> str:
         """
-        Add a hierarchical sheet.
+        Add a text box with border to the schematic.
 
         Args:
-            name: Sheet name (displayed above sheet)
-            filename: Sheet filename (.kicad_sch file)
-            position: Sheet position (top-left corner)
-            size: Sheet size (width, height)
-            stroke_width: Border line width
-            stroke_type: Border line type
-            exclude_from_sim: Exclude from simulation
-            in_bom: Include in BOM
-            on_board: Include on board
-            project_name: Project name for instances
-            page_number: Page number for instances
-            uuid: Optional UUID (auto-generated if None)
+            text: Text content
+            position: Top-left position
+            size: Box size (width, height)
+            rotation: Text rotation in degrees
+            font_size: Text font size
+            margins: Box margins (top, bottom, left, right)
+            stroke_width: Border stroke width
+            stroke_type: Border stroke type (solid, dash, etc.)
+            fill_type: Fill type (none, outline, background)
+            justify_horizontal: Horizontal justification
+            justify_vertical: Vertical justification
+            exclude_from_sim: Whether to exclude from simulation
+            effects: Text effects (legacy)
+            stroke: Border stroke settings (legacy)
 
         Returns:
-            UUID of created sheet
+            UUID of created text box
         """
-        if isinstance(position, tuple):
-            position = Point(position[0], position[1])
-        if isinstance(size, tuple):
-            size = Point(size[0], size[1])
-
-        import uuid as uuid_module
-
-        sheet = Sheet(
-            uuid=uuid if uuid else str(uuid_module.uuid4()),
+        text_box_uuid = self._text_element_manager.add_text_box(
+            text=text,
             position=position,
             size=size,
-            name=name,
-            filename=filename,
-            exclude_from_sim=exclude_from_sim,
-            in_bom=in_bom,
-            on_board=on_board,
+            rotation=rotation,
+            font_size=font_size,
+            margins=margins,
             stroke_width=stroke_width,
             stroke_type=stroke_type,
+            fill_type=fill_type,
+            justify_horizontal=justify_horizontal,
+            justify_vertical=justify_vertical,
+            exclude_from_sim=exclude_from_sim,
+            effects=effects,
+            stroke=stroke,
         )
-
-        if "sheets" not in self._data:
-            self._data["sheets"] = []
-
-        self._data["sheets"].append(
-            {
-                "uuid": sheet.uuid,
-                "position": {"x": sheet.position.x, "y": sheet.position.y},
-                "size": {"width": sheet.size.x, "height": sheet.size.y},
-                "name": sheet.name,
-                "filename": sheet.filename,
-                "exclude_from_sim": sheet.exclude_from_sim,
-                "in_bom": sheet.in_bom,
-                "on_board": sheet.on_board,
-                "dnp": sheet.dnp,
-                "fields_autoplaced": sheet.fields_autoplaced,
-                "stroke_width": sheet.stroke_width,
-                "stroke_type": sheet.stroke_type,
-                "fill_color": sheet.fill_color,
-                "pins": [],  # Sheet pins added separately
-                "project_name": project_name,
-                "page_number": page_number,
-            }
-        )
+        self._format_sync_manager.mark_dirty("text_box", "add", {"uuid": text_box_uuid})
         self._modified = True
+        return text_box_uuid
 
-        logger.debug(f"Added hierarchical sheet: {name} ({filename}) at {position}")
-        return sheet.uuid
-
-    def add_sheet_pin(
+    def add_hierarchical_label(
         self,
-        sheet_uuid: str,
-        name: str,
-        pin_type: str = "input",
-        position: Union[Point, Tuple[float, float]] = (0, 0),
-        rotation: float = 0,
+        text: str,
+        position: Union[Point, Tuple[float, float]],
+        shape: str = "input",
+        rotation: float = 0.0,
         size: float = 1.27,
-        justify: str = "right",
-        uuid: Optional[str] = None,
+        effects: Optional[Dict[str, Any]] = None,
     ) -> str:
         """
-        Add a pin to a hierarchical sheet.
+        Add a hierarchical label for sheet connections.
 
         Args:
-            sheet_uuid: UUID of the sheet to add pin to
-            name: Pin name (NET1, NET2, etc.)
-            pin_type: Pin type (input, output, bidirectional, etc.)
-            position: Pin position relative to sheet
-            rotation: Pin rotation in degrees
-            size: Font size for pin label
-            justify: Text justification (left, right, center)
-            uuid: Optional UUID (auto-generated if None)
+            text: Label text
+            position: Label position
+            shape: Shape type (input, output, bidirectional, tri_state, passive)
+            rotation: Label rotation in degrees (default 0)
+            size: Label text size (default 1.27)
+            effects: Text effects
 
         Returns:
-            UUID of created sheet pin
+            UUID of created hierarchical label
         """
-        if isinstance(position, tuple):
-            position = Point(position[0], position[1])
-
-        import uuid as uuid_module
-
-        pin_uuid = uuid if uuid else str(uuid_module.uuid4())
-
-        # Find the sheet in the data
-        sheets = self._data.get("sheets", [])
-        for sheet in sheets:
-            if sheet.get("uuid") == sheet_uuid:
-                # Add pin to the sheet's pins list
-                pin_data = {
-                    "uuid": pin_uuid,
-                    "name": name,
-                    "pin_type": pin_type,
-                    "position": {"x": position.x, "y": position.y},
-                    "rotation": rotation,
-                    "size": size,
-                    "justify": justify,
-                }
-                sheet["pins"].append(pin_data)
-                self._modified = True
-
-                logger.debug(f"Added sheet pin: {name} ({pin_type}) to sheet {sheet_uuid}")
-                return pin_uuid
-
-        raise ValueError(f"Sheet with UUID '{sheet_uuid}' not found")
+        # Use the hierarchical_labels collection
+        hlabel = self._hierarchical_labels.add(text, position, rotation=rotation, size=size)
+        self._sync_hierarchical_labels_to_data()  # Sync immediately
+        self._format_sync_manager.mark_dirty("hierarchical_label", "add", {"uuid": hlabel.uuid})
+        self._modified = True
+        return hlabel.uuid
 
-    def add_text(
+    def add_global_label(
         self,
         text: str,
         position: Union[Point, Tuple[float, float]],
-        rotation: float = 0.0,
-        size: float = 1.27,
-        exclude_from_sim: bool = False,
+        shape: str = "input",
+        effects: Optional[Dict[str, Any]] = None,
     ) -> str:
         """
-        Add a text element.
+        Add a global label for project-wide connections.
 
         Args:
-            text: Text content
-            position: Text position
-            rotation: Text rotation in degrees
-            size: Font size
-            exclude_from_sim: Exclude from simulation
+            text: Label text
+            position: Label position
+            shape: Shape type
+            effects: Text effects
 
         Returns:
-            UUID of created text element
+            UUID of created global label
         """
-        if isinstance(position, tuple):
-            position = Point(position[0], position[1])
+        label_uuid = self._text_element_manager.add_global_label(text, position, shape, effects)
+        self._format_sync_manager.mark_dirty("global_label", "add", {"uuid": label_uuid})
+        self._modified = True
+        return label_uuid
 
-        text_element = Text(
-            uuid=str(uuid.uuid4()),
-            position=position,
-            text=text,
-            rotation=rotation,
-            size=size,
-            exclude_from_sim=exclude_from_sim,
-        )
+    def remove_label(self, label_uuid: str) -> bool:
+        """
+        Remove a label by UUID.
 
-        if "texts" not in self._data:
-            self._data["texts"] = []
+        Args:
+            label_uuid: UUID of label to remove
 
-        self._data["texts"].append(
-            {
-                "uuid": text_element.uuid,
-                "position": {"x": text_element.position.x, "y": text_element.position.y},
-                "text": text_element.text,
-                "rotation": text_element.rotation,
-                "size": text_element.size,
-                "exclude_from_sim": text_element.exclude_from_sim,
-            }
-        )
-        self._modified = True
+        Returns:
+            True if label was removed, False if not found
+        """
+        removed = self._labels.remove(label_uuid)
+        if removed:
+            self._sync_labels_to_data()  # Sync immediately
+            self._format_sync_manager.mark_dirty("label", "remove", {"uuid": label_uuid})
+            self._modified = True
+        return removed
+
+    def remove_hierarchical_label(self, label_uuid: str) -> bool:
+        """
+        Remove a hierarchical label by UUID.
 
-        logger.debug(f"Added text: '{text}' at {position}")
-        return text_element.uuid
+        Args:
+            label_uuid: UUID of hierarchical label to remove
 
-    def add_text_box(
+        Returns:
+            True if hierarchical label was removed, False if not found
+        """
+        removed = self._hierarchical_labels.remove(label_uuid)
+        if removed:
+            self._sync_hierarchical_labels_to_data()  # Sync immediately
+            self._format_sync_manager.mark_dirty(
+                "hierarchical_label", "remove", {"uuid": label_uuid}
+            )
+            self._modified = True
+        return removed
+
+    # Sheet operations (delegated to SheetManager)
+    def add_sheet(
         self,
-        text: str,
+        name: str,
+        filename: str,
         position: Union[Point, Tuple[float, float]],
         size: Union[Point, Tuple[float, float]],
-        rotation: float = 0.0,
-        font_size: float = 1.27,
-        margins: Tuple[float, float, float, float] = (0.9525, 0.9525, 0.9525, 0.9525),
-        stroke_width: float = 0.0,
+        stroke_width: Optional[float] = None,
         stroke_type: str = "solid",
-        fill_type: str = "none",
-        justify_horizontal: str = "left",
-        justify_vertical: str = "top",
-        exclude_from_sim: bool = False,
+        project_name: Optional[str] = None,
+        page_number: Optional[str] = None,
+        uuid: Optional[str] = None,
     ) -> str:
         """
-        Add a text box element.
+        Add a hierarchical sheet to the schematic.
 
         Args:
-            text: Text content
-            position: Text box position (top-left corner)
-            size: Text box size (width, height)
-            rotation: Text rotation in degrees
-            font_size: Font size
-            margins: Margins (top, right, bottom, left)
-            stroke_width: Border line width
-            stroke_type: Border line type
-            fill_type: Fill type (none, solid, etc.)
-            justify_horizontal: Horizontal text alignment
-            justify_vertical: Vertical text alignment
-            exclude_from_sim: Exclude from simulation
+            name: Sheet name/title
+            filename: Referenced schematic filename
+            position: Sheet position (top-left corner)
+            size: Sheet size (width, height)
+            stroke_width: Border stroke width
+            stroke_type: Border stroke type (solid, dashed, etc.)
+            project_name: Project name for this sheet
+            page_number: Page number for this sheet
+            uuid: Optional UUID for the sheet
 
         Returns:
-            UUID of created text box element
+            UUID of created sheet
         """
-        if isinstance(position, tuple):
-            position = Point(position[0], position[1])
-        if isinstance(size, tuple):
-            size = Point(size[0], size[1])
-
-        text_box = TextBox(
-            uuid=str(uuid.uuid4()),
-            position=position,
-            size=size,
-            text=text,
-            rotation=rotation,
-            font_size=font_size,
-            margins=margins,
+        sheet_uuid = self._sheet_manager.add_sheet(
+            name,
+            filename,
+            position,
+            size,
+            uuid_str=uuid,
             stroke_width=stroke_width,
             stroke_type=stroke_type,
-            fill_type=fill_type,
-            justify_horizontal=justify_horizontal,
-            justify_vertical=justify_vertical,
-            exclude_from_sim=exclude_from_sim,
+            project_name=project_name,
+            page_number=page_number,
         )
+        self._format_sync_manager.mark_dirty("sheet", "add", {"uuid": sheet_uuid})
+        self._modified = True
+        return sheet_uuid
 
-        if "text_boxes" not in self._data:
-            self._data["text_boxes"] = []
-
-        self._data["text_boxes"].append(
-            {
-                "uuid": text_box.uuid,
-                "position": {"x": text_box.position.x, "y": text_box.position.y},
-                "size": {"width": text_box.size.x, "height": text_box.size.y},
-                "text": text_box.text,
-                "rotation": text_box.rotation,
-                "font_size": text_box.font_size,
-                "margins": text_box.margins,
-                "stroke_width": text_box.stroke_width,
-                "stroke_type": text_box.stroke_type,
-                "fill_type": text_box.fill_type,
-                "justify_horizontal": text_box.justify_horizontal,
-                "justify_vertical": text_box.justify_vertical,
-                "exclude_from_sim": text_box.exclude_from_sim,
-            }
+    def add_sheet_pin(
+        self,
+        sheet_uuid: str,
+        name: str,
+        pin_type: str,
+        edge: str,
+        position_along_edge: float,
+        uuid: Optional[str] = None,
+    ) -> str:
+        """
+        Add a pin to a hierarchical sheet using edge-based positioning.
+
+        Args:
+            sheet_uuid: UUID of the sheet to add pin to
+            name: Pin name
+            pin_type: Pin type (input, output, bidirectional, tri_state, passive)
+            edge: Edge to place pin on ("right", "bottom", "left", "top")
+            position_along_edge: Distance along edge from reference corner (mm)
+            uuid: Optional UUID for the pin
+
+        Returns:
+            UUID of created sheet pin
+
+        Edge positioning (clockwise from right):
+            - "right": Pins face right (0°), position measured from top edge
+            - "bottom": Pins face down (270°), position measured from left edge
+            - "left": Pins face left (180°), position measured from bottom edge
+            - "top": Pins face up (90°), position measured from left edge
+
+        Example:
+            >>> # Sheet at (100, 100) with size (50, 40)
+            >>> sch.add_sheet_pin(
+            ...     sheet_uuid=sheet_id,
+            ...     name="DATA_IN",
+            ...     pin_type="input",
+            ...     edge="left",
+            ...     position_along_edge=20  # 20mm from top on left edge
+            ... )
+        """
+        pin_uuid = self._sheet_manager.add_sheet_pin(
+            sheet_uuid, name, pin_type, edge, position_along_edge, uuid_str=uuid
         )
+        self._format_sync_manager.mark_dirty("sheet", "modify", {"uuid": sheet_uuid})
         self._modified = True
+        return pin_uuid
+
+    def remove_sheet(self, sheet_uuid: str) -> bool:
+        """
+        Remove a sheet by UUID.
+
+        Args:
+            sheet_uuid: UUID of sheet to remove
 
-        logger.debug(f"Added text box: '{text}' at {position} size {size}")
-        return text_box.uuid
+        Returns:
+            True if sheet was removed, False if not found
+        """
+        removed = self._sheet_manager.remove_sheet(sheet_uuid)
+        if removed:
+            self._format_sync_manager.mark_dirty("sheet", "remove", {"uuid": sheet_uuid})
+            self._modified = True
+        return removed
 
+    # Graphics operations (delegated to GraphicsManager)
     def add_rectangle(
         self,
         start: Union[Point, Tuple[float, float]],
         end: Union[Point, Tuple[float, float]],
-        stroke_width: float = 0.0,
-        stroke_type: str = "default",
-        fill_type: str = "none"
+        stroke_width: float = 0.127,
+        stroke_type: str = "solid",
+        fill_type: str = "none",
+        stroke_color: Optional[Tuple[int, int, int, float]] = None,
+        fill_color: Optional[Tuple[int, int, int, float]] = None,
     ) -> str:
         """
-        Add a graphical rectangle element.
+        Add a rectangle to the schematic.
 
         Args:
-            start: Rectangle start point (top-left)
-            end: Rectangle end point (bottom-right)
-            stroke_width: Border line width
-            stroke_type: Border line type (default, solid, dash, dot, etc.)
-            fill_type: Fill type (none, solid, etc.)
+            start: Top-left corner position
+            end: Bottom-right corner position
+            stroke_width: Line width
+            stroke_type: Line type (solid, dash, dash_dot, dash_dot_dot, dot, or default)
+            fill_type: Fill type (none, background, etc.)
+            stroke_color: Stroke color as (r, g, b, a)
+            fill_color: Fill color as (r, g, b, a)
 
         Returns:
-            UUID of created rectangle element
+            UUID of created rectangle
         """
-        if isinstance(start, tuple):
-            start = Point(start[0], start[1])
-        if isinstance(end, tuple):
-            end = Point(end[0], end[1])
+        # Validate stroke_type
+        valid_stroke_types = ["solid", "dash", "dash_dot", "dash_dot_dot", "dot", "default"]
+        if stroke_type not in valid_stroke_types:
+            raise ValueError(
+                f"Invalid stroke_type '{stroke_type}'. "
+                f"Must be one of: {', '.join(valid_stroke_types)}"
+            )
 
-        from .types import SchematicRectangle
+        # Convert individual parameters to stroke/fill dicts
+        stroke = {"width": stroke_width, "type": stroke_type}
+        if stroke_color:
+            stroke["color"] = stroke_color
 
-        rectangle = SchematicRectangle(
-            uuid=str(uuid.uuid4()),
-            start=start,
-            end=end,
-            stroke_width=stroke_width,
-            stroke_type=stroke_type,
-            fill_type=fill_type
-        )
+        fill = {"type": fill_type}
+        if fill_color:
+            fill["color"] = fill_color
 
-        if "rectangles" not in self._data:
-            self._data["rectangles"] = []
-
-        self._data["rectangles"].append({
-            "uuid": rectangle.uuid,
-            "start": {"x": rectangle.start.x, "y": rectangle.start.y},
-            "end": {"x": rectangle.end.x, "y": rectangle.end.y},
-            "stroke_width": rectangle.stroke_width,
-            "stroke_type": rectangle.stroke_type,
-            "fill_type": rectangle.fill_type
-        })
+        rect_uuid = self._graphics_manager.add_rectangle(start, end, stroke, fill)
+        self._format_sync_manager.mark_dirty("rectangle", "add", {"uuid": rect_uuid})
         self._modified = True
+        return rect_uuid
+
+    def remove_rectangle(self, rect_uuid: str) -> bool:
+        """
+        Remove a rectangle by UUID.
 
-        logger.debug(f"Added rectangle: {start} to {end}")
-        return rectangle.uuid
+        Args:
+            rect_uuid: UUID of rectangle to remove
 
-    def set_title_block(
+        Returns:
+            True if removed, False if not found
+        """
+        removed = self._graphics_manager.remove_rectangle(rect_uuid)
+        if removed:
+            self._format_sync_manager.mark_dirty("rectangle", "remove", {"uuid": rect_uuid})
+            self._modified = True
+        return removed
+
+    def add_image(
         self,
-        title: str = "",
-        date: str = "",
-        rev: str = "",
-        company: str = "",
-        comments: Optional[Dict[int, str]] = None,
-    ):
+        position: Union[Point, Tuple[float, float]],
+        scale: float = 1.0,
+        data: Optional[str] = None,
+    ) -> str:
         """
-        Set title block information.
+        Add an image to the schematic.
 
         Args:
-            title: Schematic title
-            date: Creation/revision date
-            rev: Revision number
-            company: Company name
-            comments: Numbered comments (1, 2, 3, etc.)
-        """
-        if comments is None:
-            comments = {}
+            position: Image position
+            scale: Image scale factor
+            data: Base64 encoded image data
 
-        self._data["title_block"] = {
-            "title": title,
-            "date": date,
-            "rev": rev,
-            "company": company,
-            "comments": comments,
-        }
+        Returns:
+            UUID of created image
+        """
+        image_uuid = self._graphics_manager.add_image(position, scale, data)
+        self._format_sync_manager.mark_dirty("image", "add", {"uuid": image_uuid})
         self._modified = True
+        return image_uuid
+
+    def draw_bounding_box(
+        self,
+        bbox,
+        stroke_width: float = 0.127,
+        stroke_color: str = "black",
+        stroke_type: str = "solid",
+    ) -> str:
+        """
+        Draw a bounding box rectangle around the given bounding box.
+
+        Args:
+            bbox: BoundingBox object with min_x, min_y, max_x, max_y
+            stroke_width: Line width
+            stroke_color: Line color
+            stroke_type: Line type
+
+        Returns:
+            UUID of created rectangle
+        """
+        # Convert bounding box to rectangle coordinates
+        start = (bbox.min_x, bbox.min_y)
+        end = (bbox.max_x, bbox.max_y)
 
-        logger.debug(f"Set title block: {title} rev {rev}")
+        return self.add_rectangle(start, end, stroke_width=stroke_width, stroke_type=stroke_type)
 
     def draw_bounding_box(
         self,
         bbox: "BoundingBox",
-        stroke_width: float = 0,
-        stroke_color: str = None,
-        stroke_type: str = "default",
-        exclude_from_sim: bool = False,
+        stroke_width: float = 0.127,
+        stroke_color: Optional[str] = None,
+        stroke_type: str = "solid",
     ) -> str:
         """
-        Draw a component bounding box as a visual rectangle using KiCAD rectangle graphics.
+        Draw a single bounding box as a rectangle.
 
         Args:
             bbox: BoundingBox to draw
-            stroke_width: Line width for the rectangle (0 = thin, 1 = 1mm, etc.)
-            stroke_color: Color name ('red', 'blue', 'green', etc.) or None for default
-            stroke_type: Stroke type - KiCAD supports: 'default', 'solid', 'dash', 'dot', 'dash_dot', 'dash_dot_dot'
-            exclude_from_sim: Exclude from simulation
+            stroke_width: Line width
+            stroke_color: Line color name (red, green, blue, etc.) or None
+            stroke_type: Line type (solid, dashed, etc.)
 
         Returns:
-            UUID of created rectangle element
+            UUID of created rectangle
         """
-        # Import BoundingBox type
         from .component_bounds import BoundingBox
 
-        rect_uuid = str(uuid.uuid4())
-
-        # Create rectangle data structure in KiCAD dictionary format
-        stroke_data = {"width": stroke_width, "type": stroke_type}
-
-        # Add color if specified
+        # Convert color name to RGBA tuple if provided
+        stroke_rgba = None
         if stroke_color:
-            stroke_data["color"] = stroke_color
-
-        rectangle_data = {
-            "uuid": rect_uuid,
-            "start": {"x": bbox.min_x, "y": bbox.min_y},
-            "end": {"x": bbox.max_x, "y": bbox.max_y},
-            "stroke": stroke_data,
-            "fill": {"type": "none"},
-        }
-
-        # Add to schematic data
-        if "graphics" not in self._data:
-            self._data["graphics"] = []
+            # Simple color name to RGB mapping
+            color_map = {
+                "red": (255, 0, 0, 1.0),
+                "green": (0, 255, 0, 1.0),
+                "blue": (0, 0, 255, 1.0),
+                "yellow": (255, 255, 0, 1.0),
+                "cyan": (0, 255, 255, 1.0),
+                "magenta": (255, 0, 255, 1.0),
+                "black": (0, 0, 0, 1.0),
+                "white": (255, 255, 255, 1.0),
+            }
+            stroke_rgba = color_map.get(stroke_color.lower(), (0, 255, 0, 1.0))
 
-        self._data["graphics"].append(rectangle_data)
-        self._modified = True
+        # Add rectangle using the manager
+        rect_uuid = self.add_rectangle(
+            start=(bbox.min_x, bbox.min_y),
+            end=(bbox.max_x, bbox.max_y),
+            stroke_width=stroke_width,
+            stroke_type=stroke_type,
+            stroke_color=stroke_rgba,
+        )
 
-        logger.debug(f"Drew bounding box rectangle: {bbox}")
+        logger.debug(f"Drew bounding box: {bbox}")
         return rect_uuid
 
     def draw_component_bounding_boxes(
         self,
         include_properties: bool = False,
-        stroke_width: float = 0.254,
-        stroke_color: str = "red",
-        stroke_type: str = "default",
+        stroke_width: float = 0.127,
+        stroke_color: str = "green",
+        stroke_type: str = "solid",
     ) -> List[str]:
         """
-        Draw bounding boxes for all components in the schematic.
+        Draw bounding boxes for all components.
 
         Args:
-            include_properties: Include space for Reference/Value labels
-            stroke_width: Line width for rectangles
-            stroke_color: Color for rectangles
-            stroke_type: Stroke type for rectangles
+            include_properties: Whether to include properties in bounding box
+            stroke_width: Line width
+            stroke_color: Line color
+            stroke_type: Line type
 
         Returns:
-            List of UUIDs for created rectangle elements
+            List of rectangle UUIDs created
         """
         from .component_bounds import get_component_bounding_box
 
@@ -1305,70 +1336,199 @@ class Schematic:
         logger.info(f"Drew {len(uuids)} component bounding boxes")
         return uuids
 
-    # Library management
-    @property
-    def libraries(self) -> "LibraryManager":
-        """Access to library management."""
-        if not hasattr(self, "_library_manager"):
-            from ..library.manager import LibraryManager
-
-            self._library_manager = LibraryManager(self)
-        return self._library_manager
-
-    # Utility methods
-    def clear(self):
-        """Clear all components, wires, and other elements."""
-        self._data["components"] = []
-        self._data["wires"] = []
-        self._data["junctions"] = []
-        self._data["labels"] = []
-        self._components = ComponentCollection()
+    # Metadata operations (delegated to MetadataManager)
+    def set_title_block(
+        self,
+        title: str = "",
+        date: str = "",
+        rev: str = "",
+        company: str = "",
+        comments: Optional[Dict[int, str]] = None,
+    ) -> None:
+        """
+        Set title block information.
+
+        Args:
+            title: Schematic title
+            date: Date
+            rev: Revision
+            company: Company name
+            comments: Comment fields (1-9)
+        """
+        self._metadata_manager.set_title_block(title, date, rev, company, comments)
+        self._format_sync_manager.mark_dirty("title_block", "update")
         self._modified = True
-        logger.info("Cleared schematic")
 
-    def clone(self, new_name: Optional[str] = None) -> "Schematic":
-        """Create a copy of this schematic."""
-        import copy
+    def set_paper_size(self, paper: str) -> None:
+        """
+        Set paper size for the schematic.
 
-        cloned_data = copy.deepcopy(self._data)
+        Args:
+            paper: Paper size (A4, A3, etc.)
+        """
+        self._metadata_manager.set_paper_size(paper)
+        self._format_sync_manager.mark_dirty("paper", "update")
+        self._modified = True
+
+    # Validation (enhanced with ValidationManager)
+    def validate(self) -> List[ValidationIssue]:
+        """
+        Perform comprehensive schematic validation.
+
+        Returns:
+            List of validation issues found
+        """
+        # Use the new ValidationManager for comprehensive validation
+        manager_issues = self._validation_manager.validate_schematic()
+
+        # Also run legacy validator for compatibility
+        try:
+            legacy_issues = self._legacy_validator.validate_schematic_data(self._data)
+        except Exception as e:
+            logger.warning(f"Legacy validator failed: {e}")
+            legacy_issues = []
 
-        if new_name:
-            cloned_data["title_block"]["title"] = new_name
-            cloned_data["uuid"] = str(uuid.uuid4())  # New UUID for clone
+        # Combine issues (remove duplicates based on message)
+        all_issues = manager_issues + legacy_issues
+        unique_issues = []
+        seen_messages = set()
 
-        return Schematic(cloned_data)
+        for issue in all_issues:
+            if issue.message not in seen_messages:
+                unique_issues.append(issue)
+                seen_messages.add(issue.message)
 
-    # Performance optimization
-    def rebuild_indexes(self):
-        """Rebuild internal indexes for performance."""
-        # This would rebuild component indexes, etc.
-        logger.info("Rebuilt schematic indexes")
+        return unique_issues
 
-    def get_performance_stats(self) -> Dict[str, Any]:
-        """Get performance statistics."""
-        cache_stats = get_symbol_cache().get_performance_stats()
+    def get_validation_summary(self) -> Dict[str, Any]:
+        """
+        Get validation summary statistics.
 
+        Returns:
+            Summary dictionary with counts and severity
+        """
+        issues = self.validate()
+        return self._validation_manager.get_validation_summary(issues)
+
+    # Statistics and information
+    def get_statistics(self) -> Dict[str, Any]:
+        """Get comprehensive schematic statistics."""
         return {
-            "schematic": {
+            "components": len(self._components),
+            "wires": len(self._wires),
+            "junctions": len(self._junctions),
+            "text_elements": self._text_element_manager.get_text_statistics(),
+            "graphics": self._graphics_manager.get_graphics_statistics(),
+            "sheets": self._sheet_manager.get_sheet_statistics(),
+            "performance": {
                 "operation_count": self._operation_count,
-                "total_operation_time_s": round(self._total_operation_time, 3),
-                "avg_operation_time_ms": round(
-                    (
-                        (self._total_operation_time / self._operation_count * 1000)
-                        if self._operation_count > 0
-                        else 0
-                    ),
-                    2,
-                ),
+                "total_operation_time": self._total_operation_time,
+                "modified": self.modified,
+                "last_save_time": self._last_save_time,
             },
-            "components": self._components.get_statistics(),
-            "symbol_cache": cache_stats,
         }
 
     # Internal methods
+    @staticmethod
+    def _create_empty_schematic_data() -> Dict[str, Any]:
+        """Create empty schematic data structure."""
+        from uuid import uuid4
+
+        return {
+            "version": "20250114",
+            "generator": "eeschema",
+            "generator_version": "9.0",
+            "uuid": str(uuid4()),
+            "paper": "A4",
+            "lib_symbols": {},
+            "symbol": [],
+            "wire": [],
+            "junction": [],
+            "label": [],
+            "hierarchical_label": [],
+            "global_label": [],
+            "text": [],
+            "sheet": [],
+            "rectangle": [],
+            "circle": [],
+            "arc": [],
+            "polyline": [],
+            "image": [],
+            "symbol_instances": [],
+            "sheet_instances": [],
+            "embedded_fonts": "no",
+            "components": [],
+            "wires": [],
+            "junctions": [],
+            "labels": [],
+            "nets": [],
+        }
+
+    # Context manager support for atomic operations
+    def __enter__(self):
+        """Enter atomic operation context."""
+        # Create backup for rollback
+        if self._file_path and self._file_path.exists():
+            self._backup_path = self._file_io_manager.create_backup(
+                self._file_path, ".atomic_backup"
+            )
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Exit atomic operation context."""
+        if exc_type is not None:
+            # Exception occurred - rollback if possible
+            if hasattr(self, "_backup_path") and self._backup_path.exists():
+                logger.warning("Exception in atomic operation - rolling back")
+                # Restore from backup
+                restored_data = self._file_io_manager.load_schematic(self._backup_path)
+                self._data = restored_data
+                self._modified = True
+        else:
+            # Success - clean up backup
+            if hasattr(self, "_backup_path") and self._backup_path.exists():
+                self._backup_path.unlink()
+
+    # Internal sync methods (migrated from original implementation)
     def _sync_components_to_data(self):
         """Sync component collection state back to data structure."""
-        self._data["components"] = [comp._data.__dict__ for comp in self._components]
+        logger.debug("🔍 _sync_components_to_data: Syncing components to _data")
+
+        components_data = []
+        for comp in self._components:
+            # Start with base component data
+            comp_dict = {k: v for k, v in comp._data.__dict__.items() if not k.startswith("_")}
+
+            # CRITICAL FIX: Explicitly preserve instances if user set them
+            if hasattr(comp._data, "instances") and comp._data.instances:
+                logger.debug(
+                    f"   Component {comp._data.reference} has {len(comp._data.instances)} instance(s)"
+                )
+                comp_dict["instances"] = [
+                    {
+                        "project": (
+                            getattr(inst, "project", self.name)
+                            if hasattr(inst, "project")
+                            else self.name
+                        ),
+                        "path": inst.path,  # PRESERVE exact path user set!
+                        "reference": inst.reference,
+                        "unit": inst.unit,
+                    }
+                    for inst in comp._data.instances
+                ]
+                logger.debug(
+                    f"      Instance paths: {[inst.path for inst in comp._data.instances]}"
+                )
+            else:
+                logger.debug(
+                    f"   Component {comp._data.reference} has NO instances (will be generated by parser)"
+                )
+
+            components_data.append(comp_dict)
+
+        self._data["components"] = components_data
+        logger.debug(f"   Synced {len(components_data)} components to _data")
 
         # Populate lib_symbols with actual symbol definitions used by components
         lib_symbols = {}
@@ -1376,112 +1536,23 @@ class Schematic:
 
         for comp in self._components:
             if comp.lib_id and comp.lib_id not in lib_symbols:
-                logger.debug(f"🔧 SCHEMATIC: Processing component {comp.lib_id}")
-
                 # Get the actual symbol definition
                 symbol_def = cache.get_symbol(comp.lib_id)
+
                 if symbol_def:
-                    logger.debug(f"🔧 SCHEMATIC: Loaded symbol {comp.lib_id}")
-                    lib_symbols[comp.lib_id] = self._convert_symbol_to_kicad_format(
-                        symbol_def, comp.lib_id
-                    )
-
-                    # Check if this symbol extends another symbol using multiple methods
-                    extends_parent = None
-
-                    # Method 1: Check raw_kicad_data
-                    if hasattr(symbol_def, "raw_kicad_data") and symbol_def.raw_kicad_data:
-                        extends_parent = self._check_symbol_extends(symbol_def.raw_kicad_data)
-                        logger.debug(
-                            f"🔧 SCHEMATIC: Checked raw_kicad_data for {comp.lib_id}, extends: {extends_parent}"
-                        )
-
-                    # Method 2: Check raw_data attribute
-                    if not extends_parent and hasattr(symbol_def, "__dict__"):
-                        for attr_name, attr_value in symbol_def.__dict__.items():
-                            if attr_name == "raw_data":
-                                logger.debug(
-                                    f"🔧 SCHEMATIC: Checking raw_data for extends: {type(attr_value)}"
-                                )
-                                extends_parent = self._check_symbol_extends(attr_value)
-                                if extends_parent:
-                                    logger.debug(
-                                        f"🔧 SCHEMATIC: Found extends in raw_data: {extends_parent}"
-                                    )
-
-                    # Method 3: Check the extends attribute directly
-                    if not extends_parent and hasattr(symbol_def, "extends"):
-                        extends_parent = symbol_def.extends
-                        logger.debug(f"🔧 SCHEMATIC: Found extends attribute: {extends_parent}")
-
-                    if extends_parent:
-                        # Load the parent symbol too
-                        parent_lib_id = f"{comp.lib_id.split(':')[0]}:{extends_parent}"
-                        logger.debug(f"🔧 SCHEMATIC: Loading parent symbol: {parent_lib_id}")
-
-                        if parent_lib_id not in lib_symbols:
-                            parent_symbol_def = cache.get_symbol(parent_lib_id)
-                            if parent_symbol_def:
-                                lib_symbols[parent_lib_id] = self._convert_symbol_to_kicad_format(
-                                    parent_symbol_def, parent_lib_id
-                                )
-                                logger.debug(
-                                    f"🔧 SCHEMATIC: Successfully loaded parent symbol: {parent_lib_id} for {comp.lib_id}"
-                                )
-                            else:
-                                logger.warning(
-                                    f"🔧 SCHEMATIC: Failed to load parent symbol: {parent_lib_id}"
-                                )
-                        else:
-                            logger.debug(
-                                f"🔧 SCHEMATIC: Parent symbol {parent_lib_id} already loaded"
-                            )
-                    else:
-                        logger.debug(f"🔧 SCHEMATIC: No extends found for {comp.lib_id}")
-                else:
-                    # Fallback for unknown symbols
-                    logger.warning(
-                        f"🔧 SCHEMATIC: Failed to load symbol {comp.lib_id}, using fallback"
-                    )
-                    lib_symbols[comp.lib_id] = {"definition": "basic"}
+                    converted_symbol = self._convert_symbol_to_kicad_format(symbol_def, comp.lib_id)
+                    lib_symbols[comp.lib_id] = converted_symbol
 
         self._data["lib_symbols"] = lib_symbols
 
-        # Debug: Log the final lib_symbols structure
-        logger.debug(f"🔧 FINAL: lib_symbols contains {len(lib_symbols)} symbols:")
-        for sym_id in lib_symbols.keys():
-            logger.debug(f"🔧 FINAL: - {sym_id}")
-            # Check if this symbol has extends
-            sym_data = lib_symbols[sym_id]
-            if isinstance(sym_data, list) and len(sym_data) > 2:
-                for item in sym_data[1:]:
-                    if isinstance(item, list) and len(item) >= 2:
-                        if item[0] == sexpdata.Symbol("extends"):
-                            logger.debug(f"🔧 FINAL: - {sym_id} extends {item[1]}")
-                            break
-
-    def _check_symbol_extends(self, symbol_data: Any) -> Optional[str]:
-        """Check if symbol extends another symbol and return parent name."""
-        logger.debug(f"🔧 EXTENDS: Checking symbol data type: {type(symbol_data)}")
+        # Update sheet instances
+        if not self._data["sheet_instances"]:
+            self._data["sheet_instances"] = [{"path": "/", "page": "1"}]
 
-        if not isinstance(symbol_data, list):
-            logger.debug(f"🔧 EXTENDS: Not a list, returning None")
-            return None
-
-        logger.debug(f"🔧 EXTENDS: Checking {len(symbol_data)} items for extends directive")
-
-        for i, item in enumerate(symbol_data[1:], 1):
-            logger.debug(
-                f"🔧 EXTENDS: Item {i}: {type(item)} - {item if not isinstance(item, list) else f'list[{len(item)}]'}"
-            )
-            if isinstance(item, list) and len(item) >= 2:
-                if item[0] == sexpdata.Symbol("extends"):
-                    parent_name = str(item[1]).strip('"')
-                    logger.debug(f"🔧 EXTENDS: Found extends directive: {parent_name}")
-                    return parent_name
-
-        logger.debug(f"🔧 EXTENDS: No extends directive found")
-        return None
+        # Remove symbol_instances section - instances are stored within each symbol in lib_symbols
+        # This matches KiCAD's format where instances are part of the symbol definition
+        if "symbol_instances" in self._data:
+            del self._data["symbol_instances"]
 
     def _sync_wires_to_data(self):
         """Sync wire collection state back to data structure."""
@@ -1512,163 +1583,341 @@ class Schematic:
 
         self._data["junctions"] = junction_data
 
-    def _convert_symbol_to_kicad_format(
-        self, symbol: "SymbolDefinition", lib_id: str
-    ) -> Dict[str, Any]:
-        """Convert SymbolDefinition to KiCAD lib_symbols format using raw parsed data."""
-        # If we have raw KiCAD data from the library file, use it directly
-        if hasattr(symbol, "raw_kicad_data") and symbol.raw_kicad_data:
-            return self._convert_raw_symbol_data(symbol.raw_kicad_data, lib_id)
+    def _sync_texts_to_data(self):
+        """Sync text collection state back to data structure."""
+        text_data = []
+        for text_element in self._texts:
+            text_dict = {
+                "uuid": text_element.uuid,
+                "text": text_element.text,
+                "position": {"x": text_element.position.x, "y": text_element.position.y},
+                "rotation": text_element.rotation,
+                "size": text_element.size,
+                "exclude_from_sim": text_element.exclude_from_sim,
+            }
+            text_data.append(text_dict)
+
+        self._data["texts"] = text_data
+
+    def _sync_labels_to_data(self):
+        """Sync label collection state back to data structure."""
+        label_data = []
+        for label_element in self._labels:
+            label_dict = {
+                "uuid": label_element.uuid,
+                "text": label_element.text,
+                "position": {"x": label_element.position.x, "y": label_element.position.y},
+                "rotation": label_element.rotation,
+                "size": label_element.size,
+                "justify_h": label_element._data.justify_h,
+                "justify_v": label_element._data.justify_v,
+            }
+            label_data.append(label_dict)
+
+        self._data["labels"] = label_data
+
+    def _sync_hierarchical_labels_to_data(self):
+        """Sync hierarchical label collection state back to data structure."""
+        hierarchical_label_data = []
+        for hlabel_element in self._hierarchical_labels:
+            hlabel_dict = {
+                "uuid": hlabel_element.uuid,
+                "text": hlabel_element.text,
+                "position": {"x": hlabel_element.position.x, "y": hlabel_element.position.y},
+                "rotation": hlabel_element.rotation,
+                "size": hlabel_element.size,
+            }
+            hierarchical_label_data.append(hlabel_dict)
+
+        self._data["hierarchical_labels"] = hierarchical_label_data
+
+    def _sync_no_connects_to_data(self):
+        """Sync no-connect collection state back to data structure."""
+        no_connect_data = []
+        for no_connect_element in self._no_connects:
+            no_connect_dict = {
+                "uuid": no_connect_element.uuid,
+                "position": {
+                    "x": no_connect_element.position.x,
+                    "y": no_connect_element.position.y,
+                },
+            }
+            no_connect_data.append(no_connect_dict)
+
+        self._data["no_connects"] = no_connect_data
+
+    def _sync_nets_to_data(self):
+        """Sync net collection state back to data structure."""
+        net_data = []
+        for net_element in self._nets:
+            net_dict = {
+                "name": net_element.name,
+                "components": net_element.components,
+                "wires": net_element.wires,
+                "labels": net_element.labels,
+            }
+            net_data.append(net_dict)
+
+        self._data["nets"] = net_data
+
+    def _convert_symbol_to_kicad_format(self, symbol_def, lib_id: str):
+        """Convert symbol definition to KiCAD format."""
+        # Use raw data if available, but fix the symbol name to use full lib_id
+        if hasattr(symbol_def, "raw_kicad_data") and symbol_def.raw_kicad_data:
+            raw_data = symbol_def.raw_kicad_data
+
+            # Check if raw data already contains instances with project info
+            project_refs_found = []
+
+            def find_project_refs(data, path="root"):
+                if isinstance(data, list):
+                    for i, item in enumerate(data):
+                        if hasattr(item, "__str__") and str(item) == "project":
+                            if i < len(data) - 1:
+                                project_refs_found.append(f"{path}[{i}] = '{data[i+1]}'")
+                        elif isinstance(item, list):
+                            find_project_refs(item, f"{path}[{i}]")
+
+            find_project_refs(raw_data)
+
+            # Make a copy and fix the symbol name (index 1) to use full lib_id
+            if isinstance(raw_data, list) and len(raw_data) > 1:
+                fixed_data = raw_data.copy()
+                fixed_data[1] = lib_id  # Replace short name with full lib_id
+
+                # Also fix any project references in instances to use current project name
+                self._fix_symbol_project_references(fixed_data)
+
+                return fixed_data
+            else:
+                return raw_data
 
         # Fallback: create basic symbol structure
         return {
-            "pin_numbers": {"hide": "yes"},
-            "pin_names": {"offset": 0},
-            "exclude_from_sim": "no",
-            "in_bom": "yes",
-            "on_board": "yes",
-            "properties": {
-                "Reference": {
-                    "value": symbol.reference_prefix,
-                    "at": [2.032, 0, 90],
-                    "effects": {"font": {"size": [1.27, 1.27]}},
-                },
-                "Value": {
-                    "value": symbol.reference_prefix,
-                    "at": [0, 0, 90],
-                    "effects": {"font": {"size": [1.27, 1.27]}},
-                },
-                "Footprint": {
-                    "value": "",
-                    "at": [-1.778, 0, 90],
-                    "effects": {"font": {"size": [1.27, 1.27]}, "hide": "yes"},
-                },
-                "Datasheet": {
-                    "value": getattr(symbol, "Datasheet", None)
-                    or getattr(symbol, "datasheet", None)
-                    or "~",
-                    "at": [0, 0, 0],
-                    "effects": {"font": {"size": [1.27, 1.27]}, "hide": "yes"},
-                },
-                "Description": {
-                    "value": getattr(symbol, "Description", None)
-                    or getattr(symbol, "description", None)
-                    or "Resistor",
-                    "at": [0, 0, 0],
-                    "effects": {"font": {"size": [1.27, 1.27]}, "hide": "yes"},
-                },
-            },
-            "embedded_fonts": "no",
+            "lib_id": lib_id,
+            "symbol": symbol_def.name if hasattr(symbol_def, "name") else lib_id.split(":")[-1],
         }
 
-    def _convert_raw_symbol_data(self, raw_data: List, lib_id: str) -> Dict[str, Any]:
-        """Convert raw parsed KiCAD symbol data to dictionary format for S-expression generation."""
-        import copy
+    def _fix_symbol_project_references(self, symbol_data):
+        """Fix project references in symbol instances to use current project name."""
+        if not isinstance(symbol_data, list):
+            return
+
+        # Recursively search for instances sections and update project names
+        for i, element in enumerate(symbol_data):
+            if isinstance(element, list):
+                # Check if this is an instances section
+                if (
+                    len(element) > 0
+                    and hasattr(element[0], "__str__")
+                    and str(element[0]) == "instances"
+                ):
+                    # Look for project references within instances
+                    self._update_project_in_instances(element)
+                else:
+                    # Recursively check nested lists
+                    self._fix_symbol_project_references(element)
+
+    def _update_project_in_instances(self, instances_element):
+        """Update project name in instances element."""
+        if not isinstance(instances_element, list):
+            return
+
+        for i, element in enumerate(instances_element):
+            if isinstance(element, list) and len(element) >= 2:
+                # Check if this is a project element: ['project', 'old_name', ...]
+                if hasattr(element[0], "__str__") and str(element[0]) == "project":
+                    old_name = element[1]
+                    element[1] = self.name  # Replace with current schematic name
+                else:
+                    # Recursively check nested elements
+                    self._update_project_in_instances(element)
 
-        import sexpdata
+    # ============================================================================
+    # Export Methods (using kicad-cli)
+    # ============================================================================
 
-        # Make a copy and fix symbol name and string/symbol issues
-        modified_data = copy.deepcopy(raw_data)
+    def run_erc(self, **kwargs):
+        """
+        Run Electrical Rule Check (ERC) on this schematic.
 
-        # Replace the symbol name with the full lib_id
-        if len(modified_data) >= 2:
-            modified_data[1] = lib_id  # Change 'R' to 'Device:R'
+        This requires the schematic to be saved first.
 
-        # Fix extends directive to use full lib_id
-        logger.debug(f"🔧 CONVERT: Processing {len(modified_data)} items for {lib_id}")
-        for i, item in enumerate(modified_data[1:], 1):
-            if isinstance(item, list) and len(item) >= 2:
-                logger.debug(
-                    f"🔧 CONVERT: Item {i}: {item[0]} = {item[1] if len(item) > 1 else 'N/A'}"
-                )
-                if item[0] == sexpdata.Symbol("extends"):
-                    # Convert bare symbol name to full lib_id
-                    parent_name = str(item[1]).strip('"')
-                    parent_lib_id = f"{lib_id.split(':')[0]}:{parent_name}"
-                    modified_data[i][1] = parent_lib_id
-                    logger.debug(
-                        f"🔧 CONVERT: Fixed extends directive: {parent_name} -> {parent_lib_id}"
-                    )
-                    break
-
-        # Fix string/symbol conversion issues in pin definitions
-        print(f"🔧 DEBUG: Before fix - checking for pin definitions...")
-        self._fix_symbol_strings_recursively(modified_data)
-        print(f"🔧 DEBUG: After fix - symbol strings fixed")
-
-        return modified_data
-
-    def _fix_symbol_strings_recursively(self, data):
-        """Recursively fix string/symbol issues in parsed S-expression data."""
-        import sexpdata
-
-        if isinstance(data, list):
-            for i, item in enumerate(data):
-                if isinstance(item, list):
-                    # Check for pin definitions that need fixing
-                    if len(item) >= 3 and item[0] == sexpdata.Symbol("pin"):
-                        print(
-                            f"🔧 DEBUG: Found pin definition: {item[:3]} - types: {[type(x) for x in item[:3]]}"
-                        )
-                        # Fix pin type and shape - ensure they are symbols not strings
-                        if isinstance(item[1], str):
-                            print(f"🔧 DEBUG: Converting pin type '{item[1]}' to symbol")
-                            item[1] = sexpdata.Symbol(item[1])  # pin type: "passive" -> passive
-                        if len(item) >= 3 and isinstance(item[2], str):
-                            print(f"🔧 DEBUG: Converting pin shape '{item[2]}' to symbol")
-                            item[2] = sexpdata.Symbol(item[2])  # pin shape: "line" -> line
-
-                    # Recursively process nested lists
-                    self._fix_symbol_strings_recursively(item)
-                elif isinstance(item, str):
-                    # Fix common KiCAD keywords that should be symbols
-                    if item in ["yes", "no", "default", "none", "left", "right", "center"]:
-                        data[i] = sexpdata.Symbol(item)
-
-        return data
+        Args:
+            **kwargs: Arguments passed to cli.erc.run_erc()
+                - output_path: Path for ERC report
+                - format: 'json' or 'report'
+                - severity: 'all', 'error', 'warning', 'exclusions'
+                - units: 'mm', 'in', 'mils'
 
-    @staticmethod
-    def _create_empty_schematic_data() -> Dict[str, Any]:
-        """Create empty schematic data structure."""
-        return {
-            "version": "20250114",
-            "generator": "eeschema",
-            "generator_version": "9.0",
-            "uuid": str(uuid.uuid4()),
-            "paper": "A4",
-            "components": [],
-            "wires": [],
-            "junctions": [],
-            "labels": [],
-            "nets": [],
-            "lib_symbols": {},
-            "sheet_instances": [{"path": "/", "page": "1"}],
-            "symbol_instances": [],
-            "embedded_fonts": "no",
-        }
+        Returns:
+            ErcReport with violations and summary
 
-    # Context manager support for atomic operations
-    def __enter__(self):
-        """Enter atomic operation context."""
-        # Create backup for potential rollback
-        if self._file_path and self._file_path.exists():
-            self._backup_path = self.backup(".atomic_backup")
-        return self
+        Example:
+            >>> report = sch.run_erc()
+            >>> if report.has_errors():
+            ...     print(f"Found {report.error_count} errors")
+        """
+        from kicad_sch_api.cli.erc import run_erc
 
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        """Exit atomic operation context."""
-        if exc_type is not None:
-            # Exception occurred - rollback if possible
-            if hasattr(self, "_backup_path") and self._backup_path.exists():
-                logger.warning("Exception in atomic operation - rolling back")
-                # Restore from backup
-                restored_data = self._parser.parse_file(self._backup_path)
-                self._data = restored_data
-                self._modified = True
-        else:
-            # Success - clean up backup
-            if hasattr(self, "_backup_path") and self._backup_path.exists():
-                self._backup_path.unlink()
+        if not self._file_path:
+            raise ValueError("Schematic must be saved before running ERC")
+
+        # Save first to ensure file is up-to-date
+        self.save()
+
+        return run_erc(self._file_path, **kwargs)
+
+    def export_netlist(self, format="kicadsexpr", **kwargs):
+        """
+        Export netlist from this schematic.
+
+        This requires the schematic to be saved first.
+
+        Args:
+            format: Netlist format (default: 'kicadsexpr')
+                - kicadsexpr: KiCad S-expression (default)
+                - kicadxml: KiCad XML
+                - spice: SPICE netlist
+                - spicemodel: SPICE with models
+                - cadstar, orcadpcb2, pads, allegro
+            **kwargs: Arguments passed to cli.netlist.export_netlist()
+
+        Returns:
+            Path to generated netlist file
+
+        Example:
+            >>> netlist = sch.export_netlist(format='spice')
+            >>> print(f"Netlist: {netlist}")
+        """
+        from kicad_sch_api.cli.netlist import export_netlist
+
+        if not self._file_path:
+            raise ValueError("Schematic must be saved before exporting netlist")
+
+        # Save first to ensure file is up-to-date
+        self.save()
+
+        return export_netlist(self._file_path, format=format, **kwargs)
+
+    def export_bom(self, **kwargs):
+        """
+        Export Bill of Materials (BOM) from this schematic.
+
+        This requires the schematic to be saved first.
+
+        Args:
+            **kwargs: Arguments passed to cli.bom.export_bom()
+                - output_path: Path for BOM file
+                - fields: List of fields to export
+                - group_by: Fields to group by
+                - exclude_dnp: Exclude Do-Not-Populate components
+                - And many more options...
+
+        Returns:
+            Path to generated BOM file
+
+        Example:
+            >>> bom = sch.export_bom(
+            ...     fields=['Reference', 'Value', 'Footprint', 'MPN'],
+            ...     group_by=['Value', 'Footprint'],
+            ...     exclude_dnp=True,
+            ... )
+        """
+        from kicad_sch_api.cli.bom import export_bom
+
+        if not self._file_path:
+            raise ValueError("Schematic must be saved before exporting BOM")
+
+        # Save first to ensure file is up-to-date
+        self.save()
+
+        return export_bom(self._file_path, **kwargs)
+
+    def export_pdf(self, **kwargs):
+        """
+        Export schematic as PDF.
+
+        This requires the schematic to be saved first.
+
+        Args:
+            **kwargs: Arguments passed to cli.export_docs.export_pdf()
+                - output_path: Path for PDF file
+                - theme: Color theme
+                - black_and_white: B&W export
+                - And more options...
+
+        Returns:
+            Path to generated PDF file
+
+        Example:
+            >>> pdf = sch.export_pdf(theme='Kicad Classic')
+        """
+        from kicad_sch_api.cli.export_docs import export_pdf
+
+        if not self._file_path:
+            raise ValueError("Schematic must be saved before exporting PDF")
+
+        # Save first to ensure file is up-to-date
+        self.save()
+
+        return export_pdf(self._file_path, **kwargs)
+
+    def export_svg(self, **kwargs):
+        """
+        Export schematic as SVG.
+
+        This requires the schematic to be saved first.
+
+        Args:
+            **kwargs: Arguments passed to cli.export_docs.export_svg()
+                - output_dir: Output directory
+                - theme: Color theme
+                - black_and_white: B&W export
+                - And more options...
+
+        Returns:
+            List of paths to generated SVG files
+
+        Example:
+            >>> svgs = sch.export_svg()
+            >>> for svg in svgs:
+            ...     print(f"Generated: {svg}")
+        """
+        from kicad_sch_api.cli.export_docs import export_svg
+
+        if not self._file_path:
+            raise ValueError("Schematic must be saved before exporting SVG")
+
+        # Save first to ensure file is up-to-date
+        self.save()
+
+        return export_svg(self._file_path, **kwargs)
+
+    def export_dxf(self, **kwargs):
+        """
+        Export schematic as DXF.
+
+        This requires the schematic to be saved first.
+
+        Args:
+            **kwargs: Arguments passed to cli.export_docs.export_dxf()
+
+        Returns:
+            List of paths to generated DXF files
+
+        Example:
+            >>> dxfs = sch.export_dxf()
+        """
+        from kicad_sch_api.cli.export_docs import export_dxf
+
+        if not self._file_path:
+            raise ValueError("Schematic must be saved before exporting DXF")
+
+        # Save first to ensure file is up-to-date
+        self.save()
+
+        return export_dxf(self._file_path, **kwargs)
 
     def __str__(self) -> str:
         """String representation."""