ea 0.6.106 → 0.6.108

data/lib/ea/svg/ea_emitter/connector_redock.rb

@@ -53,10 +53,10 @@ module Ea
             return stored_top_pairs(connector, source_bounds, pairs)
           end
 
-          # EA docks these markers on the outer edge of the 2px box stroke.
-          outline = bounds.map do |box|
-            Ea::Model::Bounds.new(x: box.x - 1, y: box.y - 1,
-                                  width: box.width + 2, height: box.height + 2)
+          refs = [source_ref, target_ref]
+          duids = connector.style.to_h.values_at(:soid, :eoid)
+          outline = bounds.each_with_index.map do |box, index|
+            outline_bounds(box, diagram, refs[index], duids[index])
           end
           candidate = clipped_pairs(outline, anchors)
           candidate[0] = external_source_point(connector, outline.first, anchors, candidate.first)
@@ -231,19 +231,34 @@ module Ea
           return false unless bounds.all? { |box| box.width.positive? && box.height.positive? }
 
           ends = [[refs.first, style[:soid]], [refs.last, style[:eoid]]]
-          ends.all? { |ref, duid| border_two?(diagram, ref, duid) }
+          ends.all? { |ref, duid| border_width?(diagram, ref, duid, 2) }
         end
         private_class_method :bordered_outline?
 
         # Every placement of the element (the DUID-matched one when the
-        # connector names it) must declare a border width of 2.
-        def border_two?(diagram, ref, duid)
+        # connector names it) must declare the same border width.
+        def border_width?(diagram, ref, duid, width)
+          placed = end_placements(diagram, ref, duid)
+          placed.any? && placed.all? { |el| el.line_width == width || el.style.to_h[:lwth] == width.to_s }
+        end
+        private_class_method :border_width?
+
+        # Explicit zero-width borders keep that end on the geometric edge;
+        # absent or inherited widths retain the default outer-stroke docking.
+        def outline_bounds(box, diagram, ref, duid)
+          return box if border_width?(diagram, ref, duid, 0)
+
+          Ea::Model::Bounds.new(x: box.x - 1, y: box.y - 1,
+                                width: box.width + 2, height: box.height + 2)
+        end
+        private_class_method :outline_bounds
+
+        def end_placements(diagram, ref, duid)
           placed = Array(diagram&.elements).select { |el| el.model_element_ref == ref }
           named = placed.select { |el| duid && el.duid.to_s.casecmp?(duid.to_s) }
-          placed = named unless named.empty?
-          placed.any? && placed.all? { |el| el.line_width == 2 || el.style.to_h[:lwth] == "2" }
+          named.empty? ? placed : named
         end
-        private_class_method :border_two?
+        private_class_method :end_placements
 
         def outline_connector?(connector, bounds)
           return true if default_model_connector?(connector)
@@ -397,12 +412,13 @@ module Ea
         end
         private_class_method :explicit_horizontal_source_dock?
 
-        # A stored Association ray whose source port certifies the shared
-        # anchor row is one explicit horizontal line: EA seats neither end
-        # in a compartment row, unlike Generalization/Aggregation targets.
+        # The QEA producer certifies stored Association rays from their
+        # endpoint origins. Keep the clipped ray even when a diagonal end
+        # coincides with a header divider. Other callers need a certified
+        # horizontal port before bypassing compartment row seating.
         def explicit_association_ray?(pairs, connector)
           produced = connector.style.to_h[:stored_association_ray] == true
-          return true if produced && pairs.first[1] == pairs.last[1]
+          return true if produced
 
           certified_association_ray?(pairs, connector)
         end

data/lib/ea/svg/ea_emitter/element/attribute_line_builder.rb

@@ -48,6 +48,7 @@ module Ea
             parts << ": #{type_str}" unless type_str.empty?
             mult = multiplicity
             parts << " #{mult}" unless mult.empty?
+            parts << " {ordered}" if property.is_ordered
             parts << " = #{property.default_value}" if property.default_value && !property.default_value.to_s.empty?
             parts.join.rstrip
           end
