cross_section

class AsymmetricCrossSection(TAsymmetricCrossSection[int]):
    """dbu-flavored wrapper around an `AsymmetricalCrossSection`."""

    def add_bbox(
        self,
        c: KCell | DKCell | VKCell,
        ref: kdb.LayerInfo
        | int
        | kdb.Box
        | kdb.DBox
        | ProtoInstance[Any]
        | None = None,
        *,
        top: int | None = None,
        bottom: int | None = None,
        right: int | None = None,
        left: int | None = None,
    ) -> None:
        """Draw bbox_sections using padding in integer dbu.

        Args:
            c: Target KCell, DKCell, or VKCell, including subclasses. Must share
                this cross section's KCLayout, as must any instance reference.
            ref: None for the whole target, a layer/index in c, an explicit
                Box (dbu) or DBox (micrometers), or an instance's transformed
                bounds in c's coordinate system. Cell references are not accepted.
            top: Top padding override for every bbox layer.
            bottom: Bottom padding override for every bbox layer.
            right: Right padding override for every bbox layer.
            left: Left padding override for every bbox layer.

        None padding uses each layer's stored offset; zero suppresses padding.
        Real targets use integer geometry; VKCell targets use micrometers.
        All layers use the same original bounds. Empty references draw nothing;
        neither the cross section nor the reference box is modified.

        Warning:
            Logs a warning when a non-VKCell target has pending virtual instances,
            even with an explicit reference. Call insert_vinsts() first to avoid
            inaccurate geometry. This method does not materialize instances.

        Raises:
            LockedError: The target cell is locked.
            TypeError: The target or reference type is unsupported.
            ValueError: The target or instance reference uses another KCLayout.
        """
        from .kcell import DKCell, KCell, VKCell

        if not isinstance(c, KCell | DKCell | VKCell):
            raise TypeError("The bbox target must be a KCell, DKCell, or VKCell")
        if c.kcl is not self.kcl:
            raise ValueError(
                "The cross section and target must share the same KCLayout"
            )
        if c.locked:
            raise LockedError(c)
        if isinstance(c, VKCell):
            self.to_dtype().add_bbox(
                c,
                ref,
                top=self.kcl.to_um(top),
                bottom=self.kcl.to_um(bottom),
                right=self.kcl.to_um(right),
                left=self.kcl.to_um(left),
            )
            return
        bbox = _bbox_reference(c, ref)
        _add_bbox(
            c,
            bbox if isinstance(bbox, kdb.Box) else self.kcl.to_dbu(bbox),
            {
                self.kcl.layer(layer): offset
                for layer, offset in self.bbox_sections.items()
            },
            top=top,
            bottom=bottom,
            right=right,
            left=left,
        )

    @overload
    def __init__(self, kcl: KCLayout, *, base: AsymmetricalCrossSection) -> None: ...

    @overload
    def __init__(
        self,
        kcl: KCLayout,
        section_min: int,
        section_max: int,
        layer: kdb.LayerInfo,
        sections: Sequence[CrossSectionLayer] = (),
        name: str | None = None,
        radius: int | None = None,
        radius_min: int | None = None,
        bbox_sections: dict[kdb.LayerInfo, int] | None = None,
    ) -> None: ...

    def __init__(
        self,
        kcl: KCLayout,
        section_min: int | None = None,
        section_max: int | None = None,
        layer: kdb.LayerInfo | None = None,
        sections: Sequence[CrossSectionLayer] = (),
        name: str | None = None,
        radius: int | None = None,
        radius_min: int | None = None,
        bbox_sections: dict[kdb.LayerInfo, int] | None = None,
        base: AsymmetricalCrossSection | None = None,
    ) -> None:
        if base is None:
            if section_min is None or section_max is None or layer is None:
                raise ValueError(
                    "If no base is given, section_min, section_max, and layer"
                    " must be defined"
                )
            base = kcl.get_asymmetrical_cross_section(
                AsymmetricalCrossSection(
                    layer=layer,
                    section_min=section_min,
                    section_max=section_max,
                    sections=tuple(sections),
                    name=name or "",
                    radius=radius,
                    radius_min=radius_min,
                    bbox_sections=bbox_sections or {},
                )
            )
        self.kcl = kcl
        self._base = base

    @property
    def width(self) -> int:
        return self._base.width

    @property
    def section_min(self) -> int:
        return self._base.section_min

    @property
    def section_max(self) -> int:
        return self._base.section_max

    @property
    def sections(self) -> tuple[CrossSectionLayer, ...]:
        return self._base.sections

    def get_sections(self) -> tuple[CrossSectionLayer, ...]:
        """Absolute signed dbu strips of the realised profile, main strip first."""
        return self._base.get_sections()

    @property
    def radius(self) -> int | None:
        return self._base.radius

    @property
    def radius_min(self) -> int | None:
        return self._base.radius_min

    @property
    def bbox_sections(self) -> dict[kdb.LayerInfo, int]:
        return self._base.bbox_sections.copy()

    def get_xmin_xmax(self) -> tuple[int, int]:
        return (self._base.get_xmin(), self._base.get_xmax())

