ea 0.6.140 → 0.6.142

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

@@ -22,6 +22,9 @@ module Ea
           SEAT_FONT_SIZE = 7
           SEAT_X_INSET = 3
           SEAT_STEREOTYPE_GAP = 12
+          SEAT_STEREOTYPE_ONLY_INSET = 8
+          SEAT_STEREOTYPE_ONLY_DROP = 15
+          SEAT_MULT_DROP = 15
           # EA keeps an end-label role's left edge at diagram x >= 3; the
           # stereotype line moves with the role. Measured on the Plateau
           # v5.1 export: of 776 saved end labels, the only three whose
@@ -131,7 +134,8 @@ module Ea
                          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
+                         target_rightward_role(heading, anchor, text_box, role) ||
+                         aligned_target_role(connector, heading, text_pos, text_box, role) || text_pos
               if horizontal_aligned_target_baseline?(connector, heading, text_box, role)
                 text_pos = [text_pos[0], seat_corner(anchor, text_box)[1] - 7]
               end
@@ -142,6 +146,7 @@ module Ea
               mult_pos = target_multiplicity_seat(connector, heading, anchor, mult_box) ||
                          target_diagonal_property_multiplicity(connector, heading, anchor, text_box, mult_box) ||
                          face_multiplicity || target_horizontal_multiplicity(heading, anchor, mult_box, mult) ||
+                         target_sloped_rightward_multiplicity(connector, heading, anchor, mult_box, role, mult) ||
                          mult_pos
             end
 
@@ -152,10 +157,14 @@ module Ea
                                                           [text_box, mult_box], mult) || mult_pos
               if external_upward_property_source?(connector, heading, anchor, text_box, source_bounds)
                 text_pos = external_upward_property_role(anchor, role) || text_pos
+                mult_pos = external_upward_property_multiplicity(anchor, mult) || mult_pos
               end
             end
 
-            text_box = text_box.merge("alignment" => 1) if phantom_property_box?(connector, direction, text_box)
+            if phantom_property_box?(connector, direction, text_box) ||
+               rightward_phantom_property_box?(connector, direction, text_box)
+              text_box = text_box.merge("alignment" => 1)
+            end
 
             if end_kind == :target && !from_property
               bend_positions = target_bend_positions(connector, bend, text_box, mult_box, role)
@@ -167,8 +176,11 @@ module Ea
             end
 
             role_bounds = umldi_bounds[end_kind == :source ? :source_role : :target_role]
+            # Unmoved lateral roles keep their measured seat: the saved UMLDI
+            # rectangle is stale for them (test B58D1A53 +role2 saved 24px low).
+            role_bounds = nil if PlainTargetSeat.unmoved_lateral_role?(connector, text_box)
             mult_bounds = umldi_bounds[end_kind == :source ? :source_multiplicity : :target_multiplicity]
-            text_pos = umldi_label_position(role_bounds) if role_bounds
+            text_pos = umldi_label_position(role_bounds, text_box) if role_bounds
             centering = role_bounds ? bounds_role_centering(connector, end_kind, role, stereo, text_box) : 0
             text_pos = [text_pos[0] + centering, text_pos[1]] if centering.positive?
             mult_pos = umldi_label_position(mult_bounds) if mult_bounds
@@ -188,6 +200,12 @@ module Ea
 
           private
 
+          # The width the renderer prints (real metrics, else its glyph estimate),
+          # so seats do not vanish for glyphs the metrics table lacks.
+          def seat_width(text)
+            TextRenderer.estimate_width(text, font_size, family: font_family)
+          end
+
           # Measured only for default Cambria 7pt Property roles on a vertical
           # leg rising from the end; other fonts, boxes and legs keep their
           # unclamped seats.
@@ -286,12 +304,13 @@ module Ea
           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 direction == :left && seat_font? && !role_empty?(role)
+            return nil unless box && cambria_box?(box.merge("alignment" => 1))
             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)
+              width: seat_width(role)
             )
           end
 
@@ -325,12 +344,30 @@ module Ea
           # fallback.
           def own_stereotype_only(text_box, anchor, connector, end_kind)
             stereo = connector_source_dest_stereotype(connector, end_kind)
-            pos = position_at(text_box, anchor)
+            pos = stereotype_only_seat(text_box, anchor, connector, end_kind, stereo) ||
+                  position_at(text_box, anchor)
             return [] if stereo.nil? || stereo.empty? || pos.nil?
 
             [text_at(pos[0], pos[1], "«#{stereo}»")]
           end
 
