ea 0.6.127 → 0.6.129

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

@@ -81,13 +81,15 @@ module Ea
           # A Mode 2 Generalization whose stored Path is a horizontal jog
           # between vertically separated boxes that overlap in x is EA's
           # auto-route: one vertical ray at the overlap midpoint plus SX.
-          # The stored jog is stale; the ray docks on both 1px outlines.
+          # Empty Paths qualify only when both saved origins face the gap.
+          # The ray docks on both 1px outlines.
           def mode2_overlap_ray(model, link_row, diagram_row, geom, context)
             return model if context || !mode2_overlap_candidate?(model, link_row, geom)
 
             source, target = stored_ray_boxes(link_row, diagram_row)
             column = overlap_ray_coordinate(source.x, source.width, target.x, target.width, geom[:sx])
             return model unless column && vertical_separation?(source, target)
+            return model unless mode2_overlap_path?(link_row, source, target, geom, column)
 
             set_overlap_ray(model, column, source, target)
           end
@@ -104,8 +106,35 @@ module Ea
 
           def mode2_overlap_candidate?(model, link_row, geom)
             model.connector_type == "Generalization" && model.has_geometry_offsets &&
-              mode2_overlap_style?(model.style.to_h, geom) && model.waypoints.size == 4 &&
-              horizontal_jog?(intermediate_waypoints(link_row))
+              mode2_overlap_style?(model.style.to_h, geom) &&
+              ((model.waypoints.size == 2 && link_row.path.to_s.empty?) ||
+               (model.waypoints.size == 4 && horizontal_jog?(intermediate_waypoints(link_row))))
+          end
+
+          def mode2_overlap_path?(link_row, source, target, geom, column)
+            !link_row.path.to_s.empty? || mode2_facing_origins?(source, target, geom, column)
+          end
+
+          # Saved origins on the facing border or one pixel inside it identify
+          # the empty auto-route. Interior and external origins retain their ray.
+          def mode2_facing_origins?(source, target, geom, column)
+            return false unless geom.values_at(:sx, :sy, :ex, :ey).all?
+
+            origins = [stored_ray_origin(source, geom[:sx], geom[:sy]),
+                       stored_ray_origin(target, geom[:ex], geom[:ey])]
+            return false unless mode2_origins_share_column?(origins, source, column)
+
+            origins.zip([source, target], overlap_ray_ends(column, source, target)).all? do |origin, box, dock|
+              mode2_origin_on_face?(origin, box, dock[1])
+            end
+          end
+
+          def mode2_origin_on_face?(origin, box, outline_y)
+            inside_box?(origin, box) && (origin.y - outline_y).abs.between?(1, 2)
+          end
+
+          def mode2_origins_share_column?(origins, source, column)
+            origins.first.x == column && origins.last.x.between?(source.x, source.x + source.width)
           end
 
           def mode2_overlap_style?(style, geom)
@@ -152,6 +181,7 @@ module Ea
           # Computed-jog origins are already normalized to their derived ports.
           def correct_stored_ray_origins(model, link_row, diagram_row, geom, context)
             return model if context
+            return notelink_stored_ray(model, link_row, diagram_row, geom) if model.connector_type == "NoteLink"
             return model unless stored_ray_candidate?(model, link_row, geom)
 
             source, target = stored_ray_boxes(link_row, diagram_row)
@@ -164,9 +194,47 @@ module Ea
 
             set_stored_ray_origins(model, source, target, geom)
             model.style[:association_ray_outline] = true if model.connector_type == "Association"
+            model.style[:stored_origin_ray] = true if stored_origin_ray?(model, source, target)
             model
           end
 