class AsymmetricalCrossSection(BaseModel, frozen=True, arbitrary_types_allowed=True):
    """Cross section composed of independent layer strips at signed bounds.

    The main strip (`layer`, `section_min`, `section_max`) is the port
    reference; `sections` holds any additional strips. All bounds are signed
    integer dbu relative to the port centerline (`x = 0`). Strip edges are
    always grid-aligned regardless of width parity.
    """

    layer: kdb.LayerInfo
    section_min: dbu
    section_max: dbu
    sections: tuple[CrossSectionLayer, ...] = ()
    name: str = ""
    radius: dbu | None = None
    radius_min: dbu | None = None
    bbox_sections: dict[kdb.LayerInfo, dbu] = Field(default_factory=dict)

    @model_validator(mode="before")
    @classmethod
    def _normalize(cls, data: Any) -> Any:
        if not isinstance(data, dict):
            return data
        sections = data.get("sections", ())
        coerced: list[CrossSectionLayer] = []
        for s in sections:
            if isinstance(s, CrossSectionLayer):
                coerced.append(s)
            else:
                coerced.append(CrossSectionLayer.model_validate(s))
        data["sections"] = _normalize_sections(coerced)
        if not data.get("name"):
            data["name"] = _asym_auto_name(
                data["layer"],
                data["section_min"],
                data["section_max"],
                data["sections"],
                data.get("bbox_sections") or {},
            )
        return data

    def auto_name(self) -> str:
        """Deterministic structural name (hash of geometry, excluding radius)."""
        return _asym_auto_name(
            self.layer,
            self.section_min,
            self.section_max,
            self.sections,
            self.bbox_sections,
        )

    @property
    def is_named(self) -> bool:
        """Whether an explicit name was given (vs. the derived structural name)."""
        return self.name != self.auto_name()

    @model_validator(mode="after")
    def _validate(self) -> Self:
        if self.section_min >= self.section_max:
            raise ValueError(
                "section_min must be strictly less than section_max"
                f" (got section_min={self.section_min},"
                f" section_max={self.section_max})."
            )
        return self

    @property
    def width(self) -> int:
        """Main strip width in dbu (`section_max - section_min`)."""
        return self.section_max - self.section_min

    @property
    def main_layer(self) -> kdb.LayerInfo:
        """Main layer of the cross section (parity with SymmetricalCrossSection)."""
        return self.layer

    def to_dtype(self, kcl: KCLayout) -> DAsymmetricalCrossSection:
        return DAsymmetricalCrossSection(
            layer=self.layer,
            section_min=kcl.to_um(self.section_min),
            section_max=kcl.to_um(self.section_max),
            sections=tuple(
                DCrossSectionLayer(
                    layer=s.layer,
                    section_min=kcl.to_um(s.section_min),
                    section_max=kcl.to_um(s.section_max),
                )
                for s in self.sections
            ),
            name=self.name,
            radius=kcl.to_um(self.radius),
            radius_min=kcl.to_um(self.radius_min),
            bbox_sections={k: kcl.to_um(v) for k, v in self.bbox_sections.items()},
        )

    def is_symmetric(self) -> bool:
        """Whether this cross section is symmetric."""
        return False

    def get_sections(self) -> tuple[CrossSectionLayer, ...]:
        """Absolute signed dbu strips of the realised profile, main strip first.

        The counterpart of `SymmetricalCrossSection.get_sections`: here the
        strips are already absolute, so this is the main strip followed by the
        normalized `sections`.
        """
        return (
            CrossSectionLayer(
                layer=self.layer,
                section_min=self.section_min,
                section_max=self.section_max,
            ),
            *self.sections,
        )

    def _all_strips(self) -> tuple[tuple[int, int], ...]:
        """Return (section_min, section_max) for main + every aux section."""
        return (
            (self.section_min, self.section_max),
            *((s.section_min, s.section_max) for s in self.sections),
        )

    def get_xmin(self) -> int:
        return min(lo for lo, _ in self._all_strips())

    def get_xmax(self) -> int:
        return max(hi for _, hi in self._all_strips())

    def model_copy(
        self, *, update: Mapping[str, Any] | None = {"name": None}, deep: bool = False
    ) -> AsymmetricalCrossSection:
        return super().model_copy(update=update, deep=deep)

    def __eq__(self, o: object) -> bool:
        if isinstance(o, (SymmetricalCrossSection, TCrossSection)):
            return False
        if isinstance(o, TAsymmetricCrossSection):
            return self == o.base
        if isinstance(o, AsymmetricalCrossSection):
            # radius/radius_min are non-identifying metadata.
            return (
                self.layer == o.layer
                and self.section_min == o.section_min
                and self.section_max == o.section_max
                and self.sections == o.sections
                and self.name == o.name
                and self.bbox_sections == o.bbox_sections
            )
        return NotImplemented

    def __hash__(self) -> int:
        return hash(
            (
                self.layer,
                self.section_min,
                self.section_max,
                self.sections,
                self.name,
                tuple(sorted(self.bbox_sections.items(), key=lambda kv: kv[0].name)),
            )
        )

    def _sort_key(
        self,
    ) -> tuple[
        str, int, int, int, int, tuple[tuple[str, int, int, int, int], ...], str
    ]:
        return (
            self.layer.name,
            self.layer.layer,
            self.layer.datatype,
            self.section_min,
            self.section_max,
            tuple(s._sort_key() for s in self.sections),
            self.name,
        )

    def __lt__(self, other: object) -> bool:
        if not isinstance(other, AsymmetricalCrossSection):
            return NotImplemented
        return self._sort_key() < other._sort_key()

    def __le__(self, other: object) -> bool:
        if not isinstance(other, AsymmetricalCrossSection):
            return NotImplemented
        return self._sort_key() <= other._sort_key()

    def __gt__(self, other: object) -> bool:
        if not isinstance(other, AsymmetricalCrossSection):
            return NotImplemented
        return self._sort_key() > other._sort_key()

    def __ge__(self, other: object) -> bool:
        if not isinstance(other, AsymmetricalCrossSection):
            return NotImplemented
        return self._sort_key() >= other._sort_key()

