ea 0.6.138 → 0.6.140

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0c2231b8d009e8d99c841920776cbe8539e09b76d512beed109f073fb7904282
-  data.tar.gz: 3feade927368b299842047c9c0e31aa0cb8473e7dad6870e5626fb369e1503de
+  metadata.gz: 9db50e16de6c9f9faa698a872686600da15ba3eef0787de0b18b0ea56eca0394
+  data.tar.gz: b537f2b76e1fdb3a5a6dcfd1581db9f651279c5aff4e35882144da2ace23cf26
 SHA512:
-  metadata.gz: 025f36b456316a6fcd801318f17c27363d62d3ee7355cd303c1b7147081f44d3b70fdf711966ae4a5a7fc33e022dc097ba4d6f15f6c3ad03e237d59318b89fac
-  data.tar.gz: d2487edce57559735c9cdf42984dd16ad3597985fb5d2f01ddeb9289c893b423a986f8587b3788d0cd759aaca93661c8e0a86262a4939f503d21e9495e29db9f
+  metadata.gz: 9a685c1155369f6800fbfd294feed39ea2b450f482245c30be940c18bb31098466be6dbb0f0e6ca28e90502798ceaf10c8a5bbac0f0739b619b1cc0cd69696cb
+  data.tar.gz: 570de8eaf44e482c0330cc96f17eb2ab89e26a75542c613617b53468040b45dfec9ce597b308cd50b068d0a78e20e415a9cda9e897622f1cc1b1ab2a4e110baa

data/lib/ea/fonts/metrics.rb

@@ -59,6 +59,8 @@ module Ea
                                          File.expand_path("cjk_fallback_widths.json", __dir__)
                                        )).fetch("widths").freeze
       CJK_FALLBACK_FAMILIES = %w[Carlito Cambria].freeze
+      # Logical height from which a bold Cambria CJK run uses regular advances.
+      CAMBRIA_REGULAR_BOLD_MIN_HEIGHT = 17
       # Carlito ASCII advances measured on Windows per "height:weight:style";
       # they take precedence over the quantized design advances.
       CARLITO_GDI_WIDTHS = JSON.parse(File.read(
@@ -71,7 +73,7 @@ module Ea
                                             )).fetch("advance").freeze
       private_constant :CAMBRIA_7_REGULAR_WIDTHS, :CAMBRIA_7_STYLED_WIDTHS,
                        :CAMBRIA_7_GUILLEMET_PAIR_WIDTH, :VERTICAL_METRICS,
-                       :CJK_FALLBACK_WIDTHS, :CJK_FALLBACK_FAMILIES,
+                       :CJK_FALLBACK_WIDTHS, :CJK_FALLBACK_FAMILIES, :CAMBRIA_REGULAR_BOLD_MIN_HEIGHT,
                        :CARLITO_GDI_WIDTHS, :SOURCE_SANS_PRO_ADVANCES
 
       # Advance used for codepoints missing from the tables.
@@ -205,7 +207,7 @@ module Ea
       private_class_method :measured_carlito_widths
 
       def cambria_text_length(text, size_pt, weight, style)
-        return nil unless size_pt.to_f.to_r == 7
+        return cambria_cjk_only_length(text, size_pt, weight, style) unless size_pt.to_f.to_r == 7
         return nil unless ["", "0", "400", "normal", "700", "bold"].include?(weight.to_s)
         return nil unless ["", "normal", "italic"].include?(style.to_s)
 
@@ -220,6 +222,24 @@ module Ea
       end
       private_class_method :cambria_text_length
 