+          # A straight top-docked NoteLink uses mathematical saved Y offsets,
+          # like the other custom rays, while authored bends keep their ports.
+          def notelink_stored_ray(model, link_row, diagram_row, geom)
+            return model unless notelink_ray_candidate?(model, link_row, geom)
+
+            source, target = stored_ray_boxes(link_row, diagram_row)
+            return model unless target.y + target.height < source.y
+            return model unless notelink_origins_inside?(source, target, geom)
+
+            set_stored_ray_origins(model, source, target, geom)
+          end
+
+          def notelink_ray_candidate?(model, link_row, geom)
+            model.waypoints.size == 2 && link_row.path.to_s.empty? && model.style[:lwidth] == "2" &&
+              association_ray_style?(model.style.to_h) &&
+              geom[:edge] == 1 && geom.values_at(:sx, :sy, :ex, :ey).all?
+          end
+
+          def notelink_origins_inside?(source, target, geom)
+            origins = [stored_ray_origin(source, geom[:sx], geom[:sy]),
+                       stored_ray_origin(target, geom[:ex], geom[:ey])]
+            origins.zip([source, target]).all? { |origin, box| inside_box?(origin, box) }
+          end
+
+          # Certify only a straight, width-2 custom-line ray whose corrected
+          # stored origins lie inside their own outlines. Its clipped row is
+          # authored geometry, even when it coincides with a header divider.
+          def stored_origin_ray?(model, source, target)
+            style = model.style.to_h
+            return false unless model.connector_type == "Generalization" &&
+                                style[:lwidth] == "2" && association_ray_style?(style)
+
+            [model.source_anchor, model.target_anchor].zip([source, target]).all? do |origin, box|
+              inside_box?(origin, grown_bounds(box, 1))
+            end
+          end
+
           # An empty-Path Mode 3 Association follows the line between its
           # stored endpoint origins; an omitted offset defaults to the center.
           # The target origin must lie inside its own stroked outline.
@@ -176,6 +244,8 @@ module Ea
             return model unless association_ray_candidate?(model, link_row)
 
             source, target = stored_ray_boxes(link_row, diagram_row)
+            return model if default_center_ray?(model) && !horizontal_ray_gap?(source, target)
+
             width = association_outline_width(model, link_row, diagram_row)
             origins = association_ray_origins(source, target, geom, width)
             return model unless origins
@@ -287,10 +357,26 @@ 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 || aligned_default_origins?(model)) &&
+              association_ray_ports?(model) &&
               association_ray_style?(model.style.to_h)
           end
 
+          def association_ray_ports?(model)
+            model.source_port || model.target_port || aligned_default_origins?(model) || default_center_ray?(model)
+          end
+
+          # Without stored offsets or ports, a width-2 custom line between
+          # horizontally separated boxes follows their centers to the stroke.
+          def default_center_ray?(model)
+            !model.has_geometry_offsets && model.style[:lwidth] == "2" && model.waypoints.size == 2 &&
+              [model.source_port, model.target_port].all?(&:nil?) &&
+              diagonal_origins?(model.source_anchor, model.target_anchor)
+          end
+
+          def diagonal_origins?(first, last)
+            first.x != last.x && first.y != last.y
+          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)

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

@@ -14,12 +14,14 @@ module Ea
         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"
+        autoload :AssociationClass, "ea/sources/qea/diagram_builder/association_class"
         include Routing
         include AutoRouting
         include StoredSquarePorts
         include FontSettings
+        include AssociationClass
         private_constant :Routing
-        private_constant :AutoRouting, :StoredSquarePorts, :FontSettings
+        private_constant :AutoRouting, :StoredSquarePorts, :FontSettings, :AssociationClass
 
         attr_reader :database
 
@@ -396,9 +398,10 @@ module Ea
         # Internal producer flag, like :direct. A model relationship with no
         # link row is stroked at the 2px box outline, so its ends dock there.
         def phantom_style(connector_type)
-          return { direct: true } if PHANTOM_DOUBLE_BACK_TYPES.include?(connector_type)
-
-          %w[Aggregation Association].include?(connector_type) ? { phantom_outline: true } : {}
+          style = { lwidth: "1" }
+          style[:direct] = true if PHANTOM_DOUBLE_BACK_TYPES.include?(connector_type)
+          style[:phantom_outline] = true if %w[Aggregation Association].include?(connector_type)
+          style
         end
 
         # Computes the edge attachment point on source bounds that
@@ -424,6 +427,24 @@ module Ea
           end
         end
 
+        # Preserve original Path absence: authored two-point paths can look
+        # identical after routing but retain their stored label offsets.
+        def mark_plain_source_seat(model, link_row, context)
+          return if context || !link_row.path.to_s.empty? || model.connector_type != "Aggregation"
+          return unless model.style.values_at(:mode, :lwidth, :tree) == ["3", "2", nil]
+          return unless model.source_stereotype.to_s.empty?
+
+          model.style[:plain_source_seat] = true
+        end
+
+        def mark_plain_target_seat(model, link_row, context)
+          return if context || !link_row.path.to_s.empty? || model.connector_type != "Association"
+          return unless model.style.values_at(:mode, :lwidth, :tree) == ["3", "2", nil]
+          return unless model.target_stereotype.to_s.empty?
+
+          model.style[:plain_target_seat] = true
+        end
+
         def build_connector(link_row, diagram_row)
           connector = database.find_connector(link_row.connectorid)
           geom = parse_geometry_fields(link_row.geometry)