@@ -100,20 +101,21 @@ module Ea
           def multiplicity
             lower = property.multiplicity_lower
             upper = property.multiplicity_upper
-            if lower == 1 && upper == 1
-              raw = property.multiplicity_lower_raw
-              # Literal text bounds EA displays verbatim ('elements:
-              # Character [size]' - stored bounds 'size'/'size' parse
-              # to the 1..1 default).
-              return "[#{raw}]" if raw && raw == property.multiplicity_upper_raw
-
-              return ""
-            end
+            return default_multiplicity if lower == 1 && upper == 1
             return "" if lower.nil? && upper.nil?
+            return "[#{lower}]" if lower == upper && upper != -1
 
             "[#{lower || 0}..#{bound_text(upper)}]"
           end
 
+          # Literal text bounds EA displays verbatim ('elements:
+          # Character [size]' - stored bounds 'size'/'size' parse
+          # to the 1..1 default).
+          def default_multiplicity
+            raw = property.multiplicity_lower_raw
+            raw && raw == property.multiplicity_upper_raw ? "[#{raw}]" : ""
+          end
+
           def bound_text(value)
             # EA renders a stored literal bound ("n") verbatim, and a
             # computed-unbounded upper as "*" (verified against

data/lib/ea/svg/ea_emitter/element/attribute_renderer.rb

@@ -47,12 +47,14 @@ module Ea
           end
 
           def self.render(lines, bounds:, first_y:, family:,
-                          size:, size_unit: DEFAULT_FONT_UNIT,
+                          size:, size_unit: DEFAULT_FONT_UNIT, logical_height: nil,
                           fill: "#000000",
                           visibility_x_offset: DEFAULT_VISIBILITY_X_OFFSET,
                           content_x_offset: nil)
 
-            line_h = size + ROW_LINE_OFFSET
+            line_h = Ea::Fonts::Metrics.compartment_line_height(
+              size, family: family, unit: size_unit, offset: ROW_LINE_OFFSET, logical_height: logical_height
+            )
             offsets = group_lead_offsets(lines)
             text_blocks = []
             lines.each_with_index do |line, idx|
@@ -60,15 +62,27 @@ module Ea
               visibility, rest = split_visibility(line)
               if visibility
                 unless visibility.strip.empty?
-                  text_blocks << build_text(bounds.x + visibility_x_offset, y, visibility, family, size, size_unit, fill)
+                  text_blocks << build_text(
+                    bounds.x + visibility_x_offset, y, visibility, family, size, size_unit, fill,
+                    logical_height: logical_height
+                  )
                 end
                 offset = (content_x_offset || DEFAULT_CONTENT_X_OFFSET) +
                          2 * (size - 7)
-                text_blocks << build_text(bounds.x + offset, y, rest, family, size, size_unit, fill)
+                offset -= 1 if Ea::Fonts::Metrics.compact_compartment_font?(size, family: family, unit: size_unit)
+                text_blocks << build_text(
+                  bounds.x + offset, y, rest, family, size, size_unit, fill, logical_height: logical_height
+                )
               elsif line.strip.start_with?("«")
-                text_blocks << build_text(bounds.x + STEREOTYPE_HEADER_X_OFFSET, y, line.strip, family, size, size_unit, fill)
+                text_blocks << build_text(
+                  bounds.x + STEREOTYPE_HEADER_X_OFFSET, y, line.strip, family, size, size_unit, fill,
+                  logical_height: logical_height
+                )
               else
-                text_blocks << build_text(bounds.x + visibility_x_offset, y, line.strip, family, size, size_unit, fill)
+                text_blocks << build_text(
+                  bounds.x + visibility_x_offset, y, line.strip, family, size, size_unit, fill,
+                  logical_height: logical_height
+                )
               end
             end
             group_style = "stroke-width:1;stroke-linecap:round;stroke-linejoin:bevel; fill:#{fill};fill-opacity:1.00; stroke:#000000; stroke-opacity:0.00"