+          # EMPIRICAL FIT (34FF671B and 5038EEE3, the only two ends in the
+          # Plateau v5.1 corpus that draw a Property stereotype with no role
+          # or multiplicity): a one-line centred target box is seated at its
+          # corner, anchor + (OX, OY) with no sign flip, like the source-end
+          # corner seat; the stereotype ends 8px left of the corner and its
+          # baseline sits 15px below it. Both reproduce the native SVG exactly.
+          def stereotype_only_seat(text_box, anchor, connector, end_kind, stereo)
+            return nil unless end_kind == :target && property_label?(connector, end_kind)
+            return nil unless seat_font? && cambria_box?(text_box) && text_box.values_at("alignment", "cy") == [1, 16]
+
+            width = Ea::Fonts::Metrics.text_length("«#{stereo}»", font_size, family: font_family)
+            return nil unless width
+
+            x, y = seat_corner(anchor, text_box)
+            [x - width - SEAT_STEREOTYPE_ONLY_INSET, y + SEAT_STEREOTYPE_ONLY_DROP]
+          end
+
           # EA's tree-route label clusters (hand-verified against the
           # EA-published reference, SY 8542 with canvas=(0,0)):
           # source-end pairs stack at the exit point (role +3/-23,
@@ -374,8 +411,8 @@ module Ea
                          role.to_s.length * 6
             mult_width = Ea::Fonts::Metrics.text_length(mult.to_s, font_size, family: font_family) ||
                          mult.to_s.length * 6
-            [[anchor[0] - 60 - role_width, anchor[1] - 7],
-             [anchor[0] - mult_width - 3, anchor[1] + 15]]
+            [[[anchor[0] - 60 - role_width, MIN_ROLE_X].max, anchor[1] - 7],
+             [[anchor[0] - mult_width - 3, MIN_ROLE_X].max, anchor[1] + 15]]
           end
 
           # Stored source-end boxes on a 7pt label whose first leg
@@ -461,10 +498,10 @@ module Ea
           end
 
           # Measured box heights: left/down Property clusters store CY 35,
-          # right-seat clusters CY 31. Phantom outlines leaving down carry a
-          # synthesized zero box that centers the same way.
+          # right-seat and up clusters CY 31. Phantom outlines leaving down
+          # carry a synthesized zero box that centers the same way.
           def centered_property_box?(connector, direction, box)
-            cy = { left: 35, down: 35, right: 31 }[direction]
+            cy = { left: 35, down: 35, right: 31, up: 31 }[direction]
             (cy && box.values_at("cy", "alignment") == [cy, 1]) ||
               (direction == :down && phantom_property_box?(connector, direction, box))
           end
@@ -486,6 +523,16 @@ module Ea
               property_label?(connector, :source)
           end
 
+          # A rightward phantom keeps the plain role seat; only its stereotype
+          # is centred under the role (0BE81AC5: native stereotype 4px right of
+          # the role for a 52px role over a 44px stereotype).
+          def rightward_phantom_property_box?(connector, direction, box)
+            direction == :right && seat_font? && cambria_box?(box) &&
+              box["alignment"].nil? && stored_offsets_zero?(box) &&
+              connector.style.to_h[:phantom_outline] == true &&
+              property_label?(connector, :source)
+          end
+
           def property_role_x(direction, origin, offset)
             direction == :right ? origin + offset : origin - offset
           end
@@ -526,6 +573,17 @@ module Ea
             [[anchor[0] - inset - width, MIN_ROLE_X].max, anchor[1] + baseline]
           end
 
+          # Multiplicity of a floating upward source (5038EEE3: both such
+          # ends, QEA; native "0..1" at anchor.x - width - 3, anchor.y + 15).
+          def external_upward_property_multiplicity(anchor, mult)
+            return nil if mult_empty?(mult)
+
+            width = Ea::Fonts::Metrics.text_length(mult, font_size, family: font_family)
+            return nil unless width
+
+            [anchor[0] - width - SEAT_X_INSET, anchor[1] + SEAT_MULT_DROP]
+          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) &&
@@ -678,6 +736,23 @@ module Ea
             [anchor[0] + 8, anchor[1] - 7]
           end
 
