ea 0.6.139 → 0.6.141

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

@@ -9,6 +9,8 @@ module Ea
         # dog-eared rectangle (top-right corner folded in) with the
         # note text wrapped inside.
         #
+        # Native EA emits the body and the folded corner as two polygons.
+        #
         # Layout:
         #
         #   ┌──────────────────┐
@@ -19,15 +21,25 @@ module Ea
         #
         class NoteShapeRenderer
           FOLD_SIZE = 12
+          FOLD_FILL = "#DCDCDC"
           TEXT_X_OFFSET = 5
           TEXT_Y_OFFSET = 12
           LINE_HEIGHT = 12
 
-          def self.render(bounds, body:, fill:, stroke:, stroke_width:, family:, size:, text_fill:)
-            new(bounds, body, fill, stroke, stroke_width, family, size, text_fill).to_svg
+          # EA never sets the note pen: the outline takes the cap and join
+          # left by the previous drawing, or the initial pen (square/miter)
+          # when the note is the first thing painted. Checked on all six
+          # native notes: 7C44AC09 first (square/miter), 7D960BD8 after
+          # square/bevel icons (square/bevel), 676B9C9A, 926AFE38, 9DA6C553
+          # and C028B286 after round/bevel shapes (round/bevel).
+          INITIAL_PEN = Pen::INITIAL
+
+          def self.render(bounds, body:, fill:, stroke:, stroke_width:, family:, size:, text_fill:, pen: nil)
+            new(bounds, body, fill, stroke, stroke_width, family, size, text_fill, pen || INITIAL_PEN).to_svg
           end
 
-          def initialize(bounds, body, fill, stroke, stroke_width, family, size, text_fill)
+          def initialize(bounds, body, fill, stroke, stroke_width, family, size, text_fill, pen)
+            @pen = pen
             @bounds = bounds
             @body = body.to_s
             @fill = fill
@@ -39,7 +51,7 @@ module Ea
           end
 
           def to_svg
