ea 0.6.130 → 0.6.132

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

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Xmi
+      # Routes an XMI connector the way the QEA source does: the same
+      # center-ray ports and the same QEA route helpers, over the same
+      # inputs (link style, bends in `x:y;` form, connector type, endpoint
+      # boxes). Returns nil where QEA would fall back to bare SX/SY deltas,
+      # which the generic router keeps handling.
+      class StoredRoute < Qea::DiagramBuilder
+        Link = Struct.new(:style, :path, :geometry)
+        Connector = Struct.new(:connector_type)
+
+        def initialize
+          super(nil)
+        end
+
+        def waypoints(link:, connector_type:, source:, target:, bends:, offsets:, edge: nil)
+          connector = Connector.new(connector_type)
+          ports = { source: port_for(source, offsets[:source]), target: port_for(target, offsets[:target]) }
+          edge ||= 0
+          points = initial_points(link, connector, source, target, bends, ports, edge)
+          return unless points
+
+          finish(points, link, connector, source, target, bends, ports, offsets, edge)
+        end
+
+        private
+
+        # Placements here are already Ea::Model::Bounds.
+        def bounds_from_rect(bounds)
+          bounds
+        end
+
+        def ported?(offset)
+          offset.none?(&:nil?) && offset.any?(&:nonzero?)
+        end
+
+        def port_for(box, offset)
+          ray_port(box, offset) if ported?(offset)
+        end
+
+        def initial_points(link, connector, source, target, bends, ports, edge)
+          src = ports[:source] || element_edge_point(source, :source, edge)
+          tgt = ports[:target] || element_edge_point(target, :target, edge)
+          if Qea::DiagramStyleParser.parse(link.style)[:mode] == "1"
+            [src, tgt]
+          elsif edge == 2 && ports.values.all? && !valid_tree_path?(bends, source)
+            [src, [tgt[0], src[1]], tgt]
+          elsif edge == 2 && bends.size == 1
+            tree_points(source, target, bends.first)
+          elsif bends.any?
+            bent_points(src, bends, tgt, link, connector, source, target)
+          elsif ports.values.any?
+            [src, tgt]
+          end
+        end
+
+        def tree_points(src, tgt, bend)
+          target_y = tgt.y + tgt.height <= src.y ? tgt.y + tgt.height : tgt.y
+          [[src.x + src.width, bend[1]], [bend[0], bend[1]], [bend[0], target_y]]
+        end
+
+        def bent_points(src, bends, tgt, link, connector, source, target)
+          points = [src, *bends, tgt]
+          redock_parent_above(points, link, source, target) if connector.connector_type == "Generalization"
+          points
+        end
+
+        def finish(points, link, connector, source, target, bends, ports, offsets, edge)
+          tree_route = stored_tree_route(points, link, connector, source, target, ports)
+          if tree_route
+            points = tree_route
+          elsif %w[Association Aggregation].include?(connector.connector_type) && edge != 2
+            points = facing(points, link, connector, source, target, bends)
+          end
+          points = level_entry_route(points, link, connector, source, target) if bends.any? && !tree_route
+          points = drop_zero_length_tree_segments(points, link)
+          empty_path_ray(points, link, connector, source, target, bends, ports, offsets, edge)
+        end
+
+        # An empty Path has no authored corner to keep: a computed EDGE2 jog
+        # between ports that face across a gap becomes the straight port line.
+        def empty_path_ray(points, link, connector, source, target, bends, ports, offsets, edge)
+          style = Qea::DiagramStyleParser.parse(link.style)
+          return points unless %w[Generalization Aggregation].include?(connector.connector_type) &&
+                               points.size == 3 && bends.empty? && edge == 2 && ports.values.all? &&
+                               style[:mode] == "3" && style[:lwidth] == "2" && !style[:tree]
+          return points unless ray_gap?(source, target, offsets)
+
+          ports.values_at(:source, :target)
+        end
+
+        def ray_gap?(source, target, offsets)
+          return false unless source.x + source.width < target.x
+
+          [[source, offsets[:source]], [target, offsets[:target]]].all? do |box, (x, y)|
+            within_height?(stored_ray_origin(box, x, y).y, source) &&
+              within_height?(stored_ray_origin(box, x, y).y, target)
+          end
+        end
+
+        def stored_tree_route(points, link, connector, source, target, ports)
+          stored_square_route(link, connector, source, target) ||
+            stored_stair_route(link, connector, source, target) ||
+            stored_lateral_route(link, connector, source, target, ported: ports.values.all?) ||
+            derived_lateral_route(link, connector, source, target) ||
+            horizontal_tree_route(points, link, connector, source, target)
+        end
+
+        def facing(points, link, connector, source, target, bends)
+          stored_tree = preserve_stored_tree?(points, link, connector, source, target)
+          unless stored_tree || level_corner_route?(points, link, connector, source, target)
+            points = facing_edge_route(points, source, target)
+          end
+          if connector.connector_type == "Aggregation" && bends.any? && points.size >= 4 &&
+             (generalization_outline_offset(link, points.size) == 1 ||
+              (stored_tree && flush_width_zero_tree?(link)))
+            redock_parent_above(points, link, source, target, strict: true)
+          end
+          redock_vertical_tree_trunk(points, link, connector, source, target) if bends.any?
+          points
+        end
+
+        # EA's SX/SY (EX/EY) point from the box center toward the port,
+        # y up; the port is where that ray leaves the box.
+        def ray_port(bounds, offset)
+          dx = offset[0].to_f
+          dy = -offset[1].to_f
+          center_x = bounds.x + bounds.width / 2.0
+          center_y = bounds.y + bounds.height / 2.0
+          t = [ray_scale(dx, bounds.x, bounds.width, center_x),
+               ray_scale(dy, bounds.y, bounds.height, center_y)].min
+          [(center_x + t * dx).round, (center_y + t * dy).round]
+        end
+
+        def ray_scale(delta, origin, length, center)
+          return Float::INFINITY if delta.zero?
+
+          ((delta.positive? ? origin + length : origin) - center) / delta
+        end
+      end
+    end
+  end
+end

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