@@ -454,6 +475,8 @@ module Ea
             has_geometry_offsets: geometry_has_offsets?(link_row.geometry),
             is_substitutable: substitutable_connector?(connector)
           ), link_row, diagram_row, geom)
+          mark_plain_source_seat(model, link_row, context)
+          mark_plain_target_seat(model, link_row, context)
           model = collapse_partial_port_jog(model, link_row, diagram_row)
           model = correct_partial_port_origins(model, link_row, diagram_row, geom, context)
           model = direct_empty_path_ray(model, link_row, diagram_row, geom, context)
@@ -466,7 +489,8 @@ module Ea
           model = auto_port_elbow(model, link_row, diagram_row, geom, context)
           model = mark_default_square_ray(model, link_row, geom, context)
           model = restore_stored_square_ports(model, link_row, diagram_row, geom, context)
-          reversed_stored_corner(model, link_row, diagram_row, geom, context)
+          model = reversed_stored_corner(model, link_row, diagram_row, geom, context)
+          mark_association_class(model, connector, diagram_row)
         end
 
         # Ray origin for one connector end: the element's center

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

@@ -80,9 +80,9 @@ module Ea
             target_multiplicity_raw: raw_card(row.destcard),
             source_aggregation: source_aggregation_for(row),
             target_aggregation: aggregation_from(row.destisaggregate),
-            source_navigable: navigable?(row.sourceaccess, row.direction,
+            source_navigable: navigable?(row.sourceisnavigable, row.direction,
                                          :source),
-            target_navigable: navigable?(row.destaccess, row.direction, :target)
+            target_navigable: navigable?(row.destisnavigable, row.direction, :target)
           }
         end
 
@@ -148,10 +148,10 @@ module Ea
           ConnectorRelationshipMap.source_aggregation_for(row.connector_type)
         end
 
-        def navigable?(_access, direction, end_label)
-          # EA's navigability is messy. Treat unspecified direction
-          # as bidirectional, "Source -> Destination" as target-only
-          # navigable, etc. Conservative default: both ends navigable.
+        def navigable?(flag, direction, end_label)
+          return flag == 1 if [0, 1].include?(flag)
+
+          # Missing or unspecified flags retain the direction fallback.
           case direction.to_s
           when "<->", "" then true
           when "->" then end_label == :target

data/lib/ea/sources/xmi/relationship_builder.rb

@@ -76,8 +76,8 @@ module Ea
             target_multiplicity_upper: parse_upper(target_end),
             source_aggregation: source_end&.aggregation || "none",
             target_aggregation: target_end&.aggregation || "none",
-            source_navigable: navigable?(source_end),
-            target_navigable: navigable?(target_end)
+            source_navigable: navigable?(element, :source),
+            target_navigable: navigable?(element, :target)
           }
         end
 
@@ -128,13 +128,20 @@ module Ea
           Integer(raw) rescue 1
         end
 
-        def navigable?(end_element)
-          return true unless end_element
+        def connector_index
+          @connector_index ||= begin
+            connectors = root.extension&.connectors&.connector || []
+            connectors.each_with_object({}) do |connector, index|
+              index[connector.idref] = connector if connector.idref
+            end
+          end
+        end
 
-          # XMI represents non-navigable ends with aggregation=none
-          # and no role name; treat presence of role name or any
-          # aggregation as navigable. Default: navigable.
-          true
+        def navigable?(element, endpoint)
+          connector = connector_index[element.id]
+          end_element = connector&.public_send(endpoint)
+          flag = end_element&.modifiers&.is_navigable
+          flag.nil? || flag
         end
       end
     end

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

@@ -20,7 +20,7 @@ module Ea
               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
+              content_x_offset: context.theme.attribute_content_x_offset
             )
           end
         end

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

@@ -24,9 +24,18 @@ module Ea
               weight_bold: context.theme.text_weight_bold,
               stroke_in_text: context.theme.stroke_in_text_color,
               width_factor: context.theme.text_width_factor,