@@ -87,7 +101,7 @@ module Ea
           # Pass a `lookup` (any callable returning a Classifier for
           # an id) to enable inherited-property namespace prefixing.
           def self.lines_for(classifier, lookup: nil,
-                            exclude_association_ids: nil)
+                             exclude_association_ids: nil, stored_order: false)
             props = displayable_properties(classifier, exclude_association_ids)
             return [] unless props
 
@@ -95,19 +109,14 @@ module Ea
             if stereotypes.size == 1 && props.all? { |p| property_stereotype(p) }
               # EA renders ONE compartment stereotype header for a
               # uniformly-stereotyped attribute set (e.g. «Property»
-              # above GML property rows) and lists rows
-              # alphabetically - verified against EA-published SVGs.
+              # above GML property rows).
               header = "«#{canonical_stereotype(stereotypes.first)}»"
-              [header] + props.sort_by { |p| p.name.to_s }.map do |prop|
+              [header] + ordered_properties(props, stored_order, case_sensitive: true).map do |prop|
                 AttributeLineBuilder.new(prop, host: classifier,
                                          lookup: lookup).to_s
               end
             else
-              # EA lists attribute rows alphabetically (case-
-              # insensitive) — corpus-verified: 991 boxes strictly
-              # alphabetical vs 24 strictly stored-Pos order.
-              props.sort_by { |p| [p.name.to_s.downcase, p.name.to_s] }
-                   .flat_map do |prop|
+              ordered_properties(props, stored_order).flat_map do |prop|
                 lines = []
                 stereotype = property_stereotype(prop)
                 lines << "«#{stereotype}»" if stereotype
@@ -117,6 +126,20 @@ module Ea
             end
           end
 
+          # QEA properties arrive in stored Pos order. Association ends retain
+          # their alphabetical fallback rather than using connector Pos values.
+          def self.ordered_properties(props, stored_order, case_sensitive: false)
+            alphabetical = lambda do |prop|
+              name = prop.name.to_s
+              case_sensitive ? [name] : [name.downcase, name]
+            end
+            return props.sort_by(&alphabetical) unless stored_order
+
+            own, ends = props.partition { |prop| !prop.association_id }
+            own + ends.sort_by(&alphabetical)
+          end
+          private_class_method :ordered_properties
+
           STEREOTYPE_DISPLAY = {
             "property" => "Property",
             "featuretype" => "FeatureType",
@@ -140,9 +163,11 @@ module Ea
           end
           private_class_method :split_visibility
 
-          def self.build_text(x, y, content, family, size, size_unit = DEFAULT_FONT_UNIT, fill = "#000000")
+          def self.build_text(x, y, content, family, size, size_unit = DEFAULT_FONT_UNIT,
+                              fill = "#000000", logical_height: nil)
             TextRenderer.new(content: content, x: x, y: y,
-                              family: family, size: size, size_unit: size_unit, fill: fill).to_svg
+                             family: family, size: size, size_unit: size_unit,
+                             logical_height: logical_height, fill: fill).to_svg
           end
           private_class_method :build_text
 

data/lib/ea/svg/ea_emitter/element/compartment_geometry.rb

@@ -40,10 +40,14 @@ module Ea
                           attr_line_offset: 6,
                           attr_first_offset: 7,
                           attr_group_lead: 0,
+                         family: nil, size_unit: "pt", logical_height: nil,
                           header_ghost: false,
                           header_ghost_tight: false)
             @bounds = bounds
             @size = size
+            @family = family
+            @size_unit = size_unit
+            @logical_height = logical_height
             @header_lines_count = header_lines_count
             @attr_lines_count = attr_lines_count
             @op_lines_count = op_lines_count
@@ -61,6 +65,13 @@ module Ea
             @header_ghost_tight = header_ghost_tight
           end
 