+      # Cambria has no Latin table outside 7pt, but a run made only of
+      # characters in the measured MS UI Gothic table is exact at any
+      # measured height. EMPIRICAL FIT (decision a): EA draws a bold
+      # Cambria CJK run at logical height >= 17 with the regular-weight
+      # advances (no synthetic-bold pixel), although the Windows table
+      # records one. Checked on the 116 native legend titles "凡例"
+      # (Cambria bold 12pt, H17): native textLength 34 = 2 x 17, where
+      # the 17:700 entry would give 36. Below H17 bold keeps the bold
+      # table (native 7pt bold "都市計画データ" = 70).
+      def cambria_cjk_only_length(text, size_pt, weight, style)
+        height = gdi_logical_height(size_pt)
+        bold = bold?(weight) && height < CAMBRIA_REGULAR_BOLD_MIN_HEIGHT
+        widths = cjk_fallback_widths("Cambria", height, bold ? 700 : 400, style)
+        advances = text.each_char.map { |char| widths[char] }
+        advances.sum unless advances.include?(nil)
+      end
+      private_class_method :cambria_cjk_only_length
+
       def cambria_cjk_widths(weight, style)
         cjk_fallback_widths("Cambria", gdi_logical_height(7), weight, style)
       end

data/lib/ea/model/note.rb

@@ -15,6 +15,7 @@ module Ea
       attribute :body, :string
       attribute :note_type, :string # "Note" | "Text" | "File"
       attribute :legend, Legend
+      attribute :package_id, :string # containing package
 
       json do
         map "id", to: :id
@@ -22,6 +23,7 @@ module Ea
         map "body", to: :body
         map "noteType", to: :note_type
         map "legend", to: :legend
+        map "packageId", to: :package_id
       end
     end
   end

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

@@ -6,6 +6,8 @@ module Ea
       class DiagramBuilder
         # Internal geometry for choosing the facing edges of stored routes.
         module Routing
+          REVERSED_TREE_BUS_OFFSET = 50
+
           private
 
           # Offsets stay attached to semantic Start/End IDs even when the
@@ -32,6 +34,100 @@ module Ea
             model
           end
 