+          # Stored ALN=2 role boxes sit outside their corner; see
+          # PlainTargetSeat.aligned_position.
+          def aligned_target_role(connector, heading, text_pos, box, role)
+            PlainTargetSeat.aligned_role(
+              connector: connector, heading: heading, text_pos: text_pos,
+              box: box, role: role, font_eligible: aligned_seat_font?,
+              width: seat_width(role.to_s),
+              target_stereotype: connector_source_dest_stereotype(connector, :target)
+            )
+          end
+
+          # 7pt regular Cambria, the only face the ALN=2 samples were taken in.
+          def aligned_seat_font?
+            seat_font? && font_family.to_s.casecmp("Cambria").zero? &&
+              font_weight == 400 && font_style == "normal"
+          end
+
           def target_vertical_role(connector, heading, anchor, box, role)
             return nil unless heading && heading[0].zero? && !heading[1].zero?
 
@@ -886,6 +961,18 @@ module Ea
             mult_seat(:right, anchor, box)
           end
 
+          # EMPIRICAL FIT (5038EEE3, the only connector in the Plateau v5.1
+          # corpus with a Property source and a role-less target whose leg
+          # arrives sloped from the right):
+          # the multiplicity takes the rightward corner seat, as on a
+          # horizontal rightward leg. Reproduces the native SVG exactly.
+          def target_sloped_rightward_multiplicity(connector, heading, anchor, box, role, mult)
+            return nil unless seat_font? && role_empty?(role) && !mult_empty?(mult)
+            return nil unless heading && heading[0] > heading[1].abs && property_label?(connector, :source)
+
+            mult_seat(:right, anchor, box)
+          end
+
           def target_left_face_multiplicity?(connector, heading, box, mult, target_face)
             seat_font? && !mult_empty?(mult) && property_label?(connector, :target) && cambria_box?(box) &&
               stored_offsets_zero?(box) && target_left_face_heading?(heading, target_face)
@@ -905,9 +992,12 @@ module Ea
           end
 
           def target_multiplicity_box?(connector, box)
-            # Property targets seat at the stored corner; plain moved labels
-            # retain their explicit offsets.
-            cambria_box?(box) && (stored_offsets_zero?(box) || property_label?(connector, :target))
+            # Property targets and vertical tree targets (5038EEE3) seat at
+            # the stored corner; plain moved labels retain their explicit
+            # offsets.
+            cambria_box?(box) &&
+              (stored_offsets_zero?(box) || property_label?(connector, :target) ||
+               connector.style.to_h[:tree] == "LV")
           end
 
           def cambria_box?(box)
@@ -983,8 +1073,11 @@ module Ea
                        position[1] - font_pixel_size.ceil + height]
           end
 
-          def umldi_label_position(bounds)
-            [bounds[:x], bounds[:y] + font_pixel_size.ceil]
+          # EA draws an ALN=2 role 1px right of its saved UMLDI bounds
+          # (basic: 9 roles in 8 diagrams, all exactly +1).
+          def umldi_label_position(bounds, box = nil)
+            inset = box && box["alignment"] == 2 ? 1 : 0
+            [bounds[:x] + inset, bounds[:y] + font_pixel_size.ceil]
           end
 
           def umldi_stereotype_position(bounds, role, stereo, text_box)
@@ -1072,12 +1165,13 @@ module Ea
             property unless property && opposite_role_property?(association, end_kind, property)
           end
 
-          # A UML attribute belongs to the classifier opposite its role.
-          # Do not draw that same role again at its anonymous owner end.
+          # A UML attribute belongs to the classifier opposite its role: a
+          # property named after the opposite end's role, and not after this
+          # end's own, is that end's label. Do not draw it again here.
           def opposite_role_property?(association, end_kind, property)
             own = end_kind == :source ? association.source_role_name : association.target_role_name
             other = end_kind == :source ? association.target_role_name : association.source_role_name
-            role_empty?(own) && other == property.name
+            other == property.name && own != property.name
           end
 
           def placed_classifier_id(association, end_kind)

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

@@ -49,6 +49,35 @@ module Ea
             render_text(mx, my, content)
           end
 