@@ -15,6 +15,7 @@ module Ea
           "uml:PrimitiveType" => "Ea::Model::PrimitiveType",
           "uml:Enumeration" => "Ea::Model::Enumeration",
           "uml:Interface" => "Ea::Model::Interface",
+          "uml:Signal" => "Ea::Model::Signal",
         }.freeze
 
         def class_for(xmi_type)

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

@@ -40,6 +40,14 @@ module Ea
 
         private
 
+        # Text of the shape's UMLKeywordLabel child; name labels and
+        # other labelled children never contribute a keyword.
+        def keyword_text(shape)
+          label = shape.xpath("./ownedElement[@*[local-name()=\"type\"]=\"umldi:UMLKeywordLabel\"]").first
+          text = label && label["text"]
+          text unless text.nil? || text.empty?
+        end
+
         def doc
           @doc ||= Nokogiri::XML(File.read(xmi_path))
         end
@@ -47,34 +55,14 @@ module Ea
         def keywords_by_diagram
           @keywords_by_diagram ||= begin
             result = {}
-            # The Sparx XMI export declares the umldi: namespace
-            # but the elements inside Diagram have lost their
-            # prefix binding once parsed by Nokogiri — the
-            # element name resolves to local-name "ownedElement"
-            # and the umldi:UMLClassifierShape type information
-            # lives in the literal `type` attribute. We therefore
-            # match shape children by the presence of `modelElement`
-            # and the keyword label by its `text` attribute.
             doc.xpath("//*[local-name()=\"Diagram\"]").each do |diagram|
               diagram_id = diagram["id"] || diagram["xmi:id"]
               next unless diagram_id
 
               keywords = {}
               diagram.xpath("./ownedElement[@modelElement]").each do |shape|
