ea 0.6.127 → 0.6.128

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 78f923bf1924106f7e6853841f3470c198e6ed0c9198e4501acd63aa3e84b3b6
-  data.tar.gz: 46975a9dd5d9f80c027a4b7f906abb2dfaff6d7bfdcc8b0af82f3ce390f6a2c6
+  metadata.gz: 306887ac0320a438c1248971e4143fab06ab22982e08f2c61b19c31b7b64cc37
+  data.tar.gz: 2a73ad0edf0d4eac704f563f679946f19615e906c3d28dc30b9f25815fd8ed83
 SHA512:
-  metadata.gz: e9b5fcacddafe90bac1b21015a6649227fd9676e01e8f5367e9eec96c0eac8712ff6303e49fadfa1d3db0c19c648eec056030ddcdb0e8d68609191502fd26193
-  data.tar.gz: 3f95877c62d6dc05b74096bba8ecd49961a2c40bd363a98fde2d5e27f53a31e43ecb871a210e010ef5721b7c6e4d58c2cd94c6bf16e3826a712e80c1f0f7055e
+  metadata.gz: eef820b29153599ad35fc3de5bb047fa18fc824e6a09b8eb6f95c17a27d2c5126e350341c27649ebe9e861676bbb0b3437de0d9db7f4046ab964e11ce3923fa1
+  data.tar.gz: 32e7e0d157472804ada0ddb04a487d26180f14bf1e5c1254dff1b3de68353cff4d22270aee4a8fa9b28e6d103c27f0fe449ec5b0c65411579434a22f1f5bdb67

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

@@ -34,13 +34,14 @@ module Ea
           # A Mode 2 Association with equal SX/EX (vertical EDGE 1/3) or
           # equal SY/EY (horizontal EDGE 2/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.
+          # by the shared stored offset. Empty flush Mode 3 routes facing
+          # right use the same row. 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)
+            origins = overlap_origins(source, target, geom, model.style[:mode])
             return model unless origins && overlap_correction?(source, target, geom)
 
             model.source_anchor, model.target_anchor = origins.map do |ox, oy|
@@ -50,9 +51,20 @@ module Ea
               model.waypoints = port_waypoints(model, [model.source_anchor, model.target_anchor])
             end
             model.style[:overlap_ray] = true
+            flush_overlap_ports(model, source, target)
             model
           end
 
+          def flush_overlap_ports(model, source, target)
+            return unless model.style[:mode] == "3"
+
+            row = model.source_anchor.y
+            model.source_port = Ea::Model::Point.new(x: source.x + source.width, y: row)
+            model.target_port = Ea::Model::Point.new(x: target.x, y: row)
+            model.waypoints = port_waypoints(model, [model.source_port, model.target_port])
+            model.style[:flush_overlap_ray] = true
+          end
+
           # Aligned, zero-offset EDGE 2 routes already have their legacy docks.
           def overlap_correction?(source, target, geom)
             geom[:edge] != 2 || !geom[:sy].zero? ||
@@ -61,7 +73,9 @@ module Ea
 
           # 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)
+          def overlap_origins(source, target, geom, mode = nil)
+            return nil if mode == "3" && !source_row_faces_target?(source, target, geom[:edge])
+
             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))
@@ -85,11 +99,19 @@ module Ea
           end
 
           def overlap_ray_candidate?(model, link_row, geom)
-            model.connector_type == "Association" && model.style[:mode] == "2" &&
+            model.connector_type == "Association" && overlap_ray_style?(model.style, geom) &&
               [2, 3].include?(model.waypoints.size) && link_row.path.to_s.empty? && !model.style[:tree] &&
               model.has_geometry_offsets && uniform_overlap_offsets?(geom)
           end
 
+          def overlap_ray_style?(style, geom)
+            return true if style[:mode] == "2"
+
+            # All-zero offsets retain the default center ray.
+            style[:mode] == "3" && style[:lwidth] == "0" && geom[:edge] == 2 &&
+              geom.values_at(:sx, :sy, :ex, :ey).any? { |offset| offset.to_i.nonzero? }
+          end
+
           def uniform_overlap_offsets?(geom)
             return false unless geom.values_at(:sx, :sy, :ex, :ey).all?
 

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

@@ -164,9 +164,23 @@ 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
 
+          # 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 +190,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 +303,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

@@ -396,9 +396,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 +425,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 +473,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)

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/connector_redock.rb

@@ -34,6 +34,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)
@@ -240,9 +243,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 +436,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

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

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

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

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

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

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

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