+          # Returns the name-direction triangle `<polygon>` for a connector
+          # whose stored LMT box carries DIR=1, or nil. EA seats it beside
+          # the name, pointing along the source-to-target direction at the
+          # midpoint. Measured only on Direction="Unspecified" links (all 10
+          # basic.qea DIR=1 links; no DIR=1 link with another Direction exists
+          # in basic, test, simple, ArcGIS or PLATEAU), so other directions
+          # draw no triangle until a native sample shows their form. Right/down
+          # geometry is measured on basic.qea's native SVGs (2AAB709F,
+          # 4DBDAB9E, 4F421236, D2FA55D3 and 6E95B74E: tip 16px past the
+          # name, 10px long, 6px wide; below the name for a vertical leg).
+          # Left/up are the mirrored extrapolation: no corpus case.
+          def direction_marker(connector, points)
+            return nil unless midpoint_content(connector)
+
+            box = stored_name_box(connector, points)
+            return nil unless box && box["direction"] == 1
+            return nil unless connector.direction == "Unspecified"
+
+            # A name with an unmeasured glyph is drawn at the default seat, so
+            # the triangle follows where the name is drawn, by its printed width.
+            x, y = stored_name_position(connector, points) || label_position(connector, points)
+            width = TextRenderer.estimate_width(midpoint_content(connector), font_size, family: font_family)
+
+            tri = direction_triangle(x, y, width, travel(points))
+            coords = tri.flat_map { |px, py| [translate_x(px), translate_y(py)] }
+            %(<polygon points="#{coords.map { |v| Canvas.coord(v) }.join(" ")}" ) +
+              %(shape-rendering="auto"   style="fill-rule:evenodd;"/>)
+          end
+
           # Returns the formatted «stereotype» string or nil. Used
           # by Label::Registry to dispatch end-label vs midpoint.
           def stereotype_label(connector)
@@ -194,6 +223,43 @@ module Ea
               target[1] < last_bend[1]
           end
 
+          # Unit travel direction [dx, dy] at the midpoint: dominant axis only.
+          def travel(points)
+            mid_idx = points.size / 2
+            from, to = if points.size.odd?
+                         [points[mid_idx - 1], points[mid_idx + 1]]
+                       else
+                         [points[mid_idx - 1], points[mid_idx]]
+                       end
+            dx = to[0] - from[0]
+            dy = to[1] - from[1]
+            return [dx.negative? ? -1 : 1, 0] if dx.abs >= dy.abs
+
+            [0, dy.negative? ? -1 : 1]
+          end
+
+          def direction_triangle(x, y, width, travel)
+            dx, dy = travel
+            if dy.zero?
+              tip_x = dx.positive? ? x + width + 16 : x - 16
+              base_x = tip_x - (dx * 10)
+              [[tip_x, y - 4], [base_x, y - 7], [base_x, y - 1]]
+            else
+              center_x = x + (width / 2.0).floor
+              tip_y = dy.positive? ? y + 13 : y - 21
+              base_y = tip_y - (dy * 10)
+              [[center_x, tip_y], [center_x - 3, base_y], [center_x + 3, base_y]]
+            end
+          end
+
+          def translate_x(value)
+            canvas ? canvas.translate_x(value) : value
+          end
+
+          def translate_y(value)
+            canvas ? canvas.translate_y(value) : value
+          end
+
           def midpoint(points)
             mid_idx = points.size / 2
             if points.size.odd?

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

@@ -7,10 +7,33 @@ module Ea
         # Plain leftward roles end before the stored corner, mirroring
         # the 3px gutter and baseline of the rightward role seat.
         module PlainSourceSeat
+          # EMPIRICAL FIT, stored 13px role boxes moved left of a leftward
+          # straight source on mode 3, width 0: ALN=0 ends 3px before the
+          # corner (basic D351FC34, F32E5AFE roleTwo, Association), ALN=2
+          # 2px before it (basic 6D0349D5 role b, Aggregation); both sit
+          # 7px above the corner like the Aggregation case below.
+          # Only cy=13 boxes are measured: every negative-OX LLT box with ALN 0 or
+          # 2 in basic, test, simple, ArcGIS and PLATEAU has cy=13 (cy=14 occurs
+          # only with ALN=1), so the ALN=2 target seat's 13-or-14 tolerance is
+          # not extended to the source.
+          STORED_INSETS = { 0 => 3, 2 => 2 }.freeze
+
           def self.position(connector:, anchor:, box:, width:)