-            %(<g style="#{group_style}">\n  #{path_body}\n  #{fold_line}\n  #{text_block}\n</g>)
+            [body_layer, fold_layer, text_layer].reject(&:empty?).join("\n")
           end
 
           private
@@ -47,39 +59,52 @@ module Ea
           attr_reader :bounds, :body, :fill, :stroke, :stroke_width,
                       :family, :size, :text_fill
 
-          def group_style
-            "stroke-width:#{stroke_width};stroke-linecap:square;stroke-linejoin:bevel; " \
-              "fill:#{fill};fill-opacity:1.00; stroke:#{stroke}; stroke-opacity:1.00"
+          def group_style(layer_fill)
+            "stroke-width:#{stroke_width};stroke-linecap:#{@pen[0]};stroke-linejoin:#{@pen[1]}; " \
+              "fill:#{layer_fill};fill-opacity:1.00; stroke:#{stroke}; stroke-opacity:1.00"
           end
 
-          # Folded-corner body emitted as a closed <path> matching
-          # EA's encoding (not <polygon>). EA uses M..L..L..Z with
-          # stroke-linejoin=bevel for the dog-eared silhouette.
-          def path_body
-            x = bounds.x
-            y = bounds.y
-            w = bounds.width
-            h = bounds.height
-            fold = [FOLD_SIZE, w / 3, h / 3].min
-            d = "M #{Canvas.coord(x)} #{Canvas.coord(y)} " \
-                "L #{Canvas.coord(x + w - fold)} #{Canvas.coord(y)} " \
-                "L #{Canvas.coord(x + w)} #{Canvas.coord(y + fold)} " \
-                "L #{Canvas.coord(x + w)} #{Canvas.coord(y + h)} " \
-                "L #{Canvas.coord(x)} #{Canvas.coord(y + h)} " \
-                "L #{Canvas.coord(x)} #{Canvas.coord(y)} Z"
-            %(<path d="#{d}" shape-rendering="auto"/>)
+          def body_layer
+            %(<g style="#{group_style(fill)}">\n  #{polygon(body_points)}\n</g>)
+          end
+
+          def fold_layer
+            %(<g style="#{group_style(FOLD_FILL)}">\n  #{polygon(fold_points)}\n</g>)
+          end
+
+          def text_layer
+            text = text_block
+            text.empty? ? "" : %(<g style="#{group_style(fill)}">\n  #{text}\n</g>)
           end
 
-          # Inner edges of the folded corner; the outer path supplies the diagonal.
-          def fold_line
-            x = bounds.x
+          # EA encodes the note silhouette as a <polygon> (all six
+          # native Note placements in the PLATEAU and ArcGIS corpora),
+          # starting at the top-left corner and running down first.
+          def body_points
+            left, top, right, bottom = edges
+            [[left, top], [left, bottom], [right, bottom],
+             [right, top + fold_size], [right - fold_size, top]]
+          end
+
+          def edges
+            [bounds.x, bounds.y, bounds.x + bounds.width, bounds.y + bounds.height]
+          end
+
+          # The folded corner is a separate triangle, filled light
+          # grey regardless of the note's own fill.
+          def fold_points
+            r = bounds.x + bounds.width
             y = bounds.y
-            w = bounds.width
-            fold = [FOLD_SIZE, w / 3, bounds.height / 3].min
-            d = "M #{Canvas.coord(x + w - fold)} #{Canvas.coord(y)} " \
-                "L #{Canvas.coord(x + w - fold)} #{Canvas.coord(y + fold)} " \
-                "L #{Canvas.coord(x + w)} #{Canvas.coord(y + fold)}"
-            %(<path d="#{d}" shape-rendering="auto"/>)
+            [[r - fold_size, y], [r - fold_size, y + fold_size], [r, y + fold_size]]
+          end
+
+          def fold_size
+            [FOLD_SIZE, bounds.width / 3, bounds.height / 3].min
+          end
+
+          def polygon(points)
+            list = points.map { |px, py| "#{Canvas.coord(px)} #{Canvas.coord(py)}" }.join(" ")
+            %(<polygon points="#{list}" shape-rendering="auto"   style="fill-rule:evenodd;"/>)
           end
 
           def text_block

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

@@ -33,7 +33,12 @@ module Ea
         def groups
           @drawn_bounds = {}
           @divider_y = {}
-          ordered_elements.flat_map { |e| groups_for(e) }
+          @previous_pen = nil
+          ordered_elements.flat_map do |e|
+            painted = groups_for(e)
+            @previous_pen = painted.last&.pen || @previous_pen
+            painted.map(&:svg)
+          end
         end
 
         # Final drawn Bounds per model element reference, captured
@@ -50,8 +55,15 @@ module Ea
 
         private
 
+        # EA paints placements by descending Sequence (the lowest
+        # Sequence is on top); equal keys keep their stored order. A
+        # placement with no Sequence (no such row in the corpus, so EA's
+        # treatment is unmeasured) is painted first, as before the
+        # descending order, rather than ahead of the numbered ones.
         def ordered_elements
-          (diagram.elements || []).sort_by { |e| e.z_order || 0 }
+          (diagram.elements || []).sort_by.with_index do |e, i|
+            e.z_order ? [1, -e.z_order, i] : [0, 0, i]
+          end
         end
 
         def groups_for(element)
@@ -63,7 +75,7 @@ module Ea
           record_drawn_bounds(element, context)
           return [] if element.style&.fetch("connector_proxy", false)
 
-          Compartment.render_all(context).compact
+          Compartment.paint_all(context)
         end
 
         # Logical-space drawn bounds: stored x/y with the RENDERED
@@ -300,7 +312,8 @@ module Ea
             canvas: canvas,
             diagram: diagram,
             model_index: model_index,
-            off_canvas_parent_name: parent_name
+            off_canvas_parent_name: parent_name,
+            previous_pen: @previous_pen
           )
         end
 
@@ -380,10 +393,16 @@ module Ea
                                    attr_group_lead: attr_group_lead)
         end
 
+        # A ghost-led header (italic parent label above the stereotype /
+        # name) takes the same compact offsets: EA seats its divider at
+        # the last header baseline + 7 (empirical fit, 21 QEA dividers
+        # that were +1: 0114FD24 uro::AbstractConstruction etc.; 20 of
+        # 21 now exact, no other compared item moved). The tight ghost
+        # variant has no corpus case and keeps the default offsets.
         def compact_header_offsets?(classifier, header_lines, size, **options)
           classifier.is_a?(Ea::Model::Klass) &&
             Ea::Fonts::Metrics.compact_compartment_font?(size, family: options[:family], unit: options[:size_unit]) &&
-            !%i[italic italic_tight].include?(header_lines.dig(0, 1)) &&
+            header_lines.dig(0, 1) != :italic_tight &&
             options.values_at(:logical_height, :marker_count, :enum_literals_count,
                               :divider_offset, :attr_first_offset) == [nil, 0, 0, 8, 7] &&
             theme.compartments.header_line_offset == 6 && theme.compartments.attr_line_offset == 6

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

@@ -68,7 +68,9 @@ module Ea
         end
 
         def logical_height_for(element)
-          element&.font_logical_height if size_unit_for(element) == "pt"
+          return nil unless size_unit_for(element) == "pt"
+
+          Ea::Fonts::Metrics.source_logical_height(element&.font_logical_height)
         end
 
         def weight_for(element)

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
@@ -45,6 +48,15 @@ module Ea
             @font_unit = font_unit
             @font_weight = font_weight
             @font_style = font_style
+            @reach = []
+          end
+
+          # [right, bottom] edge, in model coordinates, of the label boxes
+          # (position + stored CX/CY) emitted so far; nil before any.
+          def reach
+            return nil if @reach.empty?
+
+            [@reach.map(&:first).max, @reach.map(&:last).max]
           end
 
           # Returns an Array of `<text>` SVG strings for one endpoint.
@@ -102,6 +114,10 @@ module Ea
             stereo = connector_source_dest_stereotype(connector, end_kind)
             stereo = stereo.nil? || stereo.empty? ? nil : "«#{stereo}»"
             direction = leg_direction(end_kind, heading)
+            if left_seated_source?(connector, end_kind)
+              text_pos, mult_pos = left_seated_positions(anchor, role, mult)
+              direction = nil
+            end
             if direction && !(tree && zero_offset?(text_box, mult_box))
               text_pos = plain_leftward_source_role(connector, direction, anchor, text_box, role) ||
                          plain_vertical_role(connector, direction, anchor, text_box, role) ||
@@ -127,7 +143,9 @@ module Ea
                                     directional_multiplicity(:left, anchor, mult_box, mult)
                                   end
               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
 
@@ -138,10 +156,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)
@@ -168,7 +190,8 @@ module Ea
             end
 
             build_texts(role:, mult:, standalone:,
-                        text_pos:, mult_pos:, stereo:, text_box:, stereo_pos:)
+                        text_pos:, mult_pos:, stereo:, text_box:, stereo_pos:,
+                        mult_box:)
           end
 
           private