-                model_id = shape["modelElement"]
-                next unless model_id
-
-                # Keyword label is the first ownedElement child
-                # with a non-empty `text` attribute. The name
-                # label follows it.
-                shape.xpath("./ownedElement[@text]").each do |child|
-                  text = child["text"]
-                  next if text.nil? || text.empty?
-                  next if text.start_with?("«") # safety
-
-                  keywords[model_id] = text
-                  break
-                end
+                text = keyword_text(shape)
+                keywords[shape["modelElement"]] = text if text
               end
               result[diagram_id] = keywords unless keywords.empty?
             end

data/lib/ea/sources/xmi.rb

@@ -18,14 +18,18 @@ module Ea
       autoload :MetadataBuilder, "ea/sources/xmi/metadata_builder"
       autoload :PackageBuilder, "ea/sources/xmi/package_builder"
       autoload :ClassifierBuilder, "ea/sources/xmi/classifier_builder"
+      autoload :InstanceBuilder, "ea/sources/xmi/instance_builder"
       autoload :PropertyBuilder, "ea/sources/xmi/property_builder"
       autoload :OperationBuilder, "ea/sources/xmi/operation_builder"
+      autoload :ReceptionBuilder, "ea/sources/xmi/reception_builder"
       autoload :RelationshipBuilder, "ea/sources/xmi/relationship_builder"
       autoload :AnnotationBuilder, "ea/sources/xmi/annotation_builder"
       autoload :TagBuilder, "ea/sources/xmi/tag_builder"
       autoload :NoteBuilder, "ea/sources/xmi/note_builder"
       autoload :StereotypeBuilder, "ea/sources/xmi/stereotype_builder"
       autoload :DiagramBuilder, "ea/sources/xmi/diagram_builder"