+          def line_height(offset)
+            Ea::Fonts::Metrics.compartment_line_height(
+              size, family: @family, unit: @size_unit, offset: offset, logical_height: @logical_height
+            )
+          end
+          private :line_height
+
           def header_first_y
             bounds.y + size + (header_top_padding || 12)
           end
@@ -81,9 +92,9 @@ module Ea
             ghost_shift = header_ghost ? (header_ghost_tight ? 3 : 6) : 0
 
             header_first_y +
-              ([header_lines_count, 1].max - 1) * (size + (header_line_offset || 6)) +
+              ([header_lines_count, 1].max - 1) * line_height(header_line_offset || 6) +
               ghost_shift +
-              (marker_count.to_i * (size + 6)) +
+              (marker_count.to_i * line_height(6)) +
               (divider_offset || 8)
           end
 
@@ -104,13 +115,13 @@ module Ea
           def raw_attr_first_y
             return bounds.y + size + (header_top_padding || 12) + 12 unless divider_y
 
-            divider_y + size + (attr_first_offset || 7)
+            divider_y + line_height((attr_first_offset || 7) - 1) + 1
           end
 
           def attr_bottom_y
             return attr_first_y unless attr_lines_count&.positive?
 
-            attr_first_y + (attr_lines_count - 1) * (size + (attr_line_offset || 6)) +
+            attr_first_y + (attr_lines_count - 1) * line_height(attr_line_offset || 6) +
               @attr_group_lead.to_i
           end
 
@@ -137,7 +148,7 @@ module Ea
           def op_bottom_y
             return op_divider_y unless op_lines_count&.positive?
 
-            op_first_y + (op_lines_count - 1) * (size + 6)
+            op_first_y + (op_lines_count - 1) * line_height(6)
           end
 
           # EA draws a single divider under the header and seats
@@ -147,17 +158,33 @@ module Ea
           def enum_literal_first_y
             return nil unless divider_y
 
-            divider_y + size + (attr_first_offset || 7)
+            divider_y + line_height((attr_first_offset || 7) - 1) + 1
+          end
+
+          # OCL constraints follow the regular content with a divider and caption.
+          # Suppress the whole compartment when its last row cannot fit.
+          def constraints_first_y
+            return nil unless constraints_count.to_i.positive?
+
+            first_y = constraints_caption_y
+            first_y if first_y + constraints_count * (size + 5) + 4 <= bounds.y + bounds.height
+          end
+
+          def constraints_caption_y
+            (regular_content_bottom_y || raw_attr_first_y) + size + 13
           end
 
-          # Tagged values appear after attributes (or after ops if
-          # present). EA does not emit a separate divider — the
-          # italic "tags" header marks the compartment. Constraints
-          # render ABOVE the attributes (constraints_first_y), not
-          # here.
+          def constraints_divider_y
+            constraints_first_y - size - 7 if constraints_first_y
+          end
+
+          def constraints_bottom_y
+            constraints_first_y + constraints_count * (size + 5) if constraints_first_y
+          end
+
+          # Tagged values follow the last visible content compartment.
           def tagged_value_first_y
-            return nil unless tagged_values_count.to_i.positive? ||
-                              constraints_count.to_i.positive?
+            return nil unless tagged_values_count.to_i.positive?
 
             (content_bottom_y || raw_attr_first_y) + size + 5
           end
@@ -169,6 +196,10 @@ module Ea
           # the autosize gate must not treat the empty-compartment
           # anchor as content.
           def content_bottom_y
+            [regular_content_bottom_y, constraints_bottom_y].compact.max
+          end
+
+          def regular_content_bottom_y
             bottoms = []
             bottoms << attr_bottom_y if attr_lines_count.to_i.positive?
             bottoms << enum_literals_bottom_y if enum_literals_count.to_i.positive?
@@ -179,10 +210,10 @@ module Ea
           def enum_literals_bottom_y
             return nil unless enum_literal_first_y
 
-            enum_literal_first_y + ([enum_literals_count, 1].max - 1) * (size + 6)
+            enum_literal_first_y + ([enum_literals_count, 1].max - 1) * line_height(6)
           end
         end
       end
     end
   end
