ea 0.6.107 → 0.6.108

data/lib/ea/sources/qea/diagram_builder/routing.rb

@@ -115,9 +115,11 @@ module Ea
                       else
                         stored_ray_gap?(source, target, model.style[:mode], geom[:edge])
                       end
-            return model unless allowed
+            return model unless allowed && stored_association_path?(model, link_row, source, target, geom)
 
             set_stored_ray_origins(model, source, target, geom)
+            model.style[:association_ray_outline] = true if model.connector_type == "Association"
+            model
           end
 
           # An empty-Path Mode 3 Association follows the line between its
@@ -125,6 +127,7 @@ module Ea
           # The target origin must lie inside its own stroked outline.
           def association_stored_ray(model, link_row, diagram_row, geom, context)
             return model if context
+            return stored_diagonal_corner(model, link_row, diagram_row, geom) unless link_row.path.to_s.empty?
             return model unless association_ray_candidate?(model, link_row)
 
             source, target = stored_ray_boxes(link_row, diagram_row)
@@ -141,6 +144,47 @@ module Ea
             model
           end
 
+          # A single authored bend joins the stored mathematical origins.
+          # Clip each leg independently; a facing-edge shortcut loses the bend.
+          def stored_diagonal_corner(model, link_row, diagram_row, geom)
+            return model unless model.connector_type == "Association" && association_ray_style?(model.style.to_h) &&
+                                model.style[:lwidth] == "2" && geom.values_at(:sx, :sy, :ex, :ey).all?
+
+            corners = intermediate_waypoints(link_row)
+            return model unless corners.size == 1
+
+            boxes = stored_ray_boxes(link_row, diagram_row)
+            origins = [stored_ray_origin(boxes[0], geom[:sx], geom[:sy]),
+                       stored_ray_origin(boxes[1], geom[:ex], geom[:ey])]
+            bend = Ea::Model::Point.new(x: corners[0][0], y: corners[0][1])
+            left, right = boxes.sort_by(&:x)
+            return model unless bend.x.between?(left.x + left.width + 1, right.x - 1) &&
+                                boxes.all? { |box| bend.y.between?(box.y, box.y + box.height) }
+
+            outlines = boxes.map { |box| grown_bounds(box, 1) }
+            return model unless origins.zip(outlines).all? { |origin, box| inside_box?(origin, box) }
+            return model if outlines.any? { |box| inside_box?(bend, box) }
+            return model unless origins.all? { |origin| origin.x != bend.x && origin.y != bend.y }
+
+            ends = origins.zip(outlines).map { |origin, box| diagonal_corner_exit(origin, bend, box) }
+            return model unless ends.all?
+
+            model.waypoints = [ends[0], bend, ends[1]].map { |point| Ea::Model::Waypoint.new(position: point) }
+            model.source_anchor, model.target_anchor = origins
+            model
+          end
+
+          def diagonal_corner_exit(origin, bend, box)
+            dx = bend.x - origin.x
+            dy = bend.y - origin.y
+            times = [(dx.positive? ? box.x + box.width - origin.x : box.x - origin.x).to_f / dx,
+                     (dy.positive? ? box.y + box.height - origin.y : box.y - origin.y).to_f / dy]
+            time = times.select { |value| value.between?(0, 1) }.min
+            return unless time
+
+            Ea::Model::Point.new(x: (origin.x + time * dx).floor, y: (origin.y + time * dy).floor)
+          end
+
           def port_waypoints(model, origins)
             [model.source_port || origins.first, model.target_port || origins.last].map do |point|
               Ea::Model::Waypoint.new(position: point)
@@ -198,7 +242,15 @@ module Ea
           def association_ray_candidate?(model, link_row)
             model.connector_type == "Association" && link_row.path.to_s.empty? &&
               model.source_anchor && model.target_anchor &&
-              (model.source_port || model.target_port) && association_ray_style?(model.style.to_h)
+              (model.source_port || model.target_port || aligned_default_origins?(model)) &&
+              association_ray_style?(model.style.to_h)
+          end
+
+          # Zero offsets omit ports, but an explicitly stored axis-aligned
+          # width-2 ray still uses the logical centers and stroked outlines.
+          def aligned_default_origins?(model)
+            model.has_geometry_offsets && model.style[:lwidth] == "2" &&
+              (model.source_anchor.x == model.target_anchor.x || model.source_anchor.y == model.target_anchor.y)
           end
 
           # A thin connector still meets the outer stroke of explicitly