-              line_offset: context.theme.compartments.header_line_offset
+              line_offset: context.theme.compartments.header_line_offset,
+              default_signal_header: default_signal_header?(context)
             )
           end
+
+          def default_signal_header?(context)
+            context.classifier.is_a?(Ea::Model::Signal) &&
+              context.classifier.stereotype_refs.empty? &&
+              context.element.font_size_inherited == true &&
+              context.element.font_family.nil? &&
+              !context.element.font_bold && !context.element.font_italic
+          end
         end
       end
     end

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

@@ -13,7 +13,7 @@ module Ea
         # classifier.
         module InstanceSlots
           ROW_OFFSET = 13
-          SUBTITLE_EXTRA_OFFSET = 10
+          SUBTITLE_OFFSET_FROM_BOTTOM = 15
 
           module_function
 
@@ -30,11 +30,11 @@ module Ea
             fill = context.theme.attribute_text_color
             blocks = []
             slots.each_with_index do |slot, idx|
-              y = first_y + (idx * ROW_OFFSET)
+              y = first_y + (idx * row_offset(context))
               blocks << line_text(slot, bounds, y, context, fill)
             end
             if subtitle
-              y = first_y + (slots.size * ROW_OFFSET) + SUBTITLE_EXTRA_OFFSET
+              y = bounds.y + bounds.height + SUBTITLE_OFFSET_FROM_BOTTOM
               blocks << subtitle_text(subtitle, bounds, y, context, fill)
             end
             wrap(blocks.join("\n"), fill)
@@ -88,9 +88,19 @@ module Ea
           end
           module_function :content_x_offset
 
+          def row_offset(context)
+            return ROW_OFFSET unless Ea::Fonts::Metrics.compact_compartment_font?(
+              context.size, family: context.family, unit: context.size_unit
+            )
+
+            Ea::Fonts::Metrics.compartment_line_height(
+              context.size, family: context.family, unit: context.size_unit
+            )
+          end
+          module_function :row_offset
+
           def subtitle_text(text, bounds, y_pos, context, fill)
-            estimated_width = text.length * context.size * 0.5
-            x_pos = bounds.x + (bounds.width - estimated_width) / 2.0
+            x_pos = (bounds.x + (bounds.width - subtitle_width(text, context)) / 2.0).floor
             TextRenderer.new(
               content: text,
               x: x_pos,
@@ -102,6 +112,15 @@ module Ea
           end
           module_function :subtitle_text
 
+          def subtitle_width(text, context)
+            TextRenderer.estimate_width(
+              text, context.size, nil,
+              family: context.family, style: "italic",
+              logical_height: context.size_unit == "pt" ? context.logical_height : nil
+            ).round
+          end
+          module_function :subtitle_width
+
           def wrap(body, fill)
             group_style = "stroke-width:1;stroke-linecap:round;" \
                           "stroke-linejoin:bevel; fill:#{fill};" \

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

@@ -8,6 +8,11 @@ module Ea
         # Renders only when the host element is a Note with a
         # non-empty body.
         module NoteBody
+          # Native notes put the first baseline this far below the note
+          # top plus the font's GDI cell ascent (Arial 9pt/10pt +27,
+          # Cambria 7pt +24, Carlito 9pt +26).
+          TEXT_TOP = 14
+
           module_function
 
           def render(context)
@@ -22,17 +27,15 @@ module Ea
           end
 
           def wrapped_lines(context, body)
-            # Lines fit bounds.width - 4. Pitch and
-            # first-line offset scale with the note font (9pt: pitch
-            # 16 = size+7, first line at bounds.y + 18 = size+9), and
-            # each paragraph break adds one blank pitch row
-            # (paragraph 2 starts 32 after the last line of
-            # paragraph 1).
+            # Lines fit bounds.width - 4. Pitch is the GDI cell height
+            # of the note font and the first baseline sits TEXT_TOP
+            # plus the cell ascent below the top; fonts without
+            # vertical data keep pitch size+7 and offset size+9. Each
+            # empty source line adds one blank pitch row.
             usable = context.bounds.width - 4
             size = context.size
             family = context.family
-            pitch = size + 7
-            first_offset = size + 9
+            pitch, first_offset = vertical_layout(context)
             y_index = 0
             paragraphs = NoteHtml.paragraphs(body)
             paragraphs.flat_map do |para|
@@ -52,28 +55,38 @@ module Ea
                   width_factor: context.theme.text_width_factor
                 ).to_svg
               end