+      autoload :StoredRoute, "ea/sources/xmi/stored_route"
+      autoload :ExtensionTypes, "ea/sources/xmi/extension_types"
       autoload :ExtensionElements, "ea/sources/xmi/extension_elements"
       autoload :ExtensionGeometryParser, "ea/sources/xmi/extension_geometry_parser"
       autoload :ExtensionStyleParser, "ea/sources/xmi/extension_style_parser"

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

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      # Bridges decorate resolved render paths; stored routes and marker seats
+      # remain centerlines. The connector's stored order key (reproducing EA's
+      # exported link order), rather than style group order, determines which
+      # connector passes over a crossing.
+      class ConnectorBridges
+        RADIUS = 6
+
+        def initialize(_diagram, routes)
+          @routes = routes.map { |connector, points| [connector, points, priority_for(connector)] }
+        end
+
+        def path_for(connector, points)
+          priority = priority_for(connector)
+          return centerline(connector, points) unless priority
+
+          segments = points.each_cons(2).map do |first, last|
+            crossings_for(connector, priority, first, last)
+          end
+          return centerline(connector, points) if segments.all?(&:empty?)
+
+          serialize(points, segments)
+        end
+
+        private
+
+        def centerline(connector, points)
+          seats = points.map { |point| coordinates(point) }
+          # Direct lines retain EA's target-first repeat and source-first model.
+          if points.size == 2 && direct?(connector)
+            "M #{seats.last} L #{seats.first} M #{seats.last}"
+          else
+            "M #{seats.join(" L ")}"
+          end
+        end
+
+        def direct?(connector)
+          style = connector.style || {}
+          style.key?(:direct) || style.key?("direct")
+        end
+
+        def serialize(points, segments)
+          commands = ["M #{coordinates(points.first)}"]
+          points.each_cons(2).with_index do |(first, last), index|
+            segments[index].each do |crossing|
+              commands.concat(arc_commands(first, last, crossing))
+            end
+            commands << "L #{coordinates(last)}"
+          end
+          commands.join(" ")
+        end
+
+        # nil or empty: no bridge decision for this connector.
+        def priority_for(connector)
+          connector.paint_order if connector.paint_order&.any?
+        end
+
+        def crossings_for(connector, priority, first, last)
+          axis = axis_for(first, last)
+          return [] unless axis
+
+          crossings = lower_routes(connector, priority).flat_map do |_partner, points, _order|
+            points.each_cons(2).filter_map do |start, finish|
+              crossing(first, last, start, finish, axis)
+            end
+          end
+          separate_crossings(crossings, axis).sort_by { |point| (point[axis] - first[axis]).abs }
+        end
+
+        # The order key is only proven across different start placements, so
+        # connectors leaving the same placement make no carrier decision.
+        def lower_routes(connector, priority)
+          @routes.select do |partner, _points, order|
+            !partner.equal?(connector) && order && order.size == priority.size &&
+              !same_source?(connector, partner) && (order <=> priority).negative?
+          end
+        end
+
+        def same_source?(connector, partner)
+          connector.source_element_ref && connector.source_element_ref == partner.source_element_ref
+        end
+
+        # Suppress both overlapping spans, including coincident crossings,
+        # so route order cannot select one of several ambiguous arcs.
+        def separate_crossings(crossings, axis)
+          crossings.reject.with_index do |point, index|
+            crossings.each_with_index.any? do |other, other_index|
+              index != other_index && (point[axis] - other[axis]).abs < 2 * RADIUS
+            end
+          end
+        end
+
+        def crossing(first, last, start, finish, axis)
+          return unless axis_for(start, finish) == 1 - axis
+
+          point = axis.zero? ? [start[0], first[1]] : [first[0], start[1]]
+          return unless segment_interior?(point, first, last, axis) &&
+                        segment_interior?(point, start, finish, 1 - axis)
+
+          point
+        end
+
+        def segment_interior?(point, first, last, axis)
+          interior?(point[axis], first[axis], last[axis])
+        end
+
+        def interior?(value, first, last)
+          minimum, maximum = [first, last].minmax
+          value > minimum && value < maximum &&
+            value - minimum >= RADIUS && maximum - value >= RADIUS
+        end
+
+        def axis_for(first, last)
+          return 0 if first[1] == last[1] && first[0] != last[0]
+          return 1 if first[0] == last[0] && first[1] != last[1]
+
+          nil
+        end
+
+        def arc_commands(first, last, crossing)
+          axis = axis_for(first, last)
+          direction = last[axis] > first[axis] ? 1 : -1
+          start = crossing.dup
+          finish = crossing.dup
+          start[axis] -= direction * RADIUS
+          finish[axis] += direction * RADIUS
+          ["L #{coordinates(start)}", "A #{RADIUS} #{RADIUS} 180 0 0 #{coordinates(finish)}"]
+        end
+
+        def coordinates(point)
+          point.map { |value| Canvas.coord(value) }.join(" ")
+        end
+      end
+    end
+  end
+end

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

@@ -16,9 +16,10 @@ module Ea
         # Returns replacement waypoint pairs for direct or lateral tree routes,
         # for the connector, or nil when the connector must keep its
         # parsed waypoints (not direct, not 2-point, unresolved ends,
-        # self-loop, or no drawn bounds for either end).
+        # self-loop, an authoritative UMLDI route, or no drawn bounds for either end).
         def pairs_for(connector, diagram, model_index, bounds_map)
           return nil unless bounds_map
+          return nil if connector.style.to_h[:umldi_route] == true
 
           tether = association_class_pairs(connector, bounds_map)
           return tether if tether
@@ -53,8 +54,8 @@ module Ea
 
           return nil if flush_lateral_line?(connector, points, source_bounds, target_bounds)
 
-          anchors = [connector.source_anchor, connector.target_anchor]
           bounds = [source_bounds, target_bounds]
+          anchors = drawn_center_anchors(connector, diagram, [source_ref, target_ref], bounds)
           original = clipped_pairs(bounds, anchors)
           unless stroke_outline?(connector, bounds) || overlap_ray?(connector) ||
                  bordered_outline?(connector, diagram, [source_ref, target_ref], bounds)