class CrossSection(TCrossSection[int]):
    def add_bbox(
        self,
        c: KCell | DKCell | VKCell,
        ref: kdb.LayerInfo
        | int
        | kdb.Box
        | kdb.DBox
        | ProtoInstance[Any]
        | None = None,
        *,
        top: int | None = None,
        bottom: int | None = None,
        right: int | None = None,
        left: int | None = None,
    ) -> None:
        """Draw bbox_sections using padding in integer dbu.

        Args:
            c: Target KCell, DKCell, or VKCell, including subclasses. Must share
                this cross section's KCLayout, as must any instance reference.
            ref: None for the whole target, a layer/index in c, an explicit
                Box (dbu) or DBox (micrometers), or an instance's transformed
                bounds in c's coordinate system. Cell references are not accepted.
            top: Top padding override for every bbox layer.
            bottom: Bottom padding override for every bbox layer.
            right: Right padding override for every bbox layer.
            left: Left padding override for every bbox layer.

        None padding uses each layer's stored offset; zero suppresses padding.
        Real targets use integer geometry; VKCell targets use micrometers.
        All layers use the same original bounds. Empty references draw nothing;
        neither the cross section nor the reference box is modified.

        Warning:
            Logs a warning when a non-VKCell target has pending virtual instances,
            even with an explicit reference. Call insert_vinsts() first to avoid
            inaccurate geometry. This method does not materialize instances.

        Raises:
            LockedError: The target cell is locked.
            TypeError: The target or reference type is unsupported.
            ValueError: The target or instance reference uses another KCLayout.
        """
        from .kcell import DKCell, KCell, VKCell

        if not isinstance(c, KCell | DKCell | VKCell):
            raise TypeError("The bbox target must be a KCell, DKCell, or VKCell")
        if c.kcl is not self.kcl:
            raise ValueError(
                "The cross section and target must share the same KCLayout"
            )
        if c.locked:
            raise LockedError(c)
        if isinstance(c, VKCell):
            self.to_dtype().add_bbox(
                c,
                ref,
                top=self.kcl.to_um(top),
                bottom=self.kcl.to_um(bottom),
                right=self.kcl.to_um(right),
                left=self.kcl.to_um(left),
            )
            return
        bbox = _bbox_reference(c, ref)
        _add_bbox(
            c,
            bbox if isinstance(bbox, kdb.Box) else self.kcl.to_dbu(bbox),
            {
                self.kcl.layer(layer): offset
                for layer, offset in self.bbox_sections.items()
            },
            top=top,
            bottom=bottom,
            right=right,
            left=left,
        )

    @overload
    def __init__(self, kcl: KCLayout, *, base: SymmetricalCrossSection) -> None: ...

    @overload
    def __init__(
        self,
        kcl: KCLayout,
        width: int,
        layer: kdb.LayerInfo,
        sections: Sequence[tuple[kdb.LayerInfo, int, int] | tuple[kdb.LayerInfo, int]],
        radius: int | None = None,
        radius_min: int | None = None,
        name: str | None = None,
        bbox_layers: Sequence[kdb.LayerInfo] | None = None,
        bbox_offsets: Sequence[int] | None = None,
    ) -> None: ...

    def __init__(
        self,
        kcl: KCLayout,
        width: int | None = None,
        layer: kdb.LayerInfo | None = None,
        sections: Sequence[tuple[kdb.LayerInfo, int, int] | tuple[kdb.LayerInfo, int]]
        | None = None,
        radius: int | None = None,
        radius_min: int | None = None,
        name: str | None = None,
        bbox_layers: Sequence[kdb.LayerInfo] | None = None,
        bbox_offsets: Sequence[int] | None = None,
        base: SymmetricalCrossSection | None = None,
    ) -> None:
        if not base:
            if bbox_layers:
                if not bbox_offsets:
                    bbox_offsets = [0 for _ in range(len(bbox_layers))]
                elif len(bbox_offsets) != len(bbox_layers):
                    raise ValueError(
                        "Length of the bbox_layers list and the bbox_offsets list"
                        " must be the same "
                        f"{len(bbox_layers)=}, {len(bbox_offsets)=}"
                    )
            else:
                bbox_layers = []
                bbox_offsets = []
            if width is None or layer is None or sections is None:
                raise ValueError(
                    "If no base is given, width, layer, and sections must be defined"
                )
            base = kcl.get_symmetrical_cross_section(
                SymmetricalCrossSection(
                    width=width,
                    enclosure=LayerEnclosure(
                        sections=sections,
                        main_layer=layer,
                        bbox_sections=list(
                            zip(bbox_layers, bbox_offsets)  # noqa: B905
                        ),
                    ),
                    name=name,
                    radius=radius,
                    radius_min=radius_min,
                )
            )
        self.kcl = kcl
        self._base = base

    @property
    def sections(self) -> dict[kdb.LayerInfo, list[tuple[int | None, int]]]:
        items = self._base.enclosure.layer_sections.items()
        return {
            layer: [(section.d_min, section.d_max) for section in sections.sections]
            for layer, sections in items
        }

    def get_sections(self) -> tuple[CrossSectionLayer, ...]:
        """Absolute signed dbu strips of the realised profile, main strip first.

        Unlike `sections`, which returns the enclosure's edge-relative bands,
        this resolves them against the core width and includes the main strip.
        """
        return self._base.get_sections()

    @property
    def bbox_sections(self) -> dict[kdb.LayerInfo, int]:
        return self._base.bbox_sections.copy()

    @property
    def width(self) -> int:
        return self._base.width

    @property
    def radius(self) -> int | None:
        return self._base.radius

    @property
    def radius_min(self) -> int | None:
        return self._base.radius_min

    def get_xmin_xmax(self) -> tuple[int, int]:
        return (self._base.get_xmin(), self._base.get_xmax())

    def model_copy(
        self, *, update: Mapping[str, Any] = {"name": None}, deep: bool
    ) -> CrossSection:
        return CrossSection(
            kcl=self.kcl, base=self.base.model_copy(update=update, deep=deep)
        )