+          # EMPIRICAL FIT (decision a), not a source-backed rule. A width-0
+          # Mode 3 vertical-tree Association whose saved SOID/EOID name the
+          # relationship's ends in reverse keeps a Path (bus height and
+          # bend order) that EA no longer draws: its native export routes
+          # from the semantic Start box to the End box, with the bus 50px
+          # beyond the End box's facing edge (the distance every stored tree
+          # bus in the corpus keeps from its End box, 600+ links), the Start
+          # leg at center + SX and the End leg at center + EX. Checked on
+          # plateau diagram 5038EEE3 connectors 208, 209 and 212 (exact);
+          # 211 and 902 follow the leg pull documented on reversed_tree_leg.
+          def reversed_tree_route(model, link_row, diagram_row, geom, context)
+            return model if context || !reversed_tree_link?(model, link_row, diagram_row, geom)
+
+            start, finish = stored_ray_boxes(link_row, diagram_row)
+            bus, start_edge, finish_edge = reversed_tree_levels(start, finish)
+            return model unless bus
+
+            first = reversed_tree_leg(start, geom[:sx], geom[:sy], start_edge, finish)
+            last = reversed_tree_leg(finish, geom[:ex], geom[:ey], finish_edge, start)
+            model.waypoints = [first, [first[0], bus], [last[0], bus], last].map do |x, y|
+              Ea::Model::Waypoint.new(position: Ea::Model::Point.new(x: x, y: y))
+            end
+            model.source_anchor = model.source_port = model.waypoints.first.position
+            model.target_anchor = model.target_port = model.waypoints.last.position
+            # EMPIRICAL FIT: a leg that starts beside its box (5038EEE3
+            # connector 212) seats its source labels like a leftward leg.
+            model.style = model.style.to_h.merge(left_seated_source: true) if first[1] != start_edge
+            model
+          end
+
+          # EMPIRICAL FIT (decision a). EA seats the source labels of a
+          # vertical lateral tree ("LV") whose SOID/EOID name the ends in
+          # reverse as if the source leg left to the left, whichever way the
+          # route leaves the box. Measured on the only such link in the
+          # plateau corpus, 5038EEE3 connector 207 (+lod1MultiSurface).
+          def mark_reversed_lateral_tree(model, link_row, diagram_row, context)
+            return model if context
+
+            style = DiagramStyleParser.parse(link_row.style)
+            return model unless style[:tree] == "LV" && model.connector_type == "Association"
+            return model unless placement_order_reversed?(style, diagram_row,
+                                                          database.find_connector(link_row.connectorid))
+
+            model.style = model.style.to_h.merge(left_seated_source: true)
+            model
+          end
+
+          def reversed_tree_link?(model, link_row, diagram_row, geom)
+            style = DiagramStyleParser.parse(link_row.style)
+            model.connector_type == "Association" &&
+              style.values_at(:mode, :lwidth, :tree) == %w[3 0 V] &&
+              geom.values_at(:sx, :sy, :ex, :ey).all? &&
+              stored_bus_levels(link_row) &&
+              placement_order_reversed?(style, diagram_row, database.find_connector(link_row.connectorid))
+          end
+
+          def stored_bus_levels(link_row)
+            bends = intermediate_waypoints(link_row)
+            bends.size == 2 && bends.first[1] == bends.last[1]
+          end
+
+          # [bus height, Start facing edge, End facing edge] for vertically
+          # separated boxes: the bus sits 50px past the End box's edge and
+          # must stay inside the gap. Nil otherwise.
+          def reversed_tree_levels(start, finish)
+            if finish.y + finish.height < start.y
+              bus = finish.y + finish.height + REVERSED_TREE_BUS_OFFSET
+              [bus, start.y, finish.y + finish.height] if bus < start.y
+            elsif start.y + start.height < finish.y
+              bus = finish.y - REVERSED_TREE_BUS_OFFSET
+              [bus, start.y + start.height, finish.y] if bus > start.y + start.height
+            end
+          end
+
+          # A leg runs vertically at the stored origin's x. It starts on the
+          # facing edge, unless the origin lies beside the box (outside its
+          # x-span but level with it), where the origin itself is kept.
+          #
+          # EMPIRICAL FIT (decision a): the leg's x is pulled toward the box
+          # centre by |offset_y| / (vertical centre distance to the other box).
+          # Checked on 5038EEE3 connectors 211 (SX 41, SY -125: native 13px
+          # left of centre+SX), 902 (SX 64, SY -13: 2px) and 212, 208, 209
+          # (SY within 5: the rounded-up pull leaves centre + SX unchanged);
+          # the offset is rounded away from zero, as all five require.
+          # Derived from these five SX/SY pairs, not from EA documentation.
+          def reversed_tree_leg(box, offset_x, offset_y, edge_y, other)
+            span = ((other.y + other.height / 2.0) - (box.y + box.height / 2.0)).abs
+            pull = span.positive? ? 1 - [offset_y.to_i.abs / span, 1].min : 1
+            pulled = (offset_x.to_i.abs * pull).ceil * (offset_x.to_i.negative? ? -1 : 1)
+            origin = stored_ray_origin(box, pulled, offset_y)
+            beside = !origin.x.between?(box.x, box.x + box.width) && origin.y.between?(box.y, box.y + box.height)
+            [origin.x, beside ? origin.y : edge_y]
+          end
+
           # Path follows SOID/EOID placement order, independently of the
           # relationship's Start/End IDs. Only a complete, unique DUID pair
           # can reverse the authored single-corner route.
@@ -42,6 +138,10 @@ module Ea
                                 parse_geometry_fields(link_row.geometry)[:edge] == 2 &&
                                 intermediate_waypoints(link_row).size == 1
 
+            placement_order_reversed?(style, diagram_row, connector)
+          end
+
+          def placement_order_reversed?(style, diagram_row, connector)
             ids = style.values_at(:soid, :eoid)
             return false if ids.any? { |id| id.to_s.empty? } || ids.uniq.size != 2
 
@@ -695,8 +795,7 @@ module Ea
               return nil
             end
 
-            first = outline_dock(corners[0], corners[1], source)
-            last = outline_dock(corners[-1], corners[-2], target)
+            first, last = stair_docks(link_row, corners, source, target)
             return nil unless distinct_stair_docks?(corners, first, last)
 
             [first, *corners, last]
