ea 0.6.127 → 0.6.129

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

@@ -91,6 +91,7 @@ module Ea
         end
 
         def dashed?(connector)
+          return true if connector.style.to_h[:association_class_ref]
           return true if connector.connector_type == "Dependency"
           return false unless connector.connector_type == "Package"
 

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

@@ -18,13 +18,14 @@ module Ea
                           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_offset: 6, default_signal_header: false)
             logical_height = nil unless size_unit == "pt"
             layout = line_layout(
               lines, bounds: bounds, first_y: first_y, family: family,
                      size: size, size_unit: size_unit, logical_height: logical_height,
                      weight_normal: weight_normal, weight_bold: weight_bold,
-                     width_factor: width_factor, line_offset: line_offset
+                     width_factor: width_factor, line_offset: line_offset,
+                     default_signal_header: default_signal_header
             )
             text_blocks = layout.map do |line|
               TextRenderer.new(
@@ -44,12 +45,21 @@ module Ea
           def self.line_layout(lines, bounds:, first_y:, family:, size:,
                                size_unit: "pt", logical_height: nil,
                                weight_normal: 400, weight_bold: 700,
-                               width_factor: 0.612, line_offset: 6)
+                               width_factor: 0.612, line_offset: 6, default_signal_header: false)
             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
             )
+            # Native default Cambria 7pt Signals use a 15px header pitch.
+            # Keep explicit fonts, logical heights and layout overrides intact.
+            if default_signal_header && family == "Cambria" && size == 7 &&
+               size_unit == "pt" && logical_height.nil? && line_offset == 6 &&
+               first_y == bounds.y + 13 && lines.size == 2 &&
+               lines.first == ["«signal»", :normal] && lines.last.last == :bold
+              first_y -= 1
+              line_h = 15
+            end
             ghost_shift = HeaderLines.parent_ghost_gap(lines)
             lines.each_with_index.map do |(text, style), idx|
               weight = %i[bold bold_italic].include?(style) ? weight_bold : weight_normal

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

@@ -19,8 +19,8 @@ module Ea
           def self.render(tagged_values, bounds:, first_y:, family:, size:, fill: "#000000",
                           size_unit: "px", logical_height: nil)
             line_h = line_height(size, family, size_unit, logical_height)