-            return nil unless width && eligible_connector?(connector) && moved_role_box?(box)
+            return nil unless width
+
+            inset = stored_inset(connector, box)
+            inset = 3 if inset.nil? && eligible_connector?(connector) && moved_role_box?(box)
+            return nil unless inset
+
+            [anchor[0] + box["ox"].to_i - width - inset, anchor[1] + box["oy"].to_i - 7]
+          end
+
+          def self.stored_inset(connector, box)
+            return nil unless %w[Association Aggregation].include?(connector.connector_type)
+            return nil unless connector.style.to_h.values_at(:mode, :lwidth, :tree) == ["3", "0", nil]
+            return nil unless box["cy"] == 13 && box["ox"].to_i.negative?
 
-            [anchor[0] + box["ox"].to_i - width - 3, anchor[1] + box["oy"].to_i - 7]
+            STORED_INSETS[box["alignment"]]
           end
 
           def self.eligible_connector?(connector)

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

@@ -7,11 +7,74 @@ module Ea
         # 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)
+            return nil unless width
+            return nil unless (eligible_connector?(connector) && zero_role_box?(box)) ||
+                              (lateral_connector?(connector) && lateral_zero_box?(box))
 
             [anchor[0] - width - 3, anchor[1] - 7]
           end
 
+          # EMPIRICAL FIT: an unmoved ALN=0 13px role on a width-0 derived
+          # lateral-horizontal association seats like the plain target above
+          # (test B58D1A53 +role2, the only such leftward target).
+          def self.unmoved_lateral_role?(connector, box)
+            !box.nil? && lateral_connector?(connector) && lateral_zero_box?(box)
+          end
+
+          def self.lateral_connector?(connector)
+            style = connector.style.to_h
+            connector.connector_type == "Association" &&
+              style.values_at(:mode, :lwidth, :tree) == %w[3 0 LH] &&
+              (style[:derived_lateral_line] || style[:umldi_route]) == true
+          end
+
+          def self.lateral_zero_box?(box)
+            box.values_at("alignment", "cy") == [0, 13] &&
+              box.values_at("ox", "oy").map(&:to_i) == [0, 0]
+          end
+
+          # EMPIRICAL FIT: a stored ALN=2 role box on a horizontal
+          # arrival keeps its mirrored corner, text_pos, and is drawn
+          # outside it: a leftward arrival (OX < 0) ends 2px short of the
+          # corner (7 samples in basic: 6E95B74E, 4F421236, 2AAB709F,
+          # 4DBDAB9E, D2FA55D3 x2, width 30); a rightward arrival (OX > 0)
+          # starts 4px past it (basic D351FC34, F32E5AFE roleOne, width 41).
+          # Eligibility and placement of a stored ALN=2 target role: a plain
+          # Association, mode 3 / width 0 stored ray, a single-line (CY 13/14)
+          # unstyled ALN=2 box, no target stereotype, in the eligible font.
+          def self.aligned_role(connector:, heading:, text_pos:, box:, role:, width:,
+                                font_eligible:, target_stereotype:)
+            return nil unless font_eligible && !role.to_s.empty? && target_stereotype.to_s.empty?
+            return nil unless aligned_connector?(connector) && aligned_box?(box)
+
+            aligned_position(heading: heading, text_pos: text_pos, box: box, width: width)
+          end
+
+          def self.aligned_connector?(connector)
+            style = connector.style.to_h
+            connector.connector_type == "Association" &&
+              style.values_at(:mode, :lwidth, :tree) == ["3", "0", nil] && style[:stored_association_ray]
+          end
+
+          def self.aligned_box?(box)
+            return false unless box && box["alignment"] == 2 && [13, 14].include?(box["cy"])
+            return false unless box["ox"] && box["oy"] && [nil, -1].include?(box["color"])
+
+            box["rotation"].to_i.zero? && box["direction"].to_i.zero? &&
+              box.values_at("hidden", "bold", "italic", "underline").none?
+          end
+
+          def self.aligned_position(heading:, text_pos:, box:, width:)
+            return nil unless width && text_pos && heading && heading[1].zero?
+
+            ox = box["ox"].to_i
+            if heading[0].negative? && ox.negative?
+              [text_pos[0] - width - 2, text_pos[1]]
+            elsif heading[0].positive? && ox.positive?
+              [text_pos[0] + 4, text_pos[1]]
+            end
+          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]

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

@@ -36,11 +36,29 @@ module Ea
           @divider_y_by_ref = divider_y_by_ref
         end
 