@@ -78,6 +79,38 @@ module Ea
           auto_port_elbow_pairs(connector, source, target, pairs)
         end
 
+        def drawn_center_anchors(connector, diagram, refs, bounds)
+          anchors = [connector.source_anchor, connector.target_anchor]
+          return anchors unless connector.style.to_h[:centered_origin_ray] == true
+
+          duids = connector.style.to_h.values_at(:soid, :eoid)
+          anchors.each_with_index.map do |anchor, index|
+            saved = unique_logical_bounds(diagram, refs[index], duids[index])
+            centered_anchor(anchor, saved, bounds[index])
+          end
+        end
+        private_class_method :drawn_center_anchors
+
+        def unique_logical_bounds(diagram, ref, duid)
+          placements = end_placements(diagram, ref, duid)
+          placements.first.bounds if placements.size == 1
+        end
+        private_class_method :unique_logical_bounds
+
+        def centered_anchor(anchor, saved, drawn)
+          return anchor unless anchor && saved
+
+          Ea::Model::Point.new(x: anchor.x + center_shift(saved, drawn, :x, :width),
+                               y: anchor.y + center_shift(saved, drawn, :y, :height))
+        end
+        private_class_method :centered_anchor
+
+        def center_shift(saved, drawn, coordinate, size)
+          drawn.public_send(coordinate) + drawn.public_send(size) / 2 -
+            saved.public_send(coordinate) - saved.public_send(size) / 2
+        end
+        private_class_method :center_shift
+
         # 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)
@@ -475,6 +508,7 @@ module Ea
         def row_slot_adjust(pairs, connector, diagram, model_index,
                             bounds_map, divider_y_by_ref)
           return nil unless bounds_map && divider_y_by_ref
+          return nil if connector.style.to_h[:umldi_route] == true
           return nil unless pairs.size == 2
           return nil if flush_overlap_ray?(connector)
           return nil if explicit_association_ray?(pairs, connector)

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

@@ -74,11 +74,14 @@ module Ea
         private
 
         def paths_with_styles
-          visible_connectors.filter_map do |connector|
-            path = path_for(connector)
-            next unless path
-
-            [[self.class.stroke_width_for(connector, stroke_width), dashed?(connector)], path]
+          routes = visible_connectors.filter_map do |connector|
+            points = resolved_points(connector)
+            [connector, points.map { |point| translate_point(point) }] if points.size >= 2
+          end
+          bridges = ConnectorBridges.new(diagram, routes)
+          routes.map do |connector, points|
+            [[self.class.stroke_width_for(connector, stroke_width), dashed?(connector)],
+             path_for(connector, points, bridges)]
           end
         end
 
@@ -103,39 +106,17 @@ module Ea
           (diagram.connectors || []).select(&:renderable?)
         end
 
-        def path_for(connector)
+        def resolved_points(connector)
           pts = ConnectorRedock.pairs_for(connector, diagram, model_index,
                                           drawn_bounds) ||
                 waypoints_for(connector)
-          pts = ConnectorRedock.row_slot_adjust(pts, connector, diagram,
-                                                model_index, drawn_bounds,
-                                                divider_y_by_ref) || pts
-          return nil if pts.size < 2
-
-          # DIRECT (auto-routed straight) connectors: EA writes the
-          # segment TARGET-FIRST with a trailing zero-length repeat —
-          # "M target L source M target" (B6847577, E58034A3,
-          # 8CF27BE8). Same pixels as source-first; only the byte
-          # order differs, so reversal lives here at the emitter and
-          # the marker anchoring (source = first waypoint) is
-          # untouched.
-          if pts.size == 2 && direct?(connector)
-            x1, y1 = translate_point(pts.first)
-            x2, y2 = translate_point(pts.last)
-            d = "M #{Canvas.coord(x2)} #{Canvas.coord(y2)} L #{Canvas.coord(x1)} #{Canvas.coord(y1)} " \
-                "M #{Canvas.coord(x2)} #{Canvas.coord(y2)}"
-          else
-            d = pts.each_with_index.map do |p, idx|
-              x, y = translate_point(p)
-              "#{idx.zero? ? 'M' : 'L'} #{Canvas.coord(x)} #{Canvas.coord(y)}"
-            end.join(" ")
-          end
-          %(<path d="#{d}" shape-rendering="auto"/>)
+          ConnectorRedock.row_slot_adjust(pts, connector, diagram,
+                                          model_index, drawn_bounds,
+                                          divider_y_by_ref) || pts
         end
 