-end
+end

data/lib/ea/svg/ea_emitter/element/constraint_renderer.rb

@@ -29,9 +29,41 @@ module Ea
             %(<g style="#{Style::TEXT_GROUP}">\n#{text_blocks.join("\n")}\n</g>)
           end
 
-          def self.build_text(x, y, content, family, size, fill)
+          def self.render_compartment(context)
+            rows = context.constraints.each_with_index.map do |constraint, idx|
+              compartment_row(constraint, context, idx)
+            end
+            %(<g style="#{Style::TEXT_GROUP}">\n#{([compartment_caption(context)] + rows).join("\n")}\n</g>)
+          end
+
+          def self.compartment_row(constraint, context, index)
+            build_text(context.bounds.x + 5,
+                       context.geometry.constraints_first_y + (index + 1) * (context.size + 5),
+                       "{#{constraint.name}}", context.family, context.size, context.text_fill,
+                       size_unit: context.size_unit, logical_height: context.logical_height)
+          end
+          private_class_method :compartment_row
+
+          def self.compartment_caption(context)
+            TextRenderer.new(content: "constraints", x: caption_x(context),
+                             y: context.geometry.constraints_first_y, family: context.family,
+                             size: context.size, size_unit: context.size_unit, logical_height: context.logical_height,
+                             fill: context.text_fill, style: "italic").to_svg
+          end
+          private_class_method :compartment_caption
+
+          def self.caption_x(context)
+            width = TextRenderer.estimate_width("constraints", context.size, nil,
+                                                family: context.family, style: "italic",
+                                                logical_height: context.logical_height).round
+            context.bounds.x + ((context.bounds.width - width) / 2).floor
+          end
+          private_class_method :caption_x
+
+          def self.build_text(x, y, content, family, size, fill, size_unit: "px", logical_height: nil)
             TextRenderer.new(content: content, x: x, y: y,
-                              family: family, size: size, fill: fill).to_svg
+                             family: family, size: size, size_unit: size_unit,
+                             logical_height: logical_height, fill: fill).to_svg
           end
           private_class_method :build_text
         end

data/lib/ea/svg/ea_emitter/element/enumeration_literal_renderer.rb

@@ -16,19 +16,22 @@ module Ea
           # EA lists literals alphabetically (case-insensitive) and
           # spaces rows at the same 13px pitch as attributes at 7pt
           # (size + 6) — corpus-verified against EA-published SVGs.
-          def self.render(literals, bounds:, first_y:, family:, size:)
-            line_h = size + 6
+          def self.render(literals, bounds:, first_y:, family:, size:, size_unit: "px", logical_height: nil)
+            line_h = Ea::Fonts::Metrics.compartment_line_height(
+              size, family: family, unit: size_unit, logical_height: logical_height
+            )
             sorted = literals.sort_by { |l| [l.name.to_s.downcase, l.name.to_s] }
             text_blocks = sorted.each_with_index.map do |literal, idx|
               y = first_y + (idx * line_h)
-              build_text(bounds.x + 5, y, literal.name.to_s, family, size)
+              build_text(bounds.x + 5, y, literal.name.to_s, family, size, size_unit, logical_height: logical_height)
             end
             %(<g style="#{Style::TEXT_GROUP}">\n#{text_blocks.join("\n")}\n</g>)
           end
 
-          def self.build_text(x, y, content, family, size)
+          def self.build_text(x, y, content, family, size, size_unit, logical_height: nil)
             TextRenderer.new(content: content, x: x, y: y,
-                              family: family, size: size).to_svg
+                             family: family, size: size, size_unit: size_unit,
+                             logical_height: logical_height).to_svg
           end
           private_class_method :build_text
         end

data/lib/ea/svg/ea_emitter/element/header_line_pipeline.rb

@@ -19,7 +19,7 @@ module Ea
         module HeaderLinePipeline
           Context = Struct.new(:classifier, :diagram_package_id,
                                :visually_nested, :umldi_keyword,
-                               :bounds_width, :font_size, :family,
+                               :bounds_width, :font_size, :family, :logical_height,
                                :off_canvas_parent_name,
                                :foreign_package_name,
                                :suppress_stereotypes,
@@ -57,7 +57,8 @@ module Ea
             width = lambda do |s|
               TextRenderer.estimate_width(
                 s, context.font_size || 9, nil,
-                family: context.family, weight: "700", style: font_style
+                family: context.family, weight: "700", style: font_style,
+                logical_height: context.logical_height
               ).round
             end
             return [text] if context.bounds_width.nil?

data/lib/ea/svg/ea_emitter/element/header_line_provider/instance_spec.rb

@@ -20,15 +20,20 @@ module Ea
               return [] unless inst.is_a?(Ea::Model::InstanceSpecification)
 
               lines = stereotype_lines(inst, context)
-              label = inst.name.to_s
-              if inst.classifier_name && !inst.classifier_name.empty?
-                label = "#{label}: #{inst.classifier_name}"
-              end
-              lines + HeaderLinePipeline.wrap_words(label, context, :bold).map do |line|
+              lines + HeaderLinePipeline.wrap_words(label_for(inst), context, :bold).map do |line|
                 [line, :bold]
               end
             end
 
+            # "Name / alias: Classifier"; t_object.Alias is the instance role.
+            def self.label_for(inst)
+              label = inst.name.to_s
+              label = "#{label} / #{inst.role_name}" unless inst.role_name.to_s.empty?
+              return label if inst.classifier_name.to_s.empty?
+
+              "#{label}: #{inst.classifier_name}"
+            end
+
             def self.stereotype_lines(inst, context)
               return [] if context.suppress_stereotypes
 

data/lib/ea/svg/ea_emitter/element/header_line_provider/name.rb

@@ -56,7 +56,8 @@ module Ea
               font_style = weight == :bold_italic ? "italic" : "normal"
               len = TextRenderer.estimate_width(
                 name, context.font_size || 9, nil,
-                family: context.family, weight: "700", style: font_style
+                family: context.family, weight: "700", style: font_style,
+                logical_height: context.logical_height
               ).round
               # Same usable width as wrap_words: box width - 6.
               # EA wraps "Content information::MD_FeatureCatalogue-

data/lib/ea/svg/ea_emitter/element/header_renderer.rb

@@ -12,17 +12,20 @@ module Ea
         # x= is the start position, not the center).
         class HeaderRenderer
           def self.render(lines, bounds:, first_y:, family:,
-                          size:, size_unit: "pt",
+                          size:, size_unit: "pt", logical_height: nil,
                           fill: "#000000", weight_normal: 400, weight_bold: 700,
                           stroke_in_text: "#000000", width_factor: 0.612,
                           line_offset: 6)
-            line_h = size + line_offset
+            logical_height = nil unless size_unit == "pt"
+            line_h = Ea::Fonts::Metrics.compartment_line_height(
+              size, family: family, unit: size_unit, offset: line_offset, logical_height: logical_height
+            )
             text_blocks = lines.each_with_index.map do |(text, style), idx|
               weight = case style
                        when :bold, :bold_italic then weight_bold
                        else weight_normal
                        end
-              font_style = (style == :italic || style == :bold_italic) ? "italic" : "normal"
+              font_style = %i[italic italic_tight bold_italic].include?(style) ? "italic" : "normal"
               # EA spaces the line AFTER a right-aligned ghost 3px
               # wider than the pitch. Interfaces use a tighter +3
               # (936AA434/Surface: ghost 100, «interface» 116).
@@ -33,23 +36,22 @@ module Ea
                             end
               y = first_y + (idx * line_h) +
                   (idx >= 1 && ghost_shift.positive? ? ghost_shift : 0)
-              x = if style == :italic
-                    # EA right-aligns the off-canvas parent ghost at
-                    # the box's right edge by its integer textLength.
-                    bounds.x + bounds.width -
+              x = if %i[italic italic_tight].include?(style)
+                    # Parent ghosts end 3px inside the box's right edge.
+                    bounds.x + bounds.width - 3 -
                       Ea::Svg::EaEmitter::TextRenderer.estimate_width(
                         text, size, width_factor,
-                        family: family, weight: weight, style: font_style
+                        family: family, weight: weight, style: font_style, logical_height: logical_height
                       ).round
                   else
                     center_x_for(text, bounds, size, width_factor,
                                  family: family, weight: weight,
-                                 style: font_style)
+                                 style: font_style, logical_height: logical_height)
                   end
               TextRenderer.new(
                 content: text,
                 x: x, y: y,
-                family: family, size: size, size_unit: size_unit,
+                family: family, size: size, size_unit: size_unit, logical_height: logical_height,
                 weight: weight, style: font_style, fill: fill,
                 stroke_in_text: stroke_in_text, width_factor: width_factor
               ).to_svg
@@ -60,9 +62,9 @@ module Ea
           # EA centers text by its INTEGER textLength and floors the
           # resulting x (verified exact against EA-published SVGs).
           def self.center_x_for(text, bounds, size, width_factor,
-                                family: nil, weight: nil, style: nil)
+                                family: nil, weight: nil, style: nil, logical_height: nil)
             len = Ea::Svg::EaEmitter::TextRenderer.estimate_width(
-              text, size, width_factor, family: family, weight: weight, style: style
+              text, size, width_factor, family: family, weight: weight, style: style, logical_height: logical_height
             ).round
             (bounds.x + (bounds.width - len) / 2.0).floor
           end