+        TEXT_GROUP = "stroke-width:1;stroke-linecap:round;stroke-linejoin:%<join>s; " \
+                     "fill:#000000;fill-opacity:1.00; stroke:#000000; stroke-opacity:0.00"
+        MARKER_GROUP = "stroke-width:1;stroke-linecap:round;stroke-linejoin:round; " \
+                       "fill:#000000;fill-opacity:1.00; stroke:#000000; stroke-opacity:1.00"
+
+        # A name-direction triangle is a filled shape painted between the
+        # text runs; EA closes the text group around it and keeps the
+        # round-join pen for the text that follows.
+        DirectionMarker = Struct.new(:svg)
+
         def render
-          texts = visible_connectors.flat_map { |c| texts_for(c) }
-          return "" if texts.empty?
+          items = visible_connectors.flat_map { |c| texts_for(c) }
+          return "" if items.empty?
 
-          %(<g style="stroke-width:1;stroke-linecap:round;stroke-linejoin:bevel; fill:#000000;fill-opacity:1.00; stroke:#000000; stroke-opacity:0.00">\n#{texts.join("\n")}\n</g>)
+          join = "bevel"
+          items.slice_when { |a, b| a.is_a?(DirectionMarker) || b.is_a?(DirectionMarker) }.map do |run|
+            if run.first.is_a?(DirectionMarker)
+              join = "round"
+              %(<g style="#{MARKER_GROUP}">\n  #{run.first.svg}\n</g>)
+            else
+              %(<g style="#{format(TEXT_GROUP, join: join)}">\n#{run.join("\n")}\n</g>)
+            end
+          end.join("\n")
         end
 
         # Right edge of the stored end-label boxes (model coordinates)
@@ -51,8 +69,12 @@ module Ea
 
         private
 
+        # Labels follow the connector paint order (as the XMI diagram order
+        # already does), so QEA and XMI emit the same text sequence. Against
+        # native on PLATEAU this is a wash (79/188 exact sequences either way);
+        # it is verified on basic.qea's native SVGs.
         def visible_connectors
-          (diagram.connectors || []).select(&:renderable?)
+          PaintOrder.connectors(diagram).select(&:renderable?)
         end
 
         def texts_for(connector)
@@ -63,22 +85,18 @@ module Ea
           points = label_points(connector)
           return [] if points.size < 2
 
-          texts = []
-
           # Midpoint label: stereotype «import», or relationship
           # Name ("Association A"). Renders at the path midpoint.
           mid_text = midpoint_renderer.text_for(connector, points)
-          texts << mid_text if mid_text
+          return [mid_text, direction_marker(connector, points)].compact unless registry.end_label?(connector)
 
           # End-labels: role name + «property» + multiplicity at
           # positioned LLT/LRT boxes. Only for associations without
           # a midpoint stereotype (stereotyped associations route
-          # to midpoint only).
-          if registry.end_label?(connector)
-            end_label_texts(connector, points).each { |t| texts << t }
-          end
-
-          texts
+          # to midpoint only). EA paints the source end, then the
+          # midpoint label, then the target end (basic.xmi native SVGs).
+          source_texts, target_texts = end_label_texts(connector, points)
+          [*source_texts, mid_text, direction_marker(connector, points), *target_texts].compact
         end
 
         def end_label_texts(connector, points)
@@ -91,27 +109,26 @@ module Ea
           stored_tgt = end_boxes(boxes, :lrt, :lrb)
           umldi_bounds = connector.umldi_label_bounds || {}
           stored_labels = !(stored_src.nil? && stored_tgt.nil?) || !umldi_bounds.empty?
-          src_tb, src_mb = stored_src || unstored_label_boxes(points, :source, stored_labels)
-          tgt_tb, tgt_mb = stored_tgt || unstored_label_boxes(points, :target, stored_labels)
-
-          texts = []
-          end_renderer.texts(text_box: src_tb, mult_box: src_mb,
-                             anchor: source_pt, connector: connector,
-                             end_kind: :source, tree: tree && tree[:source],
-                             heading: (stored_src || stored_labels) && source_heading(connector, points),
-                             stored_labels: stored_labels,
-                             umldi_bounds: available_umldi_bounds(umldi_bounds, boxes, :source),
-                             source_bounds: source_dock_bounds(connector)).each { |t| texts << t }
-          end_renderer.texts(text_box: tgt_tb,
-                             mult_box: tgt_mb,
-                             anchor: target_pt, connector: connector,
-                             end_kind: :target, tree: tree && tree[:target],
-                             bend: Label::TargetBendSeat.reference(points),
-                             heading: (stored_tgt || stored_labels) && target_heading(connector, points),
-                             target_face: target_dock_heading(connector, target_pt, target_heading(connector, points)),
-                             stored_labels: stored_labels,
-                             umldi_bounds: available_umldi_bounds(umldi_bounds, boxes, :target)).each { |t| texts << t }
-          texts
+          src_tb, src_mb = stored_src || unstored_label_boxes(points, :source, stored_labels, connector)
+          tgt_tb, tgt_mb = stored_tgt || unstored_label_boxes(points, :target, stored_labels, connector)
+
+          source_texts = end_renderer.texts(text_box: src_tb, mult_box: src_mb,
+                                            anchor: source_pt, connector: connector,
+                                            end_kind: :source, tree: tree && tree[:source],
+                                            heading: (stored_src || stored_labels) && source_heading(connector, points),
+                                            stored_labels: stored_labels,
+                                            umldi_bounds: available_umldi_bounds(umldi_bounds, boxes, :source),
+                                            source_bounds: source_dock_bounds(connector))
+          target_texts = end_renderer.texts(text_box: tgt_tb,
+                                            mult_box: tgt_mb,
+                                            anchor: target_pt, connector: connector,
+                                            end_kind: :target, tree: tree && tree[:target],
+                                            bend: Label::TargetBendSeat.reference(points),
+                                            heading: (stored_tgt || stored_labels) && target_heading(connector, points),
+                                            target_face: target_dock_heading(connector, target_pt, target_heading(connector, points)),
+                                            stored_labels: stored_labels,
+                                            umldi_bounds: available_umldi_bounds(umldi_bounds, boxes, :target))
+          [source_texts, target_texts]
         end
 
         # Role bounds the XMI builder keeps belong to this connector's own
@@ -126,8 +143,15 @@ module Ea
 
         # A connector that stores label boxes for only one end seats the
         # other end's labels at its anchor, like a stored zero offset.
-        def unstored_label_boxes(points, end_kind, stored_labels)
+        #
+        # A phantom outline has no saved link row, so EA draws its default
+        # (centred) label: the synthesized zero box carries no alignment,
+        # exactly like the QEA phantom's DEFAULT_LABEL_BOXES. Measured on
+        # the Plateau v5.1 export (A081C63E: 4 «property» lines, centred
+        # under the role in the native SVG, left-aligned from XMI).
+        def unstored_label_boxes(points, end_kind, stored_labels, connector)
           return default_label_boxes(points, end_kind) unless stored_labels
+          return [{ "ox" => 0, "oy" => 0 }, { "ox" => 0, "oy" => 0 }] if connector.style.to_h[:phantom_outline] == true
 
           [{ "ox" => 0, "oy" => 0, "alignment" => 0 }, { "ox" => 0, "oy" => 0, "alignment" => 0 }]
         end
@@ -341,6 +365,11 @@ module Ea
           )
         end
 
+        def direction_marker(connector, points)
+          svg = midpoint_renderer.direction_marker(connector, points)
+          DirectionMarker.new(svg) if svg
+        end
+
         def midpoint_renderer
           @midpoint_renderer ||= Label::MidpointLabel.new(
             canvas: canvas,

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

@@ -32,14 +32,11 @@ module Ea
           @document = document
         end
 
+        # Emitted once per sequencer: the canvas, diagram and options
+        # are fixed at construction, so a re-layout builds a new
+        # sequencer rather than re-emitting this one.
         def layers
-          layers = [Background.render(canvas)]
-          layers += frame_layers if frame_enabled
-          layers += element_layers
-          layers += connector_layers
-          layers << labels_layer
-          layers << ghost_labels_layer
-          layers
+          @layers ||= build_layers.freeze
         end
 
         # Final drawn Bounds per model element ref (grown heights,
@@ -67,6 +64,16 @@ module Ea
 
         private
 
+        def build_layers
+          layers = [Background.render(canvas)]
+          layers += frame_layers if frame_enabled
+          layers += element_layers
+          layers += connector_layers
+          layers << labels_layer
+          layers << ghost_labels_layer
+          layers
+        end
+
         def frame_layers
           DiagramFrame.new(canvas: canvas, theme: theme).layers(diagram).map(&:to_svg)
         end

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

@@ -270,7 +270,7 @@ module Ea
         end
 
         def object_diagram?
-          diagram.diagram_type == "Object"
+          diagram.object_diagram?
         end
 
         # Rounded [x, y] of the marker's tip (anchor) in canvas