-        def direct?(connector)
-          style = connector.style || {}
-          style.key?(:direct) || style.key?("direct")
+        def path_for(connector, pts, bridges)
+          %(<path d="#{bridges.path_for(connector, pts)}" shape-rendering="auto"/>)
         end
 
         def waypoints_for(connector)
@@ -146,10 +127,10 @@ module Ea
           end
         end
 
-        def translate_point(p)
-          return p unless @canvas
+        def translate_point(point)
+          return point unless @canvas
 
-          [@canvas.translate_x(p[0]), @canvas.translate_y(p[1])]
+          [@canvas.translate_x(point[0]), @canvas.translate_y(point[1])]
         end
       end
     end

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

@@ -54,12 +54,14 @@ module Ea
           #   end_kind   - :source or :target
           #   heading    - [dx, dy] of the first leg leaving the anchor
           #   source_bounds - effective drawn source outline, in anchor coordinates
+          #   target_face - exact drawn target dock face when it leads the emitted leg
           #   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, bend: nil, source_bounds: nil)
+                    tree: false, heading: nil, stored_labels: false, bend: nil, source_bounds: nil,
+                    target_face: 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,
@@ -114,13 +116,23 @@ module Ea
                          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
+              if horizontal_aligned_target_baseline?(connector, heading, text_box, role)
+                text_pos = [text_pos[0], seat_corner(anchor, text_box)[1] - 7]
+              end
+              face_multiplicity = if target_left_face_multiplicity?(connector, heading, mult_box, mult,
+                                                                    target_face)
+                                    directional_multiplicity(:left, anchor, mult_box, mult)
+                                  end
               mult_pos = target_multiplicity_seat(connector, heading, anchor, mult_box) ||
-                         target_horizontal_multiplicity(heading, anchor, mult_box, mult) || mult_pos
+                         face_multiplicity || target_horizontal_multiplicity(heading, anchor, mult_box, mult) ||
+                         mult_pos
             end
 
             if end_kind == :source
               text_pos = source_top_property_role(connector, heading, anchor, text_box, role) ||
                          source_bottom_property_role(connector, heading, anchor, text_box, role) || text_pos
+              mult_pos = source_top_property_multiplicity(connector, heading, anchor,
+                                                          [text_box, mult_box], mult) || mult_pos
               if external_upward_property_source?(connector, heading, anchor, text_box, source_bounds)
                 text_pos = external_upward_property_role(anchor, role) || text_pos
               end
@@ -143,6 +155,23 @@ module Ea
 
           private
 
+          # ALN2 single-line target roles retain their horizontal placement
+          # and use the saved corner's baseline on a straight stored ray.
+          def horizontal_aligned_target_baseline?(connector, heading, box, role)
+            return false unless heading && heading[1].zero? && !heading[0].zero?
+            return false unless saved_target_ray?(connector) && !role_empty?(role)
+            return false unless connector_source_dest_stereotype(connector, :target).to_s.empty?
+
+            aligned_target_baseline_box?(box)
+          end
+
+          def aligned_target_baseline_box?(box)
+            return false unless seat_font? && font_weight == 400 && font_style == "normal"
+            return false unless box && box["alignment"] == 2 && [13, 14].include?(box["cy"])
+
+            cambria_box?(box.merge("alignment" => 0))
+          end
+
           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)