@@ -238,73 +290,6 @@ module Ea
               point.y.between?(bounds.y, bounds.y + bounds.height)
           end
 
-          # A Mode 2 Association with equal SX/EX (vertical EDGE 1/3) or
-          # equal SY/EY (horizontal EDGE 4) and no custom Path docks as a
-          # straight line through the middle of the boxes' overlap, moved
-          # by the shared stored offset. Stored SY counts upward.
-          def overlap_ray_origins(model, link_row, diagram_row, geom, context)
-            return model if context
-            return model unless overlap_ray_candidate?(model, link_row, geom)
-
-            source, target = stored_ray_boxes(link_row, diagram_row)
-            origins = overlap_origins(source, target, geom)
-            return model unless origins
-
-            model.source_anchor, model.target_anchor = origins.map do |ox, oy|
-              Ea::Model::Point.new(x: ox, y: oy)
-            end
-            model.style[:overlap_ray] = true
-            model
-          end
-
-          # Both ray origins share the overlap coordinate on the axis the
-          # offsets move and sit at each box's centre on the other axis.
-          def overlap_origins(source, target, geom)
-            along, across, offset = overlap_axes(geom)
-            coordinate = overlap_ray_coordinate(*box_span(source, along), *box_span(target, along), offset)
-            return nil unless coordinate && disjoint_span?(*box_span(source, across), *box_span(target, across))
-
-            [source, target].map do |box|
-              start, size = box_span(box, across)
-              centre = start + size / 2.0
-              geom[:edge] == 4 ? [centre, coordinate] : [coordinate, centre]
-            end
-          end
-
-          # [axis the offsets move, axis the boxes face, stored offset]
-          def overlap_axes(geom)
-            return [%i[y height], %i[x width], -geom[:sy]] if geom[:edge] == 4
-
-            [%i[x width], %i[y height], geom[:sx]]
-          end
-
-          def box_span(box, keys)
-            keys.map { |key| box.public_send(key) }
-          end
-
-          def overlap_ray_candidate?(model, link_row, geom)
-            model.connector_type == "Association" && model.style[:mode] == "2" &&
-              model.waypoints.size == 2 && link_row.path.to_s.empty? &&
-              model.has_geometry_offsets && uniform_overlap_offsets?(geom)
-          end
-
-          def uniform_overlap_offsets?(geom)
-            return false unless geom.values_at(:sx, :sy, :ex, :ey).all?
-
-            geom[:edge] == 4 ? geom[:sy] == geom[:ey] : [1, 3].include?(geom[:edge]) && geom[:sx] == geom[:ex]
-          end
-
-          # Floor of the overlap midpoint plus the shared offset; nil
-          # when the boxes do not overlap on this axis.
-          def overlap_ray_coordinate(start_a, size_a, start_b, size_b, offset)
-            low = [start_a, start_b].max
-            high = [start_a + size_a, start_b + size_b].min
-            return nil if low > high
-
-            coordinate = ((low + high) / 2.0 + offset).floor
-            coordinate if coordinate.between?(low, high)
-          end
-
           def disjoint_span?(start_a, size_a, start_b, size_b)
             start_a + size_a < start_b || start_b + size_b < start_a
           end
@@ -322,11 +307,17 @@ module Ea
           end
 
           def stored_ray_candidate?(model, link_row, geom)
-            %w[Generalization Aggregation].include?(model.connector_type) &&
+            stored_ray_type?(model) &&
               model.waypoints.size == 2 && stored_ray_style?(model.style, link_row) &&
               stored_ray_geometry?(model, geom)
           end
 
+          def stored_ray_type?(model)
+            %w[Generalization Aggregation].include?(model.connector_type) ||
+              (model.connector_type == "Association" && model.style[:mode] == "1" &&
+                model.style[:lwidth] == "2")
+          end
+
           # Boundary-port rounding can move a computed jog off a level saved
           # ray. Equal stored origin rows specify the line before clipping.
           def normalized_level_ray?(model, source, target, geom)