@@ -49,11 +49,12 @@ module Ea
           #   connector  - the DiagramConnector (for relationship lookup)
           #   end_kind   - :source or :target
           #   heading    - [dx, dy] of the first leg leaving the anchor
+          #   bend       - first bend of a saved descending vertical stair
           #   stored_labels - the connector has stored label boxes at
           #                   either end; false keeps the opposite-end
           #                   fallback
           def texts(text_box:, mult_box:, anchor:, connector:, end_kind:,
-                    tree: false, heading: nil, stored_labels: false)
+                    tree: false, heading: nil, stored_labels: false, bend: nil)
             from_property, role, mult = role_and_multiplicity(connector, end_kind)
             if role_empty?(role) && mult_empty?(mult)
               other_from_prop, other_role, other_mult = role_and_multiplicity(connector,
@@ -92,7 +93,8 @@ module Ea
             stereo = stereo.nil? || stereo.empty? ? nil : "«#{stereo}»"
             direction = leg_direction(end_kind, heading)
             if direction && !(tree && zero_offset?(text_box, mult_box))
-              text_pos = plain_vertical_role(connector, direction, anchor, text_box, role) ||
+              text_pos = plain_leftward_source_role(connector, direction, anchor, text_box, role) ||
+                         plain_vertical_role(connector, direction, anchor, text_box, role) ||
                          source_property_seat(connector, direction, anchor, text_box, role) ||
                          plain_upward_seat(connector, direction, anchor, text_box, role) ||
                          role_seat(direction, anchor, text_box, role) || text_pos
@@ -100,7 +102,9 @@ module Ea
                          horizontal_tree_multiplicity(connector, direction, anchor, mult_box, mult) ||
                          mult_seat(direction, anchor, mult_box) || mult_pos
             elsif end_kind == :target && !(tree && zero_offset?(text_box, mult_box))
-              text_pos = target_property_role(connector, heading, anchor, text_box, role) ||
+              text_pos = plain_leftward_target_role(connector, heading, anchor, text_box, role) ||
+                         target_leftward_property_role(connector, heading, anchor, text_box, role) ||
+                         target_property_role(connector, heading, anchor, text_box, role) ||
                          target_diagonal_property_role(connector, heading, anchor, text_box, role) ||
                          target_vertical_role(connector, heading, anchor, text_box, role) ||
                          target_rightward_role(heading, anchor, text_box, role) || text_pos
@@ -115,12 +119,69 @@ module Ea
 
             text_box = text_box.merge("alignment" => 1) if phantom_property_box?(connector, direction, text_box)
 
+            if end_kind == :target && !from_property
+              bend_positions = target_bend_positions(connector, bend, text_box, mult_box, role)
+              text_pos, mult_pos = bend_positions if bend_positions
+            end
+            if end_kind == :source && !from_property
+              stair_positions = source_stair_positions(connector, anchor, text_box, mult_box, role)
+              text_pos, mult_pos = stair_positions if stair_positions
+            end
+
             build_texts(role:, mult:, standalone:,
                         text_pos:, mult_pos:, stereo:, text_box:)
           end
 
           private
 
+          def plain_leftward_target_role(connector, heading, anchor, box, role)
+            return nil unless heading && heading[0].negative? && heading[1].zero?
+            return nil unless plain_target_role?(connector, box, role)
+
+            PlainTargetSeat.position(
+              connector: connector, anchor: anchor, box: box,
+              width: Ea::Fonts::Metrics.text_length(role, font_size, family: font_family)
+            )
+          end
+
+          def plain_target_role?(connector, box, role)
+            seat_font? && cambria_box?(box) && !role_empty?(role) &&
+              connector_source_dest_stereotype(connector, :target).to_s.empty?
+          end
+
+          def plain_leftward_source_role(connector, direction, anchor, box, role)
+            return nil unless direction == :left && seat_font? && cambria_box?(box) && !role_empty?(role)
+            return nil unless connector_source_dest_stereotype(connector, :source).to_s.empty?
+
+            PlainSourceSeat.position(
+              connector: connector, anchor: anchor, box: box,
+              width: Ea::Fonts::Metrics.text_length(role, font_size, family: font_family)
+            )
+          end
+
+          def source_stair_positions(connector, anchor, text_box, mult_box, role)
+            return nil unless seat_font? && cambria_box?(text_box) && cambria_box?(mult_box)
+            return nil if role_empty?(role)
+
+            property = property_label?(connector, :source)
+            return nil unless property || connector_source_dest_stereotype(connector, :source).to_s.empty?
+
+            SourceStairSeat.positions(
+              connector: connector, anchor: anchor, text_box: text_box, mult_box: mult_box,
+              width: Ea::Fonts::Metrics.text_length(role, font_size, family: font_family)
+            )
+          end
+
+          def target_bend_positions(connector, bend, text_box, mult_box, role)
+            return nil unless bend && seat_font? && cambria_box?(text_box) && cambria_box?(mult_box)
+            return nil unless connector_source_dest_stereotype(connector, :target).to_s.empty? && !role_empty?(role)
+
+            TargetBendSeat.positions(
+              connector: connector, bend: bend, text_box: text_box, mult_box: mult_box,
+              width: Ea::Fonts::Metrics.text_length(role, font_size, family: font_family)
+            )
+          end
+
           # With stored boxes on the connector, an end that carries no
           # data of its own draws only its own stereotype; the data end
           # draws the role and multiplicity; with no data anywhere nothing
@@ -281,7 +342,7 @@ module Ea
             return nil unless direction == :up && cambria_box?(box)
             return nil unless [0, 1].include?(box["alignment"])
             return nil unless connector_source_dest_stereotype(connector, :source).empty?
-            return nil unless plain_role_route?(connector.style.to_h)
+            return nil unless plain_role_route?(connector.style.to_h, box)
 
             width = Ea::Fonts::Metrics.text_length(role, font_size, family: font_family)
             return nil unless width
@@ -290,6 +351,29 @@ module Ea
             [x - SEAT_X_INSET - width, y - 6]
           end
 
+          # Moved target Property clusters on horizontal arrivals share
+          # the leftward source seat relative to their stored corner.
+          def target_leftward_property_role(connector, heading, anchor, box, role)
+            return nil unless heading && heading[0].negative? && heading[1].zero?
+            return nil unless moved_target_property_box?(connector, box)
+            return nil unless horizontal_target_property_route?(connector.style.to_h)
+
+            width = Ea::Fonts::Metrics.text_length(role, font_size, family: font_family)
+            return nil unless width
+
+            x, y = seat_corner(anchor, box)
+            [x - property_role_offsets(:left).first - width, y - 7]
+          end
+
+          def moved_target_property_box?(connector, box)
+            plain_vertical_box?(box) && box["alignment"] == 1 && [31, 35].include?(box["cy"]) &&
+              !stored_offsets_zero?(box) && property_label?(connector, :target)
+          end
+
+          def horizontal_target_property_route?(style)
+            style.values_at(:mode, :lwidth) == %w[3 2] && [nil, "LH"].include?(style[:tree])
+          end
+
           # An upward target uses the downward property's right edge and
           # the upward target baseline, both relative to its stored corner.
           def target_property_role(connector, heading, anchor, box, role)
@@ -389,7 +473,9 @@ module Ea
             end
           end
 
-          def plain_role_route?(style)
+          def plain_role_route?(style, box)
+            return box["cy"] == 16 if orthogonal_stub_route?(style)
+
             %w[1 3].include?(style[:mode]) && %w[0 2].include?(style[:lwidth]) &&
               [nil, "V"].include?(style[:tree])
           end
@@ -473,6 +559,7 @@ module Ea
 
           def left_property_route?(style)
             downward_property_route?(style) || mode_two_route?(style) ||
+              (style[:overlap_ray] == true && style.values_at(:mode, :lwidth, :tree) == ["2", "0", nil]) ||
               (style[:mode] == "3" && %w[0 2].include?(style[:lwidth]) &&
                 [nil, "H", "LV"].include?(style[:tree]))
           end

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

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

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

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

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

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

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Label
+        # Moved plain target pairs on saved vertical stairs use the first
+        # bend, opposing 8px gutters and a baseline 3px above the saved OY.
+        module TargetBendSeat
+          def self.reference(points)
+            return nil unless points.size == 4
+
+            first, bend, corner, last = points
+            bend if descending_leg?(first, bend) && descending_leg?(corner, last) &&
+                    bend[1] == corner[1] && bend[0] != corner[0]
+          end
+
+          def self.descending_leg?(first, last)
+            first[0] == last[0] && first[1] < last[1]
+          end
+          private_class_method :descending_leg?
+
+          def self.positions(connector:, bend:, text_box:, mult_box:, width:)
+            return nil unless bend && width && connector.connector_type == "Association"
+            return nil unless connector.style.to_h.values_at(:mode, :lwidth, :tree) == %w[3 0 V]
+            return nil unless moved_box?(text_box, 31) && moved_box?(mult_box, 16)
+
+            [position(bend, text_box, -width - 8), position(bend, mult_box, 8)]
+          end
+
+          def self.position(bend, box, inset)
+            [bend[0] + box["ox"].to_i + inset, bend[1] + box["oy"].to_i - 3]
+          end
+          private_class_method :position
+
+          def self.moved_box?(box, height)
+            box["alignment"] == 1 && box["cy"] == height &&
+              [box["ox"].to_i, box["oy"].to_i] != [0, 0]
+          end
+          private_class_method :moved_box?
+        end
+      end
+    end
+  end
+end

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

@@ -15,6 +15,10 @@ module Ea
       # register rather than editing the orchestrator (OCP).
       module Label
         autoload :EndLabel, "ea/svg/ea_emitter/label/end_label"
+        autoload :TargetBendSeat, "ea/svg/ea_emitter/label/target_bend_seat"
+        autoload :SourceStairSeat, "ea/svg/ea_emitter/label/source_stair_seat"
+        autoload :PlainSourceSeat, "ea/svg/ea_emitter/label/plain_source_seat"
+        autoload :PlainTargetSeat, "ea/svg/ea_emitter/label/plain_target_seat"
         autoload :MidpointLabel, "ea/svg/ea_emitter/label/midpoint_label"
         autoload :Registry, "ea/svg/ea_emitter/label/registry"
       end

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

@@ -97,6 +97,7 @@ module Ea
                              mult_box: tgt_mb,
                              anchor: target_pt, connector: connector,
                              end_kind: :target, tree: tree && tree[:target],
+                             bend: Label::TargetBendSeat.reference(points),
                              heading: (stored_tgt || stored_labels) && target_heading(connector, points),
                              stored_labels: stored_labels).each { |t| texts << t }
           texts