@@ -310,12 +333,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,
@@ -345,6 +386,24 @@ module Ea
             end
           end
 
+          def left_seated_source?(connector, end_kind)
+            end_kind == :source && connector.style.to_h[:left_seated_source] == true
+          end
+
+          # EMPIRICAL FIT (5038EEE3 connectors 207 and 212, the only reversed
+          # links the builder flags): the source cluster sits left of the
+          # anchor like a source leaving left, whichever way the route leaves:
+          # role right edge 60px out, 7px above; multiplicity ends 3px short
+          # of the anchor, 15px below.
+          def left_seated_positions(anchor, role, mult)
+            role_width = Ea::Fonts::Metrics.text_length(role.to_s, font_size, family: font_family) ||
+                         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, 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
           # leaves straight up or straight right are seated at the box
           # corner, anchor + (OX, OY) with no sign flip, 3px to its
@@ -365,14 +424,15 @@ module Ea
             nil
           end
 
-          # Saved bounds seat a source Property role at the stereotype's left
-          # edge. A centred stored box (ALN=1), or a phantom's synthesized box
+          # Saved bounds seat a source or target Property role at the stereotype's
+          # left edge (target: +endPoint on 159E9DA0 and 90BCA409, the only
+          # corpus targets narrower than the stereotype). A centred stored box (ALN=1), or a phantom's synthesized box
           # without alignment, centres the shorter role over it; a
           # left-aligned box keeps both lines on that edge.
           def bounds_role_centering(connector, end_kind, role, stereo, text_box)