-            text_blocks = [build_text(bounds.x + centered_x_offset(bounds, size), first_y,
-                                      HEADER_TEXT, family, size, fill,
+            text_blocks = [build_text(bounds.x + centered_x_offset(bounds, family, size, size_unit, logical_height),
+                                      first_y, HEADER_TEXT, family, size, fill,
                                       style: "italic", size_unit: size_unit, logical_height: logical_height)]
             tagged_values.each_with_index do |tv, idx|
               text_blocks << build_text(bounds.x + LINE_X_OFFSET, first_y + ((idx + 1) * line_h),
@@ -48,9 +48,18 @@ module Ea
           private_class_method :line_height
 
           # Center the "tags" header text within the bounds width.
-          def self.centered_x_offset(bounds, size)
-            text_width = HEADER_TEXT.length * (size / 2)
-            centered = (bounds.width / 2 - text_width / 2).floor
+          def self.centered_x_offset(bounds, family, size, size_unit, logical_height)
+            # QEA point captions center on the same integer width emitted in SVG.
+            # Retain the legacy pixel API's placement.
+            text_width = if size_unit == "pt"
+                           TextRenderer.estimate_width(
+                             HEADER_TEXT, size, family: family, weight: 400,
+                                                style: "italic", logical_height: logical_height
+                           ).round
+                         else
+                           HEADER_TEXT.length * (size / 2)
+                         end
+            centered = ((bounds.width - text_width) / 2.0).floor
             [HEADER_X_OFFSET, centered].max
           end
           private_class_method :centered_x_offset

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

@@ -156,6 +156,7 @@ module Ea
                                      logical_height: logical_height,
                                      content_x_offset: attribute_content_x_offset(size, family, size_unit)),
                    row_content_width(op_lines, 3, size, family, logical_height: logical_height),
+                   tag_content_width(element, classifier, size, family, logical_height: logical_height),
                    Compartment::EnumLiterals.content_width(
                      enum_literals_for(classifier),
                      theme: theme, size: size, family: family,
@@ -302,7 +303,7 @@ module Ea
         end
 
         def attribute_content_x_offset(size, family, size_unit)
-          offset = (theme.attribute_spec.content_x_offset || Element::AttributeRenderer::DEFAULT_CONTENT_X_OFFSET) +
+          offset = (theme.attribute_content_x_offset || Element::AttributeRenderer::DEFAULT_CONTENT_X_OFFSET) +
                    2 * (size - 7)
           offset -= 1 if Ea::Fonts::Metrics.compact_compartment_font?(size, family: family, unit: size_unit)
           offset
@@ -312,6 +313,17 @@ module Ea
           Ea::Fonts::Metrics.compact_compartment_font?(size, family: family, unit: size_unit) ? 7 : 8
         end
 
+        def tag_content_width(element, classifier, size, family, logical_height: nil)
+          return nil unless element.show_tagged_values
+
+          tagged_values_for(classifier).map do |tag|
+            TextRenderer.estimate_width("#{tag.key} = #{tag.value}", size,
+                                        family: family, weight: 400, style: "normal",
+                                        logical_height: logical_height).round +
+              2 * Element::TaggedValueRenderer::LINE_X_OFFSET
+          end.max
+        end
+
         def row_content_width(lines, right_pad, size, family, **font_options)
           return nil if lines.to_a.empty?
 

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

@@ -17,6 +17,11 @@ module Ea
       # text-emitting layer.
       class FontResolver
         DEFAULT_FONT_FAMILY = "Yu Gothic UI"
+        # EA draws every text kind of a hand-drawn diagram (names, notes,
+        # connector labels) in this family.
+        HAND_DRAW_FAMILY = "Source Sans Pro"
+        # Native hand-drawn connector end labels carry font-weight:0.
+        HAND_DRAW_LABEL_WEIGHT = 0
         # EA's default element compartment font size. EA-published
         # reference SVGs render body text at 7pt (the current EA
         # theme size) for every element whose objectstyle fontsz is
@@ -87,7 +92,7 @@ module Ea
         private
 
         def default_family_for(explicit)
-          return "Source Sans Pro" if diagram.hand_draw
+          return HAND_DRAW_FAMILY if diagram.hand_draw
 
           theme_family_for(explicit) || diagram_default_family || DEFAULT_FONT_FAMILY
         end

data/lib/ea/svg/ea_emitter/label/end_label.rb

@@ -28,10 +28,12 @@ module Ea
           MIN_ROLE_X = 3
 
           attr_reader :canvas, :model_index, :document, :theme,
-                      :font_family, :font_size, :font_unit
+                      :font_family, :font_size, :font_unit,
+                      :font_weight, :font_style
 
           def initialize(canvas:, model_index:, document:, theme:,
-                         font_family:, font_size:, font_unit:)
+                         font_family:, font_size:, font_unit:,
+                         font_weight: 400, font_style: "normal")
             @canvas = canvas
             @model_index = model_index
             @document = document
@@ -39,6 +41,8 @@ module Ea
             @font_family = font_family
             @font_size = font_size
             @font_unit = font_unit
+            @font_weight = font_weight
+            @font_style = font_style
           end
 
           # Returns an Array of `<text>` SVG strings for one endpoint.
@@ -49,11 +53,13 @@ module Ea
           #   connector  - the DiagramConnector (for relationship lookup)
           #   end_kind   - :source or :target
           #   heading    - [dx, dy] of the first leg leaving the anchor
+          #   source_bounds - effective drawn source outline, in anchor coordinates
+          #   bend       - first bend of a saved descending vertical stair
           #   stored_labels - the connector has stored label boxes at
           #                   either end; false keeps the opposite-end
           #                   fallback
           def texts(text_box:, mult_box:, anchor:, connector:, end_kind:,
-                    tree: false, heading: nil, stored_labels: false)
+                    tree: false, heading: nil, stored_labels: false, bend: nil, source_bounds: nil)
             from_property, role, mult = role_and_multiplicity(connector, end_kind)
             if role_empty?(role) && mult_empty?(mult)
               other_from_prop, other_role, other_mult = role_and_multiplicity(connector,
@@ -92,7 +98,8 @@ module Ea
             stereo = stereo.nil? || stereo.empty? ? nil : "«#{stereo}»"
             direction = leg_direction(end_kind, heading)
             if direction && !(tree && zero_offset?(text_box, mult_box))
-              text_pos = plain_vertical_role(connector, direction, anchor, text_box, role) ||
+              text_pos = plain_leftward_source_role(connector, direction, anchor, text_box, role) ||
+                         plain_vertical_role(connector, direction, anchor, text_box, role) ||
                          source_property_seat(connector, direction, anchor, text_box, role) ||
                          plain_upward_seat(connector, direction, anchor, text_box, role) ||
                          role_seat(direction, anchor, text_box, role) || text_pos
@@ -100,7 +107,10 @@ module Ea
                          horizontal_tree_multiplicity(connector, direction, anchor, mult_box, mult) ||
                          mult_seat(direction, anchor, mult_box) || mult_pos
             elsif end_kind == :target && !(tree && zero_offset?(text_box, mult_box))
-              text_pos = target_property_role(connector, heading, anchor, text_box, role) ||
+              text_pos = plain_leftward_target_role(connector, heading, anchor, text_box, role) ||
+                         target_leftward_property_role(connector, heading, anchor, text_box, role) ||
+                         target_property_role(connector, heading, anchor, text_box, role) ||
+                         saved_ray_target_property_role(connector, heading, anchor, text_box, role) ||
                          target_diagonal_property_role(connector, heading, anchor, text_box, role) ||
                          target_vertical_role(connector, heading, anchor, text_box, role) ||
                          target_rightward_role(heading, anchor, text_box, role) || text_pos
@@ -111,16 +121,112 @@ module Ea
             if end_kind == :source
               text_pos = source_top_property_role(connector, heading, anchor, text_box, role) ||
                          source_bottom_property_role(connector, heading, anchor, text_box, role) || text_pos
+              if external_upward_property_source?(connector, heading, anchor, text_box, source_bounds)
+                text_pos = external_upward_property_role(anchor, role) || text_pos
+              end
             end
 
             text_box = text_box.merge("alignment" => 1) if phantom_property_box?(connector, direction, text_box)
 
+            if end_kind == :target && !from_property
+              bend_positions = target_bend_positions(connector, bend, text_box, mult_box, role)
+              text_pos, mult_pos = bend_positions if bend_positions
+            end
+            if end_kind == :source && !from_property
+              stair_positions = source_stair_positions(connector, anchor, text_box, mult_box, role)
+              text_pos, mult_pos = stair_positions if stair_positions
+            end
+
             build_texts(role:, mult:, standalone:,
                         text_pos:, mult_pos:, stereo:, text_box:)
           end
 
           private
 
+          def plain_leftward_target_role(connector, heading, anchor, box, role)
+            return nil unless heading && heading[0].negative? && heading[1].zero?
+            return nil unless plain_target_role?(connector, box, role)
+
+            return saved_ray_plain_target_position(anchor, box, role) if moved_plain_target_ray?(connector, box)
+
+            PlainTargetSeat.position(
+              connector: connector, anchor: anchor, box: box,
+              width: Ea::Fonts::Metrics.text_length(role, font_size, family: font_family)
+            )
+          end
+
+          def saved_ray_plain_target_position(anchor, box, role)
+            width = Ea::Fonts::Metrics.text_length(role, font_size, family: font_family)
+            x, y = seat_corner(anchor, box)
+            [x - width - SEAT_X_INSET, y - 7] if width
+          end
+
+          def moved_plain_target_ray?(connector, box)
+            saved_target_ray?(connector) && box.values_at("alignment", "cy") == [1, 16] &&
+              !stored_offsets_zero?(box)
+          end
+
+          def saved_target_ray?(connector)
+            connector.connector_type == "Association" &&
+              connector.style.to_h.values_at(:mode, :lwidth, :tree, :stored_association_ray) == ["3", "0", nil, true]
+          end
+
+          # Moved Property boxes on saved rays arriving from below use the
+          # downward seat, relative to the persisted label corner.
+          def saved_ray_target_property_role(connector, heading, anchor, box, role)
+            return nil unless downward_saved_property?(connector, heading, box)
+
+            width = Ea::Fonts::Metrics.text_length(role, font_size, family: font_family)
+            return nil unless width
+
+            x, y = seat_corner(anchor, box)
+            inset, baseline = property_role_offsets(:down)
+            [x - inset - width, y + baseline]
+          end
+
+          def downward_saved_property?(connector, heading, box)
+            heading && heading[1].positive? && heading[1] > heading[0].abs &&
+              saved_target_ray?(connector) && moved_target_property_box?(connector, box)
+          end
+
+          def plain_target_role?(connector, box, role)
+            seat_font? && cambria_box?(box) && !role_empty?(role) &&
+              connector_source_dest_stereotype(connector, :target).to_s.empty?
+          end
+
+          def plain_leftward_source_role(connector, direction, anchor, box, role)
+            return nil unless direction == :left && seat_font? && cambria_box?(box) && !role_empty?(role)
+            return nil unless connector_source_dest_stereotype(connector, :source).to_s.empty?
+
+            PlainSourceSeat.position(
+              connector: connector, anchor: anchor, box: box,
+              width: Ea::Fonts::Metrics.text_length(role, font_size, family: font_family)
+            )
+          end
+
+          def source_stair_positions(connector, anchor, text_box, mult_box, role)
+            return nil unless seat_font? && cambria_box?(text_box) && cambria_box?(mult_box)
+            return nil if role_empty?(role)
+
+            property = property_label?(connector, :source)
+            return nil unless property || connector_source_dest_stereotype(connector, :source).to_s.empty?
+
+            SourceStairSeat.positions(
+              connector: connector, anchor: anchor, text_box: text_box, mult_box: mult_box,
+              width: Ea::Fonts::Metrics.text_length(role, font_size, family: font_family)
+            )
+          end
+
+          def target_bend_positions(connector, bend, text_box, mult_box, role)
+            return nil unless bend && seat_font? && cambria_box?(text_box) && cambria_box?(mult_box)
+            return nil unless connector_source_dest_stereotype(connector, :target).to_s.empty? && !role_empty?(role)
+
+            TargetBendSeat.positions(
+              connector: connector, bend: bend, text_box: text_box, mult_box: mult_box,
+              width: Ea::Fonts::Metrics.text_length(role, font_size, family: font_family)
+            )
+          end
+
           # With stored boxes on the connector, an end that carries no
           # data of its own draws only its own stereotype; the data end
           # draws the role and multiplicity; with no data anywhere nothing
@@ -241,6 +347,43 @@ module Ea
             source_property_seat(connector, :up, anchor, box, role)
           end
 
+          # A persisted origin above the drawn source outline keeps the
+          # upward seat's inset and the shared upper baseline, including
+          # steep diagonals. Origins clipped onto the face retain -6.
+          def external_upward_property_role(anchor, role)
+            width = Ea::Fonts::Metrics.text_length(role, font_size, family: font_family)
+            return nil unless width
+
+            inset, = property_role_offsets(:up)
+            _, baseline = property_role_offsets(:left)
+            [[anchor[0] - inset - width, MIN_ROLE_X].max, anchor[1] + baseline]
+          end
+
+          def external_upward_property_source?(connector, heading, anchor, box, bounds)
+            upward_source_heading?(heading) &&
+              zero_source_property_box?(box) && cambria_box?(box) && source_property_cambria?(connector) &&
+              external_source_route?(connector, anchor) && above_source_outline?(anchor, bounds)
+          end
+
+          def upward_source_heading?(heading)
+            source_seat?(:source, heading) && heading[1].negative? && heading[1].abs > heading[0].abs
+          end
+
+          def external_source_route?(connector, anchor)
+            origin = connector.source_anchor
+            connector.connector_type == "Association" && connector.waypoints.size == 3 &&
+              connector.style.to_h.values_at(:mode, :lwidth, :tree) == ["3", "0", nil] &&
+              connector.label_boxes.to_h.values_at(:llt, :llb).all?(&:nil?) &&
+              origin && [origin.x, origin.y] == anchor
+          end
+
+          def above_source_outline?(anchor, bounds)
+            return false unless bounds&.width&.positive? && bounds.height.positive?
+
+            anchor[1] < bounds.y &&
+              anchor[0].between?(bounds.x, bounds.x + bounds.width)
+          end
+
           def zero_source_property_box?(box)
             box && box["alignment"]&.zero? && stored_offsets_zero?(box)
           end
@@ -281,7 +424,7 @@ module Ea
             return nil unless direction == :up && cambria_box?(box)
             return nil unless [0, 1].include?(box["alignment"])
             return nil unless connector_source_dest_stereotype(connector, :source).empty?
-            return nil unless plain_role_route?(connector.style.to_h)
+            return nil unless plain_role_route?(connector.style.to_h, box)
 
             width = Ea::Fonts::Metrics.text_length(role, font_size, family: font_family)
             return nil unless width
@@ -290,6 +433,30 @@ module Ea
             [x - SEAT_X_INSET - width, y - 6]
           end
 
+          # Moved target Property clusters on horizontal arrivals share
+          # the leftward source seat relative to their stored corner.
+          def target_leftward_property_role(connector, heading, anchor, box, role)
+            return nil unless heading && heading[0].negative? && heading[1].zero?
+            return nil unless moved_target_property_box?(connector, box)
+            return nil unless horizontal_target_property_route?(connector.style.to_h)
+
+            width = Ea::Fonts::Metrics.text_length(role, font_size, family: font_family)
+            return nil unless width
+
+            x, y = seat_corner(anchor, box)
+            [x - property_role_offsets(:left).first - width, y - 7]
+          end
+
+          def moved_target_property_box?(connector, box)
+            plain_vertical_box?(box) && box["alignment"] == 1 && [31, 35].include?(box["cy"]) &&
+              !stored_offsets_zero?(box) && property_label?(connector, :target)
+          end
+
+          def horizontal_target_property_route?(style)
+            style.values_at(:mode, :lwidth, :tree) == ["3", "0", nil] ||
+              (style.values_at(:mode, :lwidth) == %w[3 2] && [nil, "LH"].include?(style[:tree]))
+          end
+
           # An upward target uses the downward property's right edge and
           # the upward target baseline, both relative to its stored corner.
           def target_property_role(connector, heading, anchor, box, role)
@@ -369,9 +536,8 @@ module Ea
             seat_font? && cambria_box?(box) && [0, 1].include?(box["alignment"])
           end
 
-          # A target leg that runs down seats only on the "LV" tree route
-          # with line width 2; every other vertical seat needs the plain
-          # width-0 route.
+          # Downward target seats require LV width 2; upward target seats
+          # also accept LV width 0. Source seats require a plain width-0 route.
           def plain_vertical_connector?(connector, end_kind, direction)
             return false unless connector.connector_type == "Association" &&
                                 connector_source_dest_stereotype(connector, end_kind).empty?
@@ -384,12 +550,16 @@ module Ea
 
             if direction == :target_down
               style[:lwidth] == "2" && style[:tree] == "LV"
+            elsif direction == :target_up
+              style[:lwidth] == "0" && [nil, "LV"].include?(style[:tree])
             else
               style[:lwidth] == "0" && !style[:tree]
             end
           end
 
-          def plain_role_route?(style)
+          def plain_role_route?(style, box)
+            return box["cy"] == 16 if orthogonal_stub_route?(style)
+
             %w[1 3].include?(style[:mode]) && %w[0 2].include?(style[:lwidth]) &&
               [nil, "V"].include?(style[:tree])
           end
@@ -473,6 +643,7 @@ module Ea
 
           def left_property_route?(style)
             downward_property_route?(style) || mode_two_route?(style) ||
+              (style[:overlap_ray] == true && style.values_at(:mode, :lwidth, :tree) == ["2", "0", nil]) ||
               (style[:mode] == "3" && %w[0 2].include?(style[:lwidth]) &&
                 [nil, "H", "LV"].include?(style[:tree]))
           end
@@ -828,6 +999,7 @@ module Ea
             y_t = canvas ? canvas.translate_y(y) : y
             TextRenderer.new(content:, x: x_t, y: y_t,
                              family: font_family, size: font_size,
+                             weight: font_weight, style: font_style,
                              size_unit: font_unit,
                              fill: fill_color).to_svg
           end

data/lib/ea/svg/ea_emitter/label/midpoint_label.rb

@@ -15,15 +15,17 @@ module Ea
         # Stereotype wins when both are present.
         class MidpointLabel
           attr_reader :canvas, :model_index, :font_family, :font_size,
-                      :font_unit
+                      :font_unit, :font_weight, :font_style
 
           def initialize(canvas:, model_index:, font_family:, font_size:,
-                         font_unit:)
+                         font_unit:, font_weight: 400, font_style: "normal")
             @canvas = canvas
             @model_index = model_index
             @font_family = font_family
             @font_size = font_size
             @font_unit = font_unit
+            @font_weight = font_weight
+            @font_style = font_style
           end
 
           # Returns the SVG `<text>` for the connector's midpoint
@@ -112,14 +114,15 @@ module Ea
             return nil unless stereotype_label(connector)
 
             box = connector.label_boxes.to_h[:lmb]
-            return nil unless default_name_box?(box)
+            return nil unless default_name_box?(box, alignments: [0, 1])
 
             stored_position(connector, points, box, LINE_PITCH)
           end
 
           # At 7pt, a centered name's stored corner is 3px below its baseline.
           def stored_name_position(connector, points)
-            stored_position(connector, points, stored_name_box(connector), -3)
+            seat_points = horizontal_bend_seat(points) || points
+            stored_position(connector, seat_points, stored_name_box(connector, points), -3)
           end
 
           def stored_position(connector, points, box, baseline)
@@ -133,21 +136,37 @@ module Ea
             [x + offset_x - (width / 2.0).floor, y + offset_y + baseline]
           end
 
-          def stored_name_box(connector)
+          def stored_name_box(connector, points)
             return nil unless connector.is_a?(Ea::Model::DiagramConnector) && measured_name_font?
             return nil if connector.is_substitutable || stereotype_label(connector)
             return nil if midpoint_content(connector).include?(": ")
 
             box = connector.label_boxes.to_h[:lmt]
-            box if default_name_box?(box)
+            alignments = name_box_alignments(points)
+            box if default_name_box?(box, alignments: alignments)
+          end
+
+          def name_box_alignments(points)
+            horizontal_bend_seat(points) ? [0, 1] : [1]
+          end
+
+          # A vertical-to-horizontal bend seats its name on the horizontal leg.
+          def horizontal_bend_seat(points)
+            return nil unless points.size == 3
+
+            source, bend, target = points
+            return nil unless source[0] == bend[0] && source[1] != bend[1] &&
+                              bend[1] == target[1] && bend[0] != target[0]
+
+            [bend, target]
           end
 
           def measured_name_font?
             font_family.to_s.casecmp("Cambria").zero? && font_size == 7 && font_unit == "pt"
           end
 
-          def default_name_box?(box)
-            return false unless box && box["alignment"] == 1
+          def default_name_box?(box, alignments: [1])
+            return false unless box && alignments.include?(box["alignment"])
             return false unless box.values_at("ox", "oy").all?
             return false unless [nil, 0, 1].include?(box["direction"]) && [nil, -1].include?(box["color"])
 
@@ -191,6 +210,7 @@ module Ea
             y_t = canvas ? canvas.translate_y(y) : y
             TextRenderer.new(content:, x: x_t, y: y_t,
                              family: font_family, size: font_size,
+                             weight: font_weight, style: font_style,
                              size_unit: font_unit,
                              fill: "#000000").to_svg
           end

data/lib/ea/svg/ea_emitter/label/plain_source_seat.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Label
+        # Plain leftward roles end before the stored corner, mirroring
+        # the 3px gutter and baseline of the rightward role seat.
+        module PlainSourceSeat
+          def self.position(connector:, anchor:, box:, width:)
+            return nil unless width && eligible_connector?(connector) && moved_role_box?(box)
+
+            [anchor[0] + box["ox"].to_i - width - 3, anchor[1] + box["oy"].to_i - 7]
+          end
+
+          def self.eligible_connector?(connector)
+            connector.connector_type == "Aggregation" &&
+              connector.style.to_h.values_at(:mode, :lwidth, :tree, :plain_source_seat) == ["3", "2", nil, true]
+          end
+
+          def self.moved_role_box?(box)
+            box.values_at("alignment", "cy") == [1, 18] &&
+              box.values_at("ox", "oy").map(&:to_i) != [0, 0]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ea/svg/ea_emitter/label/plain_target_seat.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Label
+        # Plain leftward target roles end three pixels before the anchor.
+        module PlainTargetSeat
+          def self.position(connector:, anchor:, box:, width:)
+            return nil unless width && eligible_connector?(connector) && zero_role_box?(box)
+
+            [anchor[0] - width - 3, anchor[1] - 7]
+          end
+
+          def self.eligible_connector?(connector)
+            connector.connector_type == "Association" &&
+              connector.style.to_h.values_at(:mode, :lwidth, :tree, :plain_target_seat) == ["3", "2", nil, true]
+          end
+
+          def self.zero_role_box?(box)
+            box.values_at("alignment", "cy") == [1, 18] &&
+              box.values_at("ox", "oy").map(&:to_i) == [0, 0]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ea/svg/ea_emitter/label/source_stair_seat.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Label
+        # Moved source pairs on descending stairs share a baseline 18px
+        # below the stored source dock. Property clusters reserve the
+        # wider role gutter; multiplicities keep the plain 3px gutter.
+        module SourceStairSeat
+          def self.positions(connector:, anchor:, text_box:, mult_box:, width:)
+            return nil unless width && connector.connector_type == "Aggregation"
+            return nil unless connector.style.to_h.values_at(:mode, :lwidth, :tree) == %w[3 0 V]
+            return nil unless descending_stair?(connector.waypoints)
+
+            height, inset = role_geometry(connector)
+            return nil unless moved_box?(text_box, height) && moved_box?(mult_box, 18)
+
+            [position(anchor, text_box, -width - inset), position(anchor, mult_box, 3)]
+          end
+
+          def self.role_geometry(connector)
+            connector.source_stereotype.to_s.strip.casecmp("property").zero? ? [35, 60] : [18, 3]
+          end
+          private_class_method :role_geometry
+
+          def self.descending_stair?(waypoints)
+            return false unless waypoints.size == 4 && waypoints.all?(&:position)
+
+            first, bend, corner, last = waypoints.map(&:position)
+            descending_leg?(first, bend) && descending_leg?(corner, last) &&
+              horizontal_leg?(bend, corner)
+          end
+          private_class_method :descending_stair?
+
+          def self.descending_leg?(first, last)
+            first.x == last.x && first.y < last.y
+          end
+          private_class_method :descending_leg?
+
+          def self.horizontal_leg?(first, last)
+            first.y == last.y && first.x != last.x
+          end
+          private_class_method :horizontal_leg?
+
+          def self.position(anchor, box, inset)
+            [anchor[0] + box["ox"].to_i + inset, anchor[1] + box["oy"].to_i + 18]
+          end
+          private_class_method :position
+
+          def self.moved_box?(box, height)
+            box["alignment"] == 1 && box["cy"] == height &&
+              [box["ox"].to_i, box["oy"].to_i] != [0, 0]
+          end
+          private_class_method :moved_box?
+        end
+      end
+    end
+  end
+end