-              y_index += lines.size + (para.tight ? 0 : 1)
+              y_index += lines.size + para.gap
               paragraph_svg
             end
           end
 
-          # Wrap at whitespace until native script-specific break metrics are
-          # established. Every word but the paragraph's last carries its
-          # trailing space into the fit test.
+          # [pitch, first-baseline offset] for the note font.
+          def vertical_layout(context)
+            size = context.size
+            height = context.logical_height
+            height ||= Ea::Fonts::Metrics.gdi_logical_height(size) if context.size_unit == "pt"
+            ascent, descent = Ea::Fonts::Metrics.gdi_cell_metrics(context.family, height)
+            return [size + 7, size + 9] unless ascent
+
+            [ascent + descent, TEXT_TOP + ascent]
+          end
+          module_function :vertical_layout
+
+          # Break at whitespace and between a CJK character and its
+          # neighbours. Every atom but the paragraph's last carries a
+          # following space, when the source has one, into the fit test.
           def wrap_paragraph(para, usable, size, family, logical_height: nil)
             lines = []
             current = ""
-            words = para.strip.split(/\s+/)
-            words.each_with_index do |word, index|
-              candidate = current.empty? ? word : "#{current} #{word}"
-              trailing = index < words.size - 1 ? " " : ""
-              width = TextRenderer.estimate_width("#{candidate}#{trailing}", size, nil,
-                                                  family: family, logical_height: logical_height).round
-              if current.empty? || width <= usable
+            atoms = break_atoms(para)
+            atoms.each_with_index do |atom, index|
+              candidate = current.empty? ? atom[:text] : "#{current}#{atom[:space]}#{atom[:text]}"
+              measured = "#{candidate}#{atoms.dig(index + 1, :space)}"
+              if current.empty? || fit_width(measured, size, family, logical_height) <= usable
                 current = candidate
               else
                 lines << current
-                current = word
+                current = atom[:text]
               end
             end
             lines << current unless current.empty?
@@ -81,6 +94,29 @@ module Ea
           end
           module_function :wrap_paragraph
 
+          def fit_width(text, size, family, logical_height)
+            TextRenderer.estimate_width(text, size, nil, family: family, logical_height: logical_height).round
+          end
+          module_function :fit_width
+
+          # Unbreakable runs of text with the space that precedes each one.
+          def break_atoms(text)
+            words = text.split(/\s+/).reject(&:empty?)
+            words.each_with_index.flat_map { |word, index| word_atoms(word, index.positive? ? " " : "") }
+          end
+          module_function :break_atoms
+
+          def word_atoms(word, space)
+            runs = word.chars.slice_when { |a, b| cjk_char?(a) || cjk_char?(b) }.map(&:join)
+            runs.each_with_index.map { |run, i| { text: run, space: i.zero? ? space : "" } }
+          end
+          module_function :word_atoms
+
+          def cjk_char?(char)
+            Ea::Fonts::Metrics.cjk?(char.ord)
+          end
+          module_function :cjk_char?
+
           def group_style(context)
             "stroke-width:1;stroke-linecap:round;stroke-linejoin:bevel; " \
               "fill:#{context.theme.text_color};fill-opacity:1.00; " \

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

@@ -4,13 +4,14 @@ 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.
+        # Splits a note body into paragraphs, one per non-empty source
+        # line. Each paragraph stacks directly under the previous one
+        # (`gap` 0); every empty source line after it adds one blank row.
+        # A body with HTML markup is shown by EA as plain text: tags are
+        # dropped, entities decoded, `<ul>`/`</ul>` lines take no row,
+        # each `<li>` becomes a "- " line and `<br>` ends a line.
         module NoteHtml
-          Paragraph = Struct.new(:text, :tight)
+          Paragraph = Struct.new(:text, :gap)
 
           TAG = %r{</?(?:ul|ol|li|b|i|u|p|br|strong|em)\b[^>]*>}i
           LINE_BREAK = /<br\b[^>]*>/i
@@ -22,37 +23,23 @@ module Ea
 
           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)
+            markup = text.match?(TAG)
+            lines = text.split(/\r?\n/)
+            lines.reject! { |raw| raw.strip.match?(LIST_WRAPPER) } if markup
+            lines.each_with_object([]) do |raw, paragraphs|
+              raw.strip.empty? ? paragraphs.last&.gap += 1 : paragraphs.concat(line_paragraphs(raw, markup))
             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