data/lib/ea/theme/definition.rb

@@ -108,6 +108,7 @@ module Ea
         @geometry = geometry || DEFAULT_GEOMETRY.dup
         @frame = frame || DEFAULT_FRAME.dup
         @compartments = compartments || DEFAULT_COMPARTMENTS.dup
+        @attribute_spec_override = attribute_spec
         @attribute_spec = attribute_spec || DEFAULT_ATTR.dup
         @markers = markers || DEFAULT_MARKERS.dup
         @package = package || DEFAULT_PACKAGE.dup
@@ -137,6 +138,12 @@ module Ea
         @label_font_size_unit || font_size_unit
       end
 
+      # Attribute cells have a different inherited seat from enum literals,
+      # which continue to consume the legacy attribute_spec default.
+      def attribute_content_x_offset
+        @attribute_spec_override ? attribute_spec.content_x_offset : 22
+      end
+
       def with(**overrides)
         clear_label_override(overrides, :font_family, :label_font_family)
         clear_label_override(overrides, :font_family, :element_font_family)
@@ -193,7 +200,8 @@ module Ea
           marker_stroke_width: marker_stroke_width,
           text_width_factor: text_width_factor,
           geometry: geometry, frame: frame, compartments: compartments,
-          attribute_spec: attribute_spec, markers: markers,
+          # Preserve omission so reconstruction retains the attribute-cell default.
+          attribute_spec: @attribute_spec_override, markers: markers,
           package: package, note: note, fills: fills
         }
       end