data/lib/ea/svg/ea_emitter/element/operation_renderer.rb

@@ -16,10 +16,12 @@ module Ea
           VISIBILITY_X_OFFSET = 5
           CONTENT_X_OFFSET = 22
 
-          def self.render(operations, bounds:, first_y:, family:, size:)
+          def self.render(operations, bounds:, first_y:, family:, size:, size_unit: "px", logical_height: nil)
             # EA's op rows pitch 13 (size + 6), same as attribute
             # rows (6D4C665D: ops 541..658 step 13).
-            line_h = size + 6
+            line_h = Ea::Fonts::Metrics.compartment_line_height(
+              size, family: family, unit: size_unit, logical_height: logical_height
+            )
             text_blocks = []
             has_receptions = operations.any?(&:is_reception)
             if has_receptions
@@ -27,7 +29,7 @@ module Ea
                 content: "receptions",
                 x: bounds.x + (bounds.width / 2.0) - (8 * size * 0.65) / 2,
                 y: first_y,
-                family: family, size: size,
+                family: family, size: size, size_unit: size_unit, logical_height: logical_height,
                 style: "italic", fill: "#000000"
               ).to_svg
             end
@@ -36,9 +38,9 @@ module Ea
             ops.each_with_index do |op, idx|
               y = first_y + ((idx + offset) * line_h)
               text_blocks << build_text(bounds.x + VISIBILITY_X_OFFSET, y,
-                                         visibility_prefix(op), family, size)
+                                        visibility_prefix(op), family, size, size_unit, logical_height: logical_height)
               text_blocks << build_text(bounds.x + AttributeRenderer.content_x_offset(size), y,
-                                         operation_text(op), family, size)
+                                        operation_text(op), family, size, size_unit, logical_height: logical_height)
             end
             %(<g style="#{Style::TEXT_GROUP}">\n#{text_blocks.join("\n")}\n</g>)
           end
@@ -90,9 +92,10 @@ module Ea
           end
           private_class_method :reception_params
 
-          def self.build_text(x, y, content, family, size)
+          def self.build_text(x, y, content, family, size, size_unit, logical_height: nil)
             TextRenderer.new(content: content, x: x, y: y,
-                              family: family, size: size).to_svg
+                             family: family, size: size, size_unit: size_unit,
+                             logical_height: logical_height).to_svg
           end
           private_class_method :build_text
         end