-            return 0 unless end_kind == :source && stereo && seat_font?
+            return 0 unless stereo && seat_font?
             return 0 unless centred_bounds_box?(connector, text_box)
-            return 0 unless property_label?(connector, :source)
+            return 0 unless property_label?(connector, end_kind)
 
             -[stereotype_offset(role, stereo, { "alignment" => 1 }), 0].min
           end
@@ -427,10 +487,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
@@ -452,6 +512,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
@@ -492,6 +562,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) &&
@@ -634,6 +715,16 @@ module Ea
             property_role_offsets(:down).first if dy.negative? && dy.abs > dx.abs
           end
 
+          # With no stored multiplicity box, a Property target on a steep
+          # upward diagonal seats it beside the anchor, above the role baseline.
+          def target_diagonal_property_multiplicity(connector, heading, anchor, text_box, mult_box)
+            return nil if mult_box
+            return nil unless diagonal_property_box?(connector, text_box)
+            return nil unless heading && heading[1].negative? && heading[1].abs > heading[0].abs
+
+            [anchor[0] + 8, anchor[1] - 7]
+          end
+
           def target_vertical_role(connector, heading, anchor, box, role)
             return nil unless heading && heading[0].zero? && !heading[1].zero?
 
@@ -842,6 +933,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)
@@ -861,9 +964,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)
@@ -905,9 +1011,11 @@ module Ea
           end
 
           def build_texts(role:, mult:, standalone:, text_pos:, mult_pos:,
-                          stereo:, text_box:, stereo_pos: nil)
+                          stereo:, text_box:, stereo_pos: nil, mult_box: nil)
             if role && !role.empty? && text_pos
               x, y = text_pos