@@ -728,6 +827,45 @@ module Ea
             :horizontal if from[1] == to[1] && from[0] != to[0]
           end
 
+          def stair_docks(link_row, corners, source, target)
+            geom = parse_geometry_fields(link_row.geometry)
+            [stair_dock(corners[0], corners[1], source, geom.values_at(:sx, :sy)),
+             stair_dock(corners[-1], corners[-2], target, geom.values_at(:ex, :ey))]
+          end
+
+          # A corner level with its box docks on the outline the leg points at.
+          # When the stored origin sits off that row, EA aims the last leg at
+          # the origin instead and the dock slants onto the same outline
+          # (30D62231 connector 601: bend row 430, origin row 425, dock row 428).
+          def stair_dock(corner, neighbour, box, offsets)
+            dock = outline_dock(corner, neighbour, box)
+            return dock unless dock && offsets.none?(&:nil?)
+
+            origin = stored_ray_origin(box, *offsets)
+            return dock unless inside_box?(origin, grown_bounds(box, 1))
+
+            slanted_dock([origin.x, origin.y], corner, dock) || dock
+          end
+
+          # Where the line from the stored origin to the corner meets the
+          # outline row/column of the orthogonal dock; the other axis floors.
+          def slanted_dock(origin, corner, dock)
+            axis = dock[0] == corner[0] ? 1 : 0
+            other = intercept(origin, corner, axis, dock[axis])
+            return unless other
+
+            axis.zero? ? [dock[0], other] : [other, dock[1]]
+          end
+
+          def intercept(origin, corner, axis, face)
+            run = corner[axis] - origin[axis]
+            fraction = Rational(face - origin[axis], run) unless run.zero?
+            return unless fraction&.between?(0, 1)
+
+            other = 1 - axis
+            (origin[other] + fraction * (corner[other] - origin[other])).floor
+          end
+
           # The dock runs perpendicular to the corner's own leg.
           def outline_dock(corner, neighbour, box)
             if corner[1] == neighbour[1]

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

@@ -128,6 +128,7 @@ module Ea
           @current_obj_row = obj_row
           style_hash = DiagramStyleParser.parse(obj_row.objectstyle)
           style_hash[:stored_attribute_order] = true
+          style_hash["connector_proxy"] = true if connector_proxy?(obj_row)
           fqname = stereotype_fqname_for(obj_row)
           style_hash[:stereotype_fqname] = fqname if fqname
           font_style = effective_font_style(obj_row, style_hash)
@@ -154,6 +155,12 @@ module Ea
           )
         end
 
+        # EA anchors association-class links on ProxyConnector stubs and
+        # never draws them (the XMI source flags them the same way).
+        def connector_proxy?(obj_row)
+          database.find_object(obj_row.ea_object_id)&.object_type == "ProxyConnector"
+        end
+
         # Negative widths inherit; QEA zero widths request a one-pixel cosmetic pen.
         def effective_line_width(obj_row, style)
           object = database.find_object(obj_row.ea_object_id)
@@ -475,6 +482,7 @@ module Ea
             style: context ? { direct: true } :
                      DiagramStyleParser.parse(link_row.style),
             hidden: hidden?(link_row),
+            line_width: connector&.isbold,
             ghost_labels: ghost_labels_for(connector, diagram_row, link_row),
             has_geometry_offsets: geometry_has_offsets?(link_row.geometry),
             is_substitutable: substitutable_connector?(connector)
@@ -494,6 +502,8 @@ module Ea
           model = mark_default_square_ray(model, link_row, geom, context)
           model = restore_stored_square_ports(model, link_row, diagram_row, geom, context)
           model = reversed_stored_corner(model, link_row, diagram_row, geom, context)
+          model = reversed_tree_route(model, link_row, diagram_row, geom, context)
+          model = mark_reversed_lateral_tree(model, link_row, diagram_row, context)
           mark_association_class(model, connector, diagram_row)
         end
 

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