class CrossSectionLayer(BaseModel, frozen=True, arbitrary_types_allowed=True):
    """Single strip in an asymmetrical cross section.

    A strip on `layer` spanning `[section_min, section_max]` in dbu relative to
    the port centerline (`offset=0`). Both bounds are signed integer dbu, so
    edges are always grid-aligned. The strip's width is the derived
    `section_max - section_min`.
    """

    layer: kdb.LayerInfo
    section_min: dbu
    section_max: dbu

    @model_validator(mode="after")
    def _validate_bounds(self) -> Self:
        if self.section_min >= self.section_max:
            raise ValueError(
                "section_min must be strictly less than section_max (got"
                f" section_min={self.section_min},"
                f" section_max={self.section_max})."
            )
        return self

    @property
    def width(self) -> int:
        """Width of the strip in dbu (`section_max - section_min`)."""
        return self.section_max - self.section_min

    def _sort_key(self) -> tuple[str, int, int, int, int]:
        return (
            self.layer.name,
            self.layer.layer,
            self.layer.datatype,
            self.section_min,
            self.section_max,
        )

    def __lt__(self, other: object) -> bool:
        if not isinstance(other, CrossSectionLayer):
            return NotImplemented
        return self._sort_key() < other._sort_key()

    def __le__(self, other: object) -> bool:
        if not isinstance(other, CrossSectionLayer):
            return NotImplemented
        return self._sort_key() <= other._sort_key()

    def __gt__(self, other: object) -> bool:
        if not isinstance(other, CrossSectionLayer):
            return NotImplemented
        return self._sort_key() > other._sort_key()

    def __ge__(self, other: object) -> bool:
        if not isinstance(other, CrossSectionLayer):
            return NotImplemented
        return self._sort_key() >= other._sort_key()