@@ -408,6 +399,7 @@ module Ea
             when "Association"
               return unless style[:lwidth] == "0"
 
+              redock_child_below(points, bounds_from_rect(source_placement), bounds_from_rect(target_placement))
               redock_parent_above(points, link_row, source_placement, target_placement, strict: true)
             end
           end
@@ -517,15 +509,18 @@ module Ea
               [bounds.y, bounds.y + bounds.height].include?(point[1])
           end
 
-          # A width-2 Mode 3 Aggregation without a tree style keeps an authored
-          # orthogonal stair-step of three or more corners. Each end docks on
+          # A width-2 Mode 3 route without a tree style keeps authored orthogonal
+          # bends: two corners for Associations, three or more for Aggregations.
+          # Each end docks on
           # the 1px outline its adjacent leg points at, from the corner's own
           # coordinate; any end that cannot do so leaves the route unchanged.
           def stored_stair_route(link_row, connector, source, target)
             return nil unless stair_style?(link_row, connector)
 
             corners = stored_square_corners(link_row)
-            return nil unless corners && corners.size >= 3 && alternating_legs?(corners)
+            unless corners && stair_corner_count?(corners, connector.connector_type) && alternating_legs?(corners)
+              return nil
+            end
 
             first = outline_dock(corners[0], corners[1], source)
             last = outline_dock(corners[-1], corners[-2], target)
@@ -534,10 +529,14 @@ module Ea
 
           def stair_style?(link_row, connector)
             style = DiagramStyleParser.parse(link_row.style)
-            connector.connector_type == "Aggregation" && style[:mode] == "3" &&
+            %w[Aggregation Association].include?(connector.connector_type) && style[:mode] == "3" &&
               style[:lwidth] == "2" && !style.key?(:tree)
           end
 
+          def stair_corner_count?(corners, connector_type)
+            connector_type == "Association" ? corners.size == 2 : corners.size >= 3
+          end
+
           # Every leg is non-zero and runs along the opposite axis of the last.
           def alternating_legs?(corners)
             axes = corners.each_cons(2).map { |from, to| leg_axis(from, to) }
@@ -595,6 +594,8 @@ module Ea
           # flush on its box edge.
           def derived_lateral_route(link_row, connector, source, target)
             style = DiagramStyleParser.parse(link_row.style)
+            return derived_vertical_lateral_route(style, link_row, connector, source, target) if style[:tree] == "LV"
+
             return nil unless style[:mode] == "3" && style[:tree] == "LH" &&
                               derived_lateral_path?(connector.connector_type, link_row.path.to_s)
 
@@ -726,7 +727,7 @@ module Ea
           # Keep a vertical tree trunk whose bends still fit both boxes
           # and the open gap; the closest facing edges need not share its x.
           def preserve_stored_tree?(points, link_row, connector, src, tgt)
-            return false unless points.size == 4 && stored_tree_type?(points, link_row, connector)
+            return false unless points.size == 4 && stored_tree_type?(points, link_row, connector, src, tgt)
 
             style = DiagramStyleParser.parse(link_row.style)
             return false unless style[:lwidth] == "2" || flush_width_zero_tree?(link_row)
@@ -897,14 +898,13 @@ module Ea
             style[:tree] == "V" || (style[:mode] == "3" && style[:tree].nil?)
           end
 
-          def stored_tree_type?(points, link_row, connector)
-            connector.connector_type == "Aggregation" || flush_straight_association?(points, link_row, connector)
-          end
+          def stored_tree_type?(points, link_row, connector, source, target)
+            return true if connector.connector_type == "Aggregation"
+            return false unless connector.connector_type == "Association" && flush_width_zero_tree?(link_row)
 
-          # A flush Association keeps only a straight trunk (one bend stored twice).
-          def flush_straight_association?(points, link_row, connector)
-            connector.connector_type == "Association" && points[1] == points[-2] &&
-              flush_width_zero_tree?(link_row)
+            # Distinct thin bends are supported when the source sits above
+            # the target; the established reverse case keeps straight trunks.
+            points[1] == points[-2] || source.y + source.height < target.y
           end
 
           # A flush trunk may also hang below its parent; a bend repeated at