@@ -38,10 +38,16 @@ module Ea
             name: obj.name,
             body: obj.note,
             note_type: obj.object_type,
-            legend: legend_for(obj)
+            legend: legend_for(obj),
+            package_id: package_id_for(obj)
           )
         end
 
+        def package_id_for(obj)
+          pkg = database.find_package(obj.package_id)
+          pkg && IdNormalizer.from_guid(pkg.ea_guid)
+        end
+
         def note_type?(object_type)
           object_type == NOTE_OBJECT_TYPE || object_type == TEXT_OBJECT_TYPE
         end

data/lib/ea/sources/xmi/diagram_builder/element_borders.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Xmi
+      class DiagramBuilder
+        # An element placed without its own LWth takes the border width saved on
+        # the model element (<style appearance="...BorderWidth=n;...">), the same
+        # t_object.BorderWidth fallback the QEA source applies. Checked on
+        # AB281AC1, where the missing width left the Association 1px long.
+        class ElementBorders
+          def initialize(root)
+            @elements = root.extension&.elements&.element.to_a.to_h { |element| [element.idref, element] }
+          end
+
+          def width_for(subject)
+            appearance = @elements[subject]&.style&.appearance.to_s
+            raw = ExtensionStyleParser.split_pairs(appearance)["BorderWidth"]
+            return nil if raw.nil? || raw.to_i.negative?
+
+            [raw.to_i, 1].max
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -12,6 +12,7 @@ module Ea
         autoload :ConnectorMetadata, "ea/sources/xmi/diagram_builder/connector_metadata"
         autoload :AssociationClassMetadata, "ea/sources/xmi/diagram_builder/association_class_metadata"
         autoload :FontSettings, "ea/sources/xmi/diagram_builder/font_settings"
+        autoload :ElementBorders, "ea/sources/xmi/diagram_builder/element_borders"
         autoload :StereotypeProfiles, "ea/sources/xmi/diagram_builder/stereotype_profiles"
         autoload :UmldiEdges, "ea/sources/xmi/diagram_builder/umldi_edges"
 
@@ -135,7 +136,7 @@ module Ea
             image_bounds: (build_bounds(geom.img_left, geom.img_top, geom.img_right, geom.img_bottom) unless bounds),
             background_color: style.background_color,
             line_color: style.line_color,
-            line_width: style.line_width,
+            line_width: placed_line_width(style, placed.subject),
             font_family: font[:family],
             font_size: font[:size],
             font_size_unit: "pt",
@@ -155,6 +156,17 @@ module Ea
 
         # XMI preserves UML member order in ownedAttribute. Carry that
         # provenance to the renderer so it does not replace it with a name sort.
+        # LWth on the placement, else the model element's saved border width.
+        # A negative LWth (-1) inherits; zero requests the one-pixel cosmetic
+        # pen, as in the QEA source. Checked on 01661E1B (LWth=-1 over
+        # BorderWidth=2) and 1A10EB6D (LWth=0, native stroke-width 1).
+        def placed_line_width(style, subject)
+          own = style.line_width
+          return [own, 1].max if own && own >= 0
+
+          (@element_borders ||= ElementBorders.new(root)).width_for(subject)
+        end
+
         def element_style(subject)
           style = (@stereotype_profiles ||= StereotypeProfiles.new(root)).for(subject)
           return style unless source_ordered_classifiers.include?(subject)
@@ -179,8 +191,8 @@ module Ea
           return nil unless left && top && right && bottom
 
           Ea::Model::Bounds.new(x: left, y: top,
-                                 width: right - left,
-                                 height: bottom - top)
+                                width: right - left,
+                                height: bottom - top)
         end
 
         def build_connectors(placed_connectors, placed_elements, owner_id, context)
@@ -245,7 +257,7 @@ module Ea
             waypoints: route[:waypoints],
             style: route[:style],
             line_color: style.color,
-            line_width: style.line_width,
+            line_width: ext_meta[:line_width],
             hidden: style.hidden,
             label_boxes: connector_label_boxes(placed, ext_meta[:ea_type],
                                                options.fetch(:context) ? nil : owner_id)