data/lib/ea/version.rb

@@ -4,5 +4,5 @@ module Ea
   # Gem release version. Extracted to its own file so the
   # `gem-release` tool's `gem bump` can find and update it via the
   # standard `lib/<gem>/version.rb` convention.
-  VERSION = "0.6.127"
+  VERSION = "0.6.128"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ea
 version: !ruby/object:Gem::Version
-  version: 0.6.127
+  version: 0.6.128
 platform: ruby
 authors:
 - Ribose Inc.
@@ -940,7 +940,11 @@ files:
 - lib/ea/svg/ea_emitter/label.rb
 - lib/ea/svg/ea_emitter/label/end_label.rb
 - lib/ea/svg/ea_emitter/label/midpoint_label.rb
+- lib/ea/svg/ea_emitter/label/plain_source_seat.rb
+- lib/ea/svg/ea_emitter/label/plain_target_seat.rb
 - lib/ea/svg/ea_emitter/label/registry.rb
+- lib/ea/svg/ea_emitter/label/source_stair_seat.rb
+- lib/ea/svg/ea_emitter/label/target_bend_seat.rb
 - lib/ea/svg/ea_emitter/labels.rb
 - lib/ea/svg/ea_emitter/layer.rb
 - lib/ea/svg/ea_emitter/layer_sequencer.rb