class CrossSectionModel(BaseModel):
    cross_sections: dict[str, SymmetricalCrossSection | AsymmetricalCrossSection] = (
        Field(default_factory=dict)
    )
    kcl: KCLayout

    def __getitem__(
        self, name: str
    ) -> SymmetricalCrossSection | AsymmetricalCrossSection:
        return self.cross_sections[name]

    def get_asymmetrical_cross_section(
        self,
        cross_section: str | AsymmetricalCrossSection | DAsymmetricalCrossSection,
    ) -> AsymmetricalCrossSection:
        if isinstance(cross_section, str):
            xs = self.cross_sections[cross_section]
            if not isinstance(xs, AsymmetricalCrossSection):
                raise TypeError(
                    f"Cross section {cross_section!r} is symmetric; use "
                    "get_(symmetrical_)cross_section."
                )
            return xs
        if isinstance(cross_section, DAsymmetricalCrossSection):
            cross_section = cross_section.to_itype(self.kcl)
        registered = self._register(cross_section)
        assert isinstance(registered, AsymmetricalCrossSection)
        return registered

    def _register(
        self, cross_section: SymmetricalCrossSection | AsymmetricalCrossSection
    ) -> SymmetricalCrossSection | AsymmetricalCrossSection:
        """Register/resolve a cross section by its canonical (structural) name.

        Entries are keyed by their `auto_name()` and, when named, additionally by
        the explicit name. Existence is a single `get(auto_name())`.
        """
        auto = cross_section.auto_name()
        canonical = self.cross_sections.get(auto)
        if canonical is None:
            if cross_section.is_named and cross_section.name in self.cross_sections:
                raise CrossSectionNamingConflictError(
                    f"Cross section name {cross_section.name!r} is already "
                    "registered for a different structural signature."
                )
            self.cross_sections[auto] = cross_section
            if cross_section.is_named:
                self.cross_sections[cross_section.name] = cross_section
            return cross_section
        if not cross_section.is_named:
            return _resolve_radius(canonical, cross_section)
        if canonical.is_named:
            if canonical.name == cross_section.name:
                return _resolve_radius(canonical, cross_section)
            raise CrossSectionNamingConflictError(
                f"Cannot register cross section {cross_section.name!r}: the same "
                f"structural signature is already registered as {canonical.name!r}."
                " A structure can have at most one name."
            )
        # Promote the unnamed canonical to the named one (radius must match).
        _resolve_radius(canonical, cross_section)
        self.cross_sections[auto] = cross_section
        self.cross_sections[cross_section.name] = cross_section
        return cross_section

    def get_cross_section(
        self,
        cross_section: str
        | SymmetricalCrossSection
        | DSymmetricalCrossSection
        | CrossSectionSpecDict
        | DCrossSectionSpecDict
        | CrossSection
        | DCrossSection,
    ) -> SymmetricalCrossSection:
        if isinstance(cross_section, str):
            xs = self.cross_sections[cross_section]
            if not isinstance(xs, SymmetricalCrossSection):
                raise TypeError(
                    f"Cross section {cross_section!r} is asymmetric; use "
                    "get_asymmetrical_cross_section."
                )
            return xs
        if isinstance(cross_section, TCrossSection):
            cross_section = cross_section.base
        if isinstance(cross_section, SymmetricalCrossSection):
            canonical_enc = self.kcl.get_enclosure(cross_section.enclosure)
            if cross_section.enclosure != canonical_enc:
                return self.get_cross_section(
                    SymmetricalCrossSection(
                        enclosure=canonical_enc,
                        # Preserve named/unnamed provenance: re-derive the auto
                        # name from the canonical enclosure when unnamed.
                        name=cross_section.name if cross_section.is_named else None,
                        width=cross_section.width,
                        radius=cross_section.radius,
                        radius_min=cross_section.radius_min,
                    )
                )
        elif isinstance(cross_section, DSymmetricalCrossSection):
            cross_section = cross_section.to_itype(self.kcl)

        elif cross_section.get("unit", "dbu") == "dbu":
            cross_section = SymmetricalCrossSection(
                width=cross_section["width"],  # ty:ignore[invalid-argument-type]
                enclosure=self.kcl.layer_enclosures.get_enclosure(
                    LayerEnclosureSpec(
                        sections=cross_section.get("sections", []),  # ty:ignore[invalid-argument-type]
                        main_layer=cross_section["layer"],
                        name=cross_section.get("enclosure", {}).get("name"),
                    ),
                    kcl=self.kcl,
                ),
                name=cross_section.get("name", None),
            )
        else:
            cross_section = SymmetricalCrossSection(
                width=self.kcl.to_dbu(cross_section["width"]),
                enclosure=self.kcl.layer_enclosures.get_enclosure(
                    LayerEnclosureSpec(
                        sections=[
                            (section[0], self.kcl.to_dbu(section[1]))
                            if len(section) == 2
                            else (
                                section[0],
                                self.kcl.to_dbu(section[1]),
                                self.kcl.to_dbu(section[2]),
                            )
                            for section in cross_section.get("sections", [])
                        ],
                        main_layer=cross_section["layer"],
                        name=cross_section.get("enclosure", {}).get("name"),
                    ),
                    kcl=self.kcl,
                ),
                name=cross_section.get("name", None),
            )
        registered = self._register(cross_section)
        assert isinstance(registered, SymmetricalCrossSection)
        return registered

    def __repr__(self) -> str:
        return repr(self.cross_sections)