@@ -257,7 +269,10 @@ module Ea
                                                                   connector.label_boxes)
                                          end
           mark_stored_ray(connector, placed, source, target) unless options.fetch(:context)
-          mark_association_route(connector, placed, source, target) unless options.fetch(:context)
+          unless options.fetch(:context)
+            reversed = reversed_placement?(style, by_duid, edge_source, edge_target)
+            mark_association_route(connector, placed, source, target, reversed)
+          end
           connector
         end
 
@@ -280,7 +295,9 @@ module Ea
 
           metadata = stored_ray_metadata(connector, placed, source, target)
           metadata.each { |name, value| connector.public_send("#{name}=", value) }
-          connector.style[:association_ray_outline] = true unless metadata.empty?
+          return if metadata.empty? || connector.connector_type == "Generalization"
+
+          connector.style[:association_ray_outline] = true
         end
 
         def stored_ray_metadata(connector, placed, source, target, stage: :ray_metadata)
@@ -291,9 +308,20 @@ module Ea
           StoredRoute.new.public_send(stage, connector, link: link, bounds: bounds, offsets: offsets, edge: geom.edge)
         end
 
-        def mark_association_route(connector, placed, source, target)
+        def mark_association_route(connector, placed, source, target, reversed)
+          connector.style[:reversed_ends] = true if reversed
           metadata = stored_ray_metadata(connector, placed, source, target, stage: :association_route)
           metadata.each { |name, value| connector.public_send("#{name}=", value) }
+          connector.style.delete(:reversed_ends)
+        end
+
+        # Mirrors QEA placement_order_reversed?: SOID and EOID must both name
+        # placements on this diagram and be crossed against the relationship's
+        # ends. A stale DUID resolves to nothing and is not a reversal.
+        def reversed_placement?(style, by_duid, edge_source, edge_target)
+          source = by_duid[style.soid]
+          target = by_duid[style.eoid]
+          source && target && reversed_ends?(source, target, edge_source, edge_target)
         end
 
         def mark_plain_source_seat(connector, placed, context)
@@ -356,12 +384,13 @@ module Ea
 
         def connector_meta(subject_id)
           connector = connector_index[subject_id]
-          return { ea_type: nil, direction: nil } unless connector
+          return { ea_type: nil, direction: nil, line_width: nil } unless connector
 
           props = connector.properties
           {
             ea_type: props&.ea_type,
-            direction: props&.direction
+            direction: props&.direction,
+            line_width: connector.appearance&.linewidth
           }.merge(connector_metadata.for(connector))
         end
 
@@ -513,8 +542,8 @@ module Ea
           return nil unless g.left && g.top && g.right && g.bottom
 
           Ea::Model::Bounds.new(x: g.left, y: g.top,
-                                 width: g.right - g.left,
-                                 height: g.bottom - g.top)
+                                width: g.right - g.left,
+                                height: g.bottom - g.top)
         end
 
         def edge_point(placed, edge_code, _end_kind)

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

@@ -40,7 +40,8 @@ module Ea
             name: ext_element.name,
             body: ext_element.properties&.documentation,
             note_type: note_type,