data/lib/ea/sources/qea/diagram_builder.rb

@@ -13,11 +13,13 @@ module Ea
         autoload :Routing, "ea/sources/qea/diagram_builder/routing"
         autoload :AutoRouting, "ea/sources/qea/diagram_builder/auto_routing"
         autoload :StoredSquarePorts, "ea/sources/qea/diagram_builder/stored_square_ports"
+        autoload :FontSettings, "ea/sources/qea/diagram_builder/font_settings"
         include Routing
         include AutoRouting
         include StoredSquarePorts
+        include FontSettings
         private_constant :Routing
-        private_constant :AutoRouting, :StoredSquarePorts
+        private_constant :AutoRouting, :StoredSquarePorts, :FontSettings
 
         attr_reader :database
 
@@ -124,6 +126,7 @@ module Ea
           @current_obj_row = obj_row
           style_hash = DiagramStyleParser.parse(obj_row.objectstyle)
           style_hash[:stored_attribute_order] = true
+          font_style = effective_font_style(obj_row, style_hash)
           Ea::Model::DiagramElement.new(
             id: IdNormalizer.synthetic("de", diagram_row.diagram_id,
                                        obj_row.instance_id),
@@ -131,8 +134,10 @@ module Ea
             model_element_ref: ref_for_object(obj_row),
             bounds: bounds_from_rect(obj_row),
             style: style_hash,
-            font_family: presence(style_hash[:font]),
-            font_size: font_size_from(style_hash),
+            font_family: presence(font_style[:font]),
+            font_size: font_size_from(font_style),
+            font_size_unit: "pt",
+            font_logical_height: font_logical_height_from(font_style),
             font_bold: truthy?(style_hash[:bold]),
             font_italic: truthy?(style_hash[:italic]),
             font_underline: truthy?(style_hash[:ul]),
@@ -145,33 +150,6 @@ module Ea
           raw == "1" || raw == "-1"
         end
 
-        def presence(value)
-          value.nil? || value.to_s.empty? ? nil : value
-        end
-
-        # EA stores the element font size in tenths of a point and
-        # renders it through GDI's double rounding: pixel height =
-        # floor(tenths * 96 / 720), then point size =
-        # floor(pixels * 72 / 96). 70 -> 9px -> 6pt (F3660305 Text),
-        # 80 -> 10px -> 7pt, 90 -> 12px -> 9pt (4EBDE645's PI_*
-        # classes), 100 -> 13px -> 9pt (0D31AED1's all-100 elements
-        # publish 321 texts at 9pt), 120 -> 16px -> 12pt
-        # (412BC89E's Boundary title), 140 -> 18px -> 13pt.
-        # fontsz=0 ("use default", written back by the font dialog)
-        # renders at the 7pt theme size.
-        USE_DEFAULT_FONTSZ = [0].freeze
-        GDI_DPI = 96
-
-        def font_size_from(style_hash)
-          raw = style_hash[:fontsz]
-          return nil if raw.nil? || raw.to_s.empty?
-
-          return nil if USE_DEFAULT_FONTSZ.include?(raw.to_i)
-
-          pixels = (raw.to_f * GDI_DPI / 720).floor
-          (pixels * 72.0 / GDI_DPI).floor
-        end
-
         def build_connectors(diagram_row)
           links = database.diagram_links_for(diagram_row.diagram_id) || []
           context = ContextDiagramSupport.context?(diagram_row)

data/lib/ea/sources/qea/instance_builder.rb

@@ -34,6 +34,7 @@ module Ea
           Ea::Model::InstanceSpecification.new(
             id: IdNormalizer.from_guid(row.ea_guid),
             name: row.name.to_s,
+            role_name: row.alias,
             classifier_id: classifier_id_for(row),
             classifier_name: classifier_name_for(row),
             stereotype: row.stereotype.to_s,

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

@@ -7,11 +7,10 @@ module Ea
       #
       # Theme :119 applies:
       #   - Border color (#9A8484) for element strokes
-      #   - Attribute color (#66413F) for attribute text
       #   - Method color for operation text
       # Theme :119 does NOT apply:
       #   - Per-type fill colors (elements use default #FFFFFF)
-      #   - Text color (#000000 black for non-attribute text)
+      #   - Attribute text color (inherits the black text color)
       #
       # Precedence chain for fill:
       #   1. Element's BCol int (when present and not sentinel)

data/lib/ea/svg/ea_emitter/compartment/attributes.rb

@@ -16,7 +16,8 @@ module Ea
               context.attr_lines,
               bounds: context.bounds,
               first_y: context.geometry.attr_first_y,
-              family: context.family, size: context.size, size_unit: context.size_unit,
+              family: context.family, size: context.size,
+              size_unit: context.size_unit, logical_height: context.logical_height,
               fill: context.theme.attribute_text_color,
               visibility_x_offset: context.theme.attribute_spec.visibility_x_offset,
               content_x_offset: context.theme.attribute_spec.content_x_offset

data/lib/ea/svg/ea_emitter/compartment/enum_literals.rb

@@ -23,7 +23,10 @@ module Ea
           end
 
           def render_literals_block(context)
-            line_h = context.size + LITERAL_LINE_OFFSET
+            line_h = Ea::Fonts::Metrics.compartment_line_height(
+              context.size, family: context.family, unit: context.size_unit, logical_height: context.logical_height,
+                            offset: LITERAL_LINE_OFFSET
+            )
             text_blocks = []
             row_y = context.geometry.enum_literal_first_y
             # EA renders a centered italic "literals" caption above
@@ -69,12 +72,13 @@ module Ea
           def caption_text(context, y)
             content = "literals"
             len = TextRenderer.estimate_width(content, context.size, nil,
-                                              family: context.family).round
+                                              family: context.family, logical_height: context.logical_height).round
             x = (context.bounds.x + (context.bounds.width - len) / 2.0).floor
             TextRenderer.new(
               content: content,
               x: x, y: y,
-              family: context.family, size: context.size, size_unit: context.size_unit,
+              family: context.family, size: context.size,
+              size_unit: context.size_unit, logical_height: context.logical_height,
               fill: context.theme.text_color,
               stroke_in_text: context.theme.stroke_in_text_color,
               width_factor: context.theme.text_width_factor,
@@ -87,7 +91,8 @@ module Ea
               content: " ",
               x: context.bounds.x + (context.theme.attribute_spec.visibility_x_offset || 5),
               y: y,
-              family: context.family, size: context.size, size_unit: context.size_unit,
+              family: context.family, size: context.size,
+              size_unit: context.size_unit, logical_height: context.logical_height,
               fill: context.theme.text_color,
               stroke_in_text: context.theme.stroke_in_text_color,
               width_factor: context.theme.text_width_factor
@@ -100,7 +105,8 @@ module Ea
               content: content,
               x: context.bounds.x + (context.theme.attribute_spec.content_x_offset || 26),
               y: y,
-              family: context.family, size: context.size, size_unit: context.size_unit,
+              family: context.family, size: context.size,
+              size_unit: context.size_unit, logical_height: context.logical_height,
               fill: context.theme.text_color,
               stroke_in_text: context.theme.stroke_in_text_color,
               width_factor: context.theme.text_width_factor

data/lib/ea/svg/ea_emitter/compartment/header.rb

@@ -17,7 +17,8 @@ module Ea
               context.header_lines,
               bounds: context.bounds,
               first_y: context.geometry.header_first_y,
-              family: context.family, size: context.size, size_unit: context.size_unit,
+              family: context.family, size: context.size,
+              size_unit: context.size_unit, logical_height: context.logical_height,
               fill: context.theme.text_color,
               weight_normal: context.theme.text_weight_normal,
               weight_bold: context.theme.text_weight_bold,

data/lib/ea/svg/ea_emitter/compartment/note_body.rb

@@ -39,10 +39,10 @@ module Ea
             pitch = size + 7
             first_offset = size + 9
             y_index = 0
-            paragraphs = body.to_s.split(/\n/).reject { |p| p.strip.empty? }
+            paragraphs = NoteHtml.paragraphs(body)
             paragraphs.flat_map do |para|
-              lines = wrap_paragraph(para, usable, size, context.family)
-              lines.each_with_index.map do |line, i|
+              lines = wrap_paragraph(para.text, usable, size, context.family)
+              paragraph_svg = lines.each_with_index.map do |line, i|
                 y = context.bounds.y + first_offset + ((y_index + i) * pitch)
                 TextRenderer.new(
                   content: line,
@@ -54,7 +54,9 @@ module Ea
                   stroke_in_text: context.theme.stroke_in_text_color,
                   width_factor: context.theme.text_width_factor
                 ).to_svg
-              end.tap { y_index += lines.size + 1 }
+              end
+              y_index += lines.size + (para.tight ? 0 : 1)
+              paragraph_svg
             end
           end
 

data/lib/ea/svg/ea_emitter/compartment/note_html.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Compartment
+        # Splits a note body into paragraphs. A body with HTML markup is
+        # shown by EA as plain text: tags are dropped, entities decoded,
+        # `<ul>`/`</ul>` lines take no row, and each `<li>` becomes a
+        # "- " line stacked directly under the previous text or item
+        # (`tight`) instead of leaving the blank row between paragraphs.
+        module NoteHtml
+          Paragraph = Struct.new(:text, :tight)
+
+          TAG = %r{</?(?:ul|ol|li|b|i|u|p|br|strong|em)\b[^>]*>}i
+          LINE_BREAK = /<br\b[^>]*>/i
+          LIST_WRAPPER = %r{\A</?(?:ul|ol)>\z}i
+          LIST_ITEM = %r{\A<li>(.*)</li>\z}i
+          ENTITIES = { "&lt;" => "<", "&gt;" => ">", "&amp;" => "&", "&quot;" => '"' }.freeze
+
+          module_function
+
+          def paragraphs(body)
+            text = body.to_s
+            return plain(text) unless text.match?(TAG)
+
+            entries = html_lines(text)
+            entries.each_with_index.map do |(line, _item, broken), index|
+              Paragraph.new(line, broken || entries[index + 1]&.at(1) || false)
+            end
+          end
+
+          def plain(text)
+            text.split(/\n/).reject { |line| line.strip.empty? }.map { |line| Paragraph.new(line, false) }
+          end
+
+          def html_lines(text)
+            text.split(/\r?\n/).flat_map do |raw|
+              line = raw.strip
+              next [] if line.empty? || line.match?(LIST_WRAPPER)
+
+              item = line.match(LIST_ITEM)
+              item ? broken_lines(item[1], "- ") : broken_lines(line, "")
+            end
+          end
+
+          # Entries are [text, starts_item, broken]. `<br>` ends a line
+          # without the blank row a new paragraph gets, so every segment
+          # but the last is `broken` (tight). Only the first segment
+          # carries the list bullet.
+          def broken_lines(line, bullet)
+            segments = line.split(LINE_BREAK).map { |segment| clean(segment) }.reject(&:empty?)
+            segments.each_with_index.map do |segment, index|
+              first = index.zero?
+              [first ? "#{bullet}#{segment}" : segment, first && !bullet.empty?, index < segments.size - 1]
+            end
+          end
+
+          def clean(line)
+            line.gsub(TAG, "").gsub(/&(?:lt|gt|amp|quot);/, ENTITIES).squeeze(" ").strip
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ea/svg/ea_emitter/compartment/operations.rb

@@ -27,7 +27,8 @@ module Ea
               context.classifier.operations,
               bounds: context.bounds,
               first_y: context.geometry.op_first_y,
-              family: context.family, size: context.size
+              family: context.family, size: context.size,
+              size_unit: context.size_unit, logical_height: context.logical_height
             )
             parts.join("\n")
           end

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

@@ -12,6 +12,7 @@ module Ea
       module Compartment
         autoload :Shape, "ea/svg/ea_emitter/compartment/shape"
         autoload :NoteBody, "ea/svg/ea_emitter/compartment/note_body"
+        autoload :NoteHtml, "ea/svg/ea_emitter/compartment/note_html"
         autoload :Header, "ea/svg/ea_emitter/compartment/header"
         autoload :HeaderDivider, "ea/svg/ea_emitter/compartment/header_divider"
         autoload :StereotypeIcon, "ea/svg/ea_emitter/compartment/stereotype_icon"

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

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

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

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