+              note_reach(text_pos, text_box)
+              note_reach(mult_pos, mult_box) if mult && !mult.empty? && mult_pos
               texts = [text_at(x, y, role)]
               if stereo
                 stereo_x, stereo_y = stereo_pos || [x + stereotype_offset(role, stereo, text_box),
@@ -919,12 +1027,24 @@ module Ea
               end
               texts
             elsif standalone && !standalone.empty? && mult_pos
+              note_reach(mult_pos, mult_box)
               [text_at(*mult_pos, standalone)]
             else
               []
             end
           end
 
+          # A label box starts at the text's x and at its first baseline
+          # less the rounded font height (EA's text top).
+          def note_reach(position, box)
+            width = box && box["cx"]
+            height = box && box["cy"]
+            return unless width && height
+
+            @reach << [position[0] + width,
+                       position[1] - font_pixel_size.ceil + height]
+          end
+
           def umldi_label_position(bounds)
             [bounds[:x], bounds[:y] + font_pixel_size.ceil]
           end

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

@@ -43,6 +43,12 @@ module Ea
           %(<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>)
         end
 
+        # Right edge of the stored end-label boxes (model coordinates)
+        # of the last render, or nil when none carry a width.
+        def reach
+          end_renderer.reach
+        end
+
         private
 
         def visible_connectors
@@ -85,8 +91,8 @@ 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)
+          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)
 
           texts = []
           end_renderer.texts(text_box: src_tb, mult_box: src_mb,
@@ -120,8 +126,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

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,
@@ -49,12 +46,34 @@ module Ea
           @elements&.drawn_bounds
         end
 
+        # Row-slot seating stays off. Elements records each divider in canvas
+        # space, so it only matched logical connector ends when the canvas
+        # origin was 0 (the content-anchored default) and then moved one end
+        # 13 px in all four corpus cases it matched (5D6DB5A0 Aggregation and
+        # Generalization, ADC8773C, F46E8F19), none of which EA seats on a
+        # row; it never matched an XMI route. Under the framed canvas it was
+        # inert, which is the behaviour native parity was measured against.
         def divider_y_by_ref
-          @elements&.divider_y
+          nil
+        end
+
+        # Right edge of the connector end-label boxes, model coordinates.
+        def label_reach
+          @labels&.reach
         end
 
         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
@@ -66,46 +85,48 @@ module Ea
           @elements.groups
         end
 
+        # EA paints connector by connector: each line is followed by
+        # its own heads, and only adjacent same-style groups merge.
         def connector_layers
-          connector_layers_raw = Connectors.new(diagram, canvas: canvas,
-                                                  grouped: true,
-                                                  stroke_width: DEFAULT_STROKE_WIDTH,
-                                                  drawn_bounds: drawn_bounds,
-                                                  divider_y_by_ref: divider_y_by_ref,
-                                                  model_index: model_index).layers
-          marker_layers_raw = Markers.new(diagram, model_index: model_index,
-                                           canvas: canvas, grouped: true,
-                                           stroke_width: DEFAULT_STROKE_WIDTH,
-                                           drawn_bounds: drawn_bounds,
-                                           divider_y_by_ref: divider_y_by_ref).layers
-          merge_layers_by_style(connector_layers_raw + marker_layers_raw).map(&:to_svg)
+          lines = Connectors.new(diagram, canvas: canvas,
+                                          grouped: true,
+                                          stroke_width: DEFAULT_STROKE_WIDTH,
+                                          drawn_bounds: drawn_bounds,
+                                          divider_y_by_ref: divider_y_by_ref,
+                                          model_index: model_index).connector_layers
+          markers = Markers.new(diagram, model_index: model_index,
+                                         canvas: canvas, grouped: true,
+                                         stroke_width: DEFAULT_STROKE_WIDTH,
+                                         drawn_bounds: drawn_bounds,
+                                         divider_y_by_ref: divider_y_by_ref).connector_layers
+          by_owner = {}.compare_by_identity
+          (lines + markers).each { |owner, layer| (by_owner[owner] ||= []) << layer }
+          ordered = PaintOrder.connectors(diagram).flat_map { |connector| by_owner.fetch(connector, []) }
+          merge_adjacent_by_style(ordered).map(&:to_svg)
         end
 
         def labels_layer
-          Labels.new(diagram, canvas: canvas, model_index: model_index,
+          @labels = Labels.new(diagram, canvas: canvas, model_index: model_index,
                               theme: theme, document: document,
                               drawn_bounds: drawn_bounds,
-                              divider_y_by_ref: divider_y_by_ref).render
+                              divider_y_by_ref: divider_y_by_ref)
+          @labels.render
         end
 
         def ghost_labels_layer
           GhostLabels.new(diagram, canvas: canvas).render
         end
 
-        def merge_layers_by_style(layers)
-          merged = {}
-          layers.each do |layer|
-            if merged[layer.style_key]
-              merged[layer.style_key] = Layer.new(
-                style_key: layer.style_key,
-                style: layer.style,
-                body: "#{merged[layer.style_key].body}\n  #{layer.body}"
-              )
+        def merge_adjacent_by_style(layers)
+          layers.each_with_object([]) do |layer, merged|
+            last = merged.last
+            if last && last.style_key == layer.style_key
+              merged[-1] = Layer.new(style_key: last.style_key, style: last.style,
+                                     body: "#{last.body}\n  #{layer.body}")
             else
-              merged[layer.style_key] = layer
+              merged << layer
             end
           end
-          merged.values
         end
       end
     end