-            legend: legend_for(ext_element, note_type)
+            legend: legend_for(ext_element, note_type),
+            package_id: IdNormalizer.from_xmi_id(ext_element.model&.package)
           )
         end
 

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Xmi
+      class StoredRoute < Qea::DiagramBuilder
+        # QEA's reversed-end Association rules for XMI. A connector is reversed
+        # when its SOID names a placement other than the relationship's source
+        # (builder flag :reversed_ends). Geometry helpers come from
+        # Qea::DiagramBuilder::Routing, so both sources share one rule.
+        module ReversedRoutes
+          private
+
+          # A width-0 vertical-tree Association takes the bus 50px past the End
+          # box's facing edge with legs at the stored origins (an empirical fit,
+          # see Routing#reversed_tree_route; checked on 5038EEE3).
+          def reversed_tree_metadata(model, link, bounds, offsets, edge)
+            return {} unless reversed_tree_candidate?(model, link, bounds, offsets)
+
+            start, finish = bounds.values_at(:source, :target)
+            bus, start_edge, finish_edge = reversed_tree_levels(start, finish)
+            return {} unless bus
+
+            geom = ray_geometry(offsets, edge)
+            first = reversed_tree_leg(start, geom[:sx], geom[:sy], start_edge, finish)
+            last = reversed_tree_leg(finish, geom[:ex], geom[:ey], finish_edge, start)
+
+            reversed_tree_fields(model, first, last, bus, first[1] != start_edge)
+          end
+
+          def reversed_tree_fields(model, first, last, bus, beside)
+            style = model.style.to_h.except(:umldi_route, :reversed_ends)
+            style[:left_seated_source] = true if beside
+            ends = [point_for(first), point_for(last)]
+            { waypoints: points_to_waypoints([first, [first[0], bus], [last[0], bus], last]),
+              source_anchor: ends[0], target_anchor: ends[1], source_port: ends[0], target_port: ends[1],
+              style: style }
+          end
+
+          def reversed_tree_candidate?(model, link, bounds, offsets)
+            model.connector_type == "Association" && model.style[:reversed_ends] &&
+              model.style.to_h.values_at(:mode, :lwidth, :tree) == %w[3 0 V] &&
+              ray_inputs?(bounds, offsets) && stored_bus_levels(link)
+          end
+
+          # A thin Mode 3 EDGE 2 Association whose single saved corner follows
+          # the opposite placement order is clipped from each leg's stored
+          # origin, as QEA's reversed_stored_corner does (5038EEE3).
+          def reversed_corner_metadata(model, link, bounds, offsets, edge)
+            return {} unless reversed_corner_candidate?(model, link, bounds, offsets, edge)
+
+            boxes = bounds.values_at(:source, :target)
+            origins = corner_origins(boxes, ray_geometry(offsets, edge))
+            bend = Ea::Model::Point.new(**%i[x y].zip(intermediate_waypoints(link).first).to_h)
+            ends = origins.zip(boxes).map { |origin, box| corner_exit(origin, bend, box) }
+            ends.all? ? corner_fields(origins, bend, ends) : {}
+          end
+
+          def corner_fields(origins, bend, ends)
+            { waypoints: points_to_waypoints([ends[0], bend, ends[1]].map { |point| [point.x, point.y] }),
+              source_anchor: origins[0], target_anchor: origins[1] }
+          end
+
+          def corner_origins(boxes, geom)
+            [stored_ray_origin(boxes[0], geom[:sx], geom[:sy]), stored_ray_origin(boxes[1], geom[:ex], geom[:ey])]
+          end
+
+          def corner_exit(origin, bend, box)
+            inside_box?(origin, box) ? diagonal_corner_exit(origin, bend, box) : origin
+          end
+
+          def reversed_corner_candidate?(model, link, bounds, offsets, edge)
+            model.connector_type == "Association" && model.style[:reversed_ends] && edge == 2 &&
+              model.style.to_h.values_at(:mode, :lwidth, :tree) == ["3", "0", nil] &&
+              ray_inputs?(bounds, offsets) && intermediate_waypoints(link).size == 1
+          end
+
+          # QEA seats the source labels of a reversed vertical lateral tree
+          # ("LV") as if its source leg left to the left (5038EEE3 connector 207).
+          def reversed_lateral_tree_metadata(model, _link, _bounds, _offsets, _edge)
+            return {} unless model.connector_type == "Association" && model.style[:reversed_ends] &&
+                             model.style[:tree] == "LV"
+
+            { style: model.style.to_h.except(:reversed_ends).merge(left_seated_source: true) }
+          end
+
+          def points_to_waypoints(points)
+            points.map { |x, y| Ea::Model::Waypoint.new(position: Ea::Model::Point.new(x: x, y: y)) }
+          end
+        end
+      end
+    end
+  end
+end