+          def line_paragraphs(raw, markup)
+            markup ? html_lines(raw.strip) : [Paragraph.new(raw, 0)]
           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?)
+          def html_lines(line)
+            item = line.match(LIST_ITEM)
+            segments = (item ? item[1] : 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]
+              Paragraph.new(item && index.zero? ? "- #{segment}" : segment, 0)
             end
           end
 

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

@@ -19,6 +19,10 @@ module Ea
         # self-loop, or no drawn bounds for either end).
         def pairs_for(connector, diagram, model_index, bounds_map)
           return nil unless bounds_map
+
+          tether = association_class_pairs(connector, bounds_map)
+          return tether if tether
+
           points = waypoint_pairs(connector)
           lateral = lateral_tree?(connector, points)
           trunk = trunk_tree?(connector, points)
@@ -34,6 +38,9 @@ module Ea
           target_bounds = bounds_map[target_ref]
           return nil unless source_bounds && target_bounds
           return nil if source_ref == target_ref
+          if flush_overlap_ray?(connector)
+            return clipped_pairs([source_bounds, target_bounds], [connector.source_anchor, connector.target_anchor])
+          end
           return trunk_pairs(points, source_bounds, target_bounds, connector.style[:tree]) if trunk
 
           square = OrthogonalRay.pairs_for(connector, source_bounds, target_bounds)
@@ -71,6 +78,42 @@ module Ea
           auto_port_elbow_pairs(connector, source, target, pairs)
         end
 
+        # A tether joins its saved association anchor to the facing
+        # side-center of the attached class, rather than to the other proxy.
+        def association_class_pairs(connector, bounds_map)
+          bounds = bounds_map[connector.style.to_h[:association_class_ref]]
+          anchor = connector.source_anchor
+          return nil unless bounds && anchor
+
+          [[anchor.x, anchor.y], association_class_dock(bounds, anchor)]
+        end
+        private_class_method :association_class_pairs
+
+        def association_class_dock(bounds, anchor)
+          center = association_class_center(bounds)
+          if horizontal_association_class?(bounds, anchor, center)
+            [association_class_edge_coordinate(bounds.x, bounds.width, anchor.x), center[1]]
+          else
+            [center[0], association_class_edge_coordinate(bounds.y, bounds.height, anchor.y)]
+          end
+        end
+        private_class_method :association_class_dock
+
+        def association_class_center(bounds)
+          [bounds.x + bounds.width / 2, bounds.y + bounds.height / 2]
+        end
+        private_class_method :association_class_center
+
+        def horizontal_association_class?(bounds, anchor, center)
+          (anchor.x - center[0]).abs * bounds.height > (anchor.y - center[1]).abs * bounds.width
+        end
+        private_class_method :horizontal_association_class?
+
+        def association_class_edge_coordinate(origin, size, anchor)
+          anchor > origin + size / 2 ? origin + size : origin
+        end
+        private_class_method :association_class_edge_coordinate
+
         # Auto routing turns at the clipped target column when the source
         # leaves a side edge and the target enters through its top or bottom.
         def auto_port_elbow_pairs(connector, source, target, pairs)
@@ -240,9 +283,13 @@ module Ea
         end
         private_class_method :stroke_outline?
 
-        # The QEA builder marks the Mode 2 Association overlap rays it
-        # produced; EA docks them on the outer stroke edge whatever the
-        # line width. Naturally aligned centres keep the legacy docking.
+        # The builder certifies the empty flush route's shared row and nominal docks.
+        def flush_overlap_ray?(connector)
+          connector.connector_type == "Association" && connector.style.to_h[:flush_overlap_ray] == true
+        end
+        private_class_method :flush_overlap_ray?
+
+        # The QEA builder marks Mode 2 overlap rays for outer-stroke docking.
         def overlap_ray?(connector)
           connector.connector_type == "Association" && connector.style.to_h[:overlap_ray] == true
         end
@@ -429,7 +476,9 @@ module Ea
                             bounds_map, divider_y_by_ref)
           return nil unless bounds_map && divider_y_by_ref
           return nil unless pairs.size == 2
+          return nil if flush_overlap_ray?(connector)
           return nil if explicit_association_ray?(pairs, connector)
+          return nil if connector.style.to_h[:stored_origin_ray] == true
 
           rel = relationship_for(connector, model_index)
           return nil unless rel