class DAsymmetricCrossSection(TAsymmetricCrossSection[float]):
    """um-flavored wrapper around an `AsymmetricalCrossSection`."""

    def add_bbox(
        self,
        c: KCell | DKCell | VKCell,
        ref: kdb.LayerInfo
        | int
        | kdb.Box
        | kdb.DBox
        | ProtoInstance[Any]
        | None = None,
        *,
        top: float | None = None,
        bottom: float | None = None,
        right: float | None = None,
        left: float | None = None,
    ) -> None:
        """Draw bbox_sections using padding in micrometers.

        Args:
            c: Target KCell, DKCell, or VKCell, including subclasses. Must share
                this cross section's KCLayout, as must any instance reference.
            ref: None for the whole target, a layer/index in c, an explicit
                Box (dbu) or DBox (micrometers), or an instance's transformed
                bounds in c's coordinate system. Cell references are not accepted.
            top: Top padding override for every bbox layer.
            bottom: Bottom padding override for every bbox layer.
            right: Right padding override for every bbox layer.
            left: Left padding override for every bbox layer.

        None padding uses each layer's stored offset; zero suppresses padding.
        Real targets use integer geometry; VKCell targets use micrometers.
        All layers use the same original bounds. Empty references draw nothing;
        neither the cross section nor the reference box is modified.

        Warning:
            Logs a warning when a non-VKCell target has pending virtual instances,
            even with an explicit reference. Call insert_vinsts() first to avoid
            inaccurate geometry. This method does not materialize instances.

        Raises:
            LockedError: The target cell is locked.
            TypeError: The target or reference type is unsupported.
            ValueError: The target or instance reference uses another KCLayout.
        """
        from .kcell import DKCell, KCell, VKCell

        if not isinstance(c, KCell | DKCell | VKCell):
            raise TypeError("The bbox target must be a KCell, DKCell, or VKCell")
        if c.kcl is not self.kcl:
            raise ValueError(
                "The cross section and target must share the same KCLayout"
            )
        if c.locked:
            raise LockedError(c)
        if isinstance(c, KCell | DKCell):
            self.to_itype().add_bbox(
                c,
                ref,
                top=self.kcl.to_dbu(top),
                bottom=self.kcl.to_dbu(bottom),
                right=self.kcl.to_dbu(right),
                left=self.kcl.to_dbu(left),
            )
            return
        bbox = _bbox_reference(c, ref)
        _add_bbox_virtual(
            c,
            bbox if isinstance(bbox, kdb.DBox) else self.kcl.to_um(bbox),
            {
                self.kcl.layer(layer): offset
                for layer, offset in self.bbox_sections.items()
            },
            top=top,
            bottom=bottom,
            right=right,
            left=left,
        )

    @overload
    def __init__(self, kcl: KCLayout, *, base: AsymmetricalCrossSection) -> None: ...

    @overload
    def __init__(
        self,
        kcl: KCLayout,
        section_min: float,
        section_max: float,
        layer: kdb.LayerInfo,
        sections: Sequence[DCrossSectionLayer] = (),
        name: str | None = None,
        radius: float | None = None,
        radius_min: float | None = None,
        bbox_sections: dict[kdb.LayerInfo, float] | None = None,
    ) -> None: ...

    def __init__(
        self,
        kcl: KCLayout,
        section_min: float | None = None,
        section_max: float | None = None,
        layer: kdb.LayerInfo | None = None,
        sections: Sequence[DCrossSectionLayer] = (),
        name: str | None = None,
        radius: float | None = None,
        radius_min: float | None = None,
        bbox_sections: dict[kdb.LayerInfo, float] | None = None,
        base: AsymmetricalCrossSection | None = None,
    ) -> None:
        if base is None:
            if section_min is None or section_max is None or layer is None:
                raise ValueError(
                    "If no base is given, section_min, section_max, and layer"
                    " must be defined"
                )
            base = kcl.get_asymmetrical_cross_section(
                DAsymmetricalCrossSection(
                    layer=layer,
                    section_min=section_min,
                    section_max=section_max,
                    sections=tuple(sections),
                    name=name,
                    radius=radius,
                    radius_min=radius_min,
                    bbox_sections=bbox_sections or {},
                ).to_itype(kcl)
            )
        self.kcl = kcl
        self._base = base

    @property
    def width(self) -> float:
        return self.kcl.to_um(self._base.width)

    @property
    def section_min(self) -> float:
        return self.kcl.to_um(self._base.section_min)

    @property
    def section_max(self) -> float:
        return self.kcl.to_um(self._base.section_max)

    @property
    def sections(self) -> tuple[DCrossSectionLayer, ...]:
        return _to_dsections(self.kcl, self._base.sections)

    def get_sections(self) -> tuple[DCrossSectionLayer, ...]:
        """Absolute signed um strips of the realised profile, main strip first."""
        return _to_dsections(self.kcl, self._base.get_sections())

    @property
    def radius(self) -> float | None:
        return self.kcl.to_um(self._base.radius)

    @property
    def radius_min(self) -> float | None:
        return self.kcl.to_um(self._base.radius_min)

    @property
    def bbox_sections(self) -> dict[kdb.LayerInfo, float]:
        return {k: self.kcl.to_um(v) for k, v in self._base.bbox_sections.items()}

    def get_xmin_xmax(self) -> tuple[float, float]:
        return (
            self.kcl.to_um(self._base.get_xmin()),
            self.kcl.to_um(self._base.get_xmax()),
        )