@@ -339,14 +368,27 @@ module Ea
           # EDGE=1 certifies the top dock independently of the clipped ray's
           # heading. An absent source box uses the upward Property seat.
           def source_top_property_role(connector, heading, anchor, box, role)
-            return nil unless source_seat?(:source, heading) && heading[0].negative? && heading[1].positive?
-            return nil unless zero_source_property_box?(box)
-
-            return nil unless source_top_property_route?(connector.style.to_h)
+            return nil unless source_top_property_box?(connector, heading, box)
 
             source_property_seat(connector, :up, anchor, box, role)
           end
 
+          def source_top_property_multiplicity(connector, heading, anchor, boxes, mult)
+            return nil if mult_empty?(mult)
+
+            role_box, mult_box = boxes
+            return nil unless source_top_property_box?(connector, heading, role_box)
+            return nil unless source_top_property_box?(connector, heading, mult_box)
+
+            mult_seat(:up, anchor, mult_box)
+          end
+
+          def source_top_property_box?(connector, heading, box)
+            source_seat?(:source, heading) && heading[0].negative? && heading[1].positive? &&
+              zero_source_property_box?(box) && source_top_property_route?(connector.style.to_h) &&
+              source_property_seat?(connector, :up, box)
+          end
+
           # A persisted origin above the drawn source outline keeps the
           # upward seat's inset and the shared upper baseline, including
           # steep diagonals. Origins clipped onto the face retain -6.
@@ -697,11 +739,21 @@ module Ea
           def target_horizontal_multiplicity(heading, anchor, box, mult)
             return nil unless seat_font? && heading && heading[1].zero? && !heading[0].zero?
             return nil if mult_empty?(mult)
+
             return directional_multiplicity(:left, anchor, box, mult) if heading[0].negative?
 
             mult_seat(:right, anchor, box)
           end
 
+          def target_left_face_multiplicity?(connector, heading, box, mult, target_face)
+            seat_font? && !mult_empty?(mult) && property_label?(connector, :target) && cambria_box?(box) &&
+              stored_offsets_zero?(box) && target_left_face_heading?(heading, target_face)
+          end
+
+          def target_left_face_heading?(heading, target_face)
+            heading && !heading[1].zero? && heading[0].negative? && target_face == [-1, 0]
+          end
+
           def target_multiplicity_seat(connector, heading, anchor, box)
             return nil unless seat_font?
             return nil unless heading && heading[0].zero? && heading[1].negative?

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

@@ -100,6 +100,7 @@ module Ea
                              end_kind: :target, tree: tree && tree[:target],
                              bend: Label::TargetBendSeat.reference(points),
                              heading: (stored_tgt || stored_labels) && target_heading(connector, points),
+                             target_face: target_dock_heading(connector, target_pt, target_heading(connector, points)),
                              stored_labels: stored_labels).each { |t| texts << t }
           texts
         end
@@ -202,6 +203,29 @@ module Ea
           drawn_bounds[source]
         end
 
+        def target_dock_bounds(connector)
+          return nil unless model_index && drawn_bounds
+
+          relationship = model_index[connector.relationship_ref]
+          return nil unless relationship
+
+          source, target = ConnectorRedock.end_refs(relationship)
+          return nil if source == target
+          return nil unless drawn_bounds[source]
+
+          drawn_bounds[target]
+        end
+
+        def target_dock_heading(connector, point, heading)
+          return nil unless heading
+
+          box = target_dock_bounds(connector)
+          face = box && dock_face_heading(point, box)
+          return nil unless face&.zip(heading)&.any? { |axis, delta| (axis * delta).positive? }
+
+          face
+        end
+
         # Saved rays can start outside the box. Project onto its boundary;
         # corners stay ambiguous and the face must still lead the emitted leg.
         def source_dock_heading(connector, point, box)