ea 0.6.136 → 0.6.138

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 121e254bdf4c232789483be3fc0de9f65e0b70a89c34009db6421d9dcae1337d
-  data.tar.gz: 1f11075a36fe5f7208b264f4f10e409230afe184101157ba41a3bf05fd57efb6
+  metadata.gz: 0c2231b8d009e8d99c841920776cbe8539e09b76d512beed109f073fb7904282
+  data.tar.gz: 3feade927368b299842047c9c0e31aa0cb8473e7dad6870e5626fb369e1503de
 SHA512:
-  metadata.gz: f924fea92342d3525a5fb5ea6b1b8c0167afc5f709d1c373a52b178a263efa29c9adc8bf690c4fba1073053a2f75c5888abbd509dcd187c39a57a0ab4c089286
-  data.tar.gz: 5c558dcefad07838fd403fa8eae5a9e7bf00e802348de364d28adb692e02bb76a6de2909139570431bb96a364955c276a5a356b05ba5107ce6906f0aa03315a5
+  metadata.gz: 025f36b456316a6fcd801318f17c27363d62d3ee7355cd303c1b7147081f44d3b70fdf711966ae4a5a7fc33e022dc097ba4d6f15f6c3ad03e237d59318b89fac
+  data.tar.gz: d2487edce57559735c9cdf42984dd16ad3597985fb5d2f01ddeb9289c893b423a986f8587b3788d0cd759aaca93661c8e0a86262a4939f503d21e9495e29db9f

data/lib/ea/fonts/cambria_7_regular_widths.json

@@ -46,6 +46,7 @@
   "Z": 5,
   "[": 4,
   "]": 4,
+  "_": 4,
   "a": 5,
   "b": 5,
   "c": 4,

data/lib/ea/model/diagram_connector.rb

@@ -38,6 +38,9 @@ module Ea
       attribute :hidden, :boolean
       attribute :is_substitutable, :boolean, default: false
       attribute :label_boxes, :hash, default: -> { {} }
+      # Absolute labels saved by UML-DI when the EA extension omits the
+      # corresponding relative label boxes.
+      attribute :umldi_label_bounds, :hash, default: -> { {} }
       attribute :ghost_labels, GhostLabel, collection: true, initialize_empty: true
       # True when the t_diagramlinks.Geometry string carries explicit
       # SX/SY/EX/EY offset fields. EA renders the «import» package_anchor
@@ -86,6 +89,7 @@ module Ea
         map "lineWidth", to: :line_width
         map "hidden", to: :hidden, render_default: true
         map "labelBoxes", to: :label_boxes
+        map "umldiLabelBounds", to: :umldi_label_bounds
         map "ghostLabels", to: :ghost_labels, render_empty: true
         map "hasGeometryOffsets", to: :has_geometry_offsets, render_default: true
       end

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

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+module Ea
+  module Sources
+    module Xmi
+      class DiagramBuilder
+        # EA stores the association-class reference, connector subtype and proxy
+        # classifiers in extension attributes omitted by the XMI model gem.
+        class AssociationClassMetadata
+          def initialize(xmi_path)
+            @xmi_path = xmi_path
+          end
+
+          def for(connector, placed_subjects:, waypoints:)
+            return unless valid_tether?(connector, waypoints)
+
+            attached_id = connector_data.dig(connector.idref, :association_class)
+            return unless attached_id && class_ids.include?(attached_id)
+            return unless placed_subjects.any? { |subject| guid_key(subject) == guid_key(attached_id) }
+
+            attached_id
+          end
+
+          private
+
+          def valid_tether?(connector, waypoints)
+            @xmi_path && connector && association_class?(connector) &&
+              proxy_pair?(connector) && coincident_route?(waypoints)
+          end
+
+          def association_class?(connector)
+            connector.properties&.ea_type == "Association" &&
+              connector_data.dig(connector.idref, :subtype) == "Class" &&
+              connector_data.dig(connector.idref, :private_data).to_s.match?(/\A[1-9]\d*\z/)
+          end
+
+          def proxy_pair?(connector)
+            endpoints = [connector.source, connector.target]
+            return false unless proxy_endpoints?(endpoints)
+
+            classifiers = endpoints.map { |endpoint| proxy_classifiers[endpoint.idref] }
+            matching_classifiers?(classifiers)
+          end
+
+          def proxy_endpoints?(endpoints)
+            endpoints.all? { |endpoint| endpoint&.model&.type == "ProxyConnector" }
+          end
+
+          def matching_classifiers?(classifiers)
+            classifiers.none? { |classifier| classifier.to_s.empty? } && classifiers.uniq.one?
+          end
+
+          def coincident_route?(waypoints)
+            first = waypoints&.first&.position
+            last = waypoints&.last&.position
+            first && last && first.x == last.x && first.y == last.y
+          end
+
+          def connector_data
+            @connector_data ||= read_metadata.fetch(:connectors)
+          end
+
+          def proxy_classifiers
+            @proxy_classifiers ||= read_metadata.fetch(:proxies)
+          end
+
+          def class_ids
+            @class_ids ||= read_metadata.fetch(:classes)
+          end
+
+          def read_metadata
+            @read_metadata ||= scan_metadata
+          end
+
+          def scan_metadata
+            data = { connectors: {}, proxies: {}, classes: [] }
+            File.open(@xmi_path) do |file|
+              Nokogiri::XML::Reader(file).each { |node| read_node(node, data) }
+            end
+            data
+          end
+
+          def read_node(node, data)
+            return unless node.node_type == Nokogiri::XML::Reader::TYPE_ELEMENT
+
+            read_element(node, data) if node.local_name == "element"
+            read_connector(node, data) if node.local_name == "connector"
+          end
+
+          def read_element(node, data)
+            element = Nokogiri::XML(node.outer_xml).root
+            id = attr(element, "idref")
+            return unless id
+
+            type = attr(element, "type")
+            data[:classes] << id if type == "uml:Class"
+            data[:proxies][id] = attr(element, "classifier") if type == "uml:ProxyConnector"
+          end
+
+          def read_connector(node, data)
+            connector = Nokogiri::XML(node.outer_xml).root
+            id = attr(connector, "idref")
+            return unless id
+
+            extended = connector.at_xpath("./*[local-name()='extendedProperties']")
+            properties = connector.at_xpath("./*[local-name()='properties']")
+            data[:connectors][id] = {
+              subtype: attr(properties, "subtype"),
+              association_class: attr(extended, "associationclass"),
+              private_data: attr(extended, "privatedata1")
+            }
+          end
+
+          def attr(node, name)
+            node&.attribute_nodes&.find { |attribute| attribute.name == name }&.value
+          end
+
+          def guid_key(subject)
+            subject&.sub(/\AEA(?:ID|PK)_/, "")&.upcase
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Xmi
+      class DiagramBuilder
+        class UmldiEdges
+          # Association membership proves which saved role bounds an edge owns.
+          class PropertyRoles
+            def initialize(doc)
+              @doc = doc
+            end
+
+            def keys_for(diagram_id, connector_id)
+              property_roles.dig(diagram_id, connector_id) || []
+            end
+
+            private
+
+            def property_roles
+              @property_roles ||= begin
+                document = @doc
+                declared = declared_properties(document)
+                document.xpath("//*[local-name()=\"Diagram\"]").to_h do |diagram|
+                  [diagram["id"] || diagram["xmi:id"], diagram_property_roles(diagram, declared)]
+                end
+              end
+            end
+
+            def declared_properties(document)
+              members = document.xpath("//*[local-name()='memberEnd']").to_set do |node|
+                [node["xmi:idref"], node.parent["xmi:id"]]
+              end
+              document.xpath("//*[@association][@xmi:id]", "xmi" => "http://www.omg.org/spec/XMI/20131001")
+                      .filter_map do |node|
+                pair = [node["xmi:id"], node["association"]]
+                pair if node.attributes["type"]&.value == "uml:Property" && members.include?(pair)
+              end.to_set
+            end
+
+            def diagram_property_roles(diagram, declared)
+              unique_edges(diagram).transform_values do |edge|
+                edge.xpath("./ownedElement[@modelElement]").filter_map do |label|
+                  key = role_key(label)
+                  key if key &&
+                         declared.include?([label["modelElement"], edge["modelElement"]])
+                end
+              end
+            end
+
+            def unique_edges(diagram)
+              diagram.xpath("./ownedElement[@modelElement]")
+                     .select { |node| node.attributes["type"]&.value.to_s.end_with?("UMLEdge") }
+                     .group_by { |edge| edge["modelElement"] }
+                     .select { |_, edges| edges.one? }.transform_values(&:first)
+            end
+
+            def role_key(label)
+              return unless label.attributes["type"]&.value.to_s.end_with?("UMLAssociationEndLabel")
+
+              case label["xmi:id"] || label["id"]
+              when /\AEAID_SEL/ then :source_role
+              when /\AEAID_TEL/ then :target_role
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -11,6 +11,8 @@ module Ea
         # drawn by more than one edge in the same diagram has neither; an edge
         # with fewer than two waypoints has no route.
         class UmldiEdges
+          autoload :PropertyRoles, "ea/sources/xmi/diagram_builder/umldi_edges/property_roles"
+
           def initialize(xmi_path)
             @xmi_path = xmi_path
           end
@@ -23,6 +25,20 @@ module Ea
             ends.dig(diagram_id, connector_id)
           end
 
+          # Absolute saved UMLDI bounds for connector label boxes. These are
+          # kept separate from extension label offsets: callers may use them
+          # when extension geometry is absent or the association owns the role.
+          def label_bounds_for(diagram_id, connector_id)
+            label_bounds.dig(diagram_id, connector_id)
+          end
+
+          # Role label keys whose UMLDI label is bound to the property that
+          # the connector's association declares, so the bounds describe that
+          # end's own role label rather than an unrelated label.
+          def property_role_keys_for(diagram_id, connector_id)
+            (@property_roles ||= PropertyRoles.new(doc)).keys_for(diagram_id, connector_id)
+          end
+
           private
 
           def ends
@@ -31,6 +47,46 @@ module Ea
             end
           end
 
+          def label_bounds
+            @label_bounds ||= doc.xpath("//*[local-name()=\"Diagram\"]").to_h do |diagram|
+              [diagram["id"] || diagram["xmi:id"], diagram_label_bounds(diagram)]
+            end
+          end
+
+          def diagram_label_bounds(diagram)
+            boxes_by_connector = unique_edges(diagram).to_h do |connector_id, edge|
+              [connector_id, edge_label_bounds(edge)]
+            end
+            boxes_by_connector.reject { |_, boxes| boxes.empty? }
+          end
+
+          def edge_label_bounds(edge)
+            edge.xpath("./ownedElement[@modelElement]").each_with_object({}) do |label, found|
+              bounds = label.at_xpath("./*[local-name()=\"bounds\"]")
+              key = label_key(label)
+              next unless key && bounds
+
+              found[key] = bounds_values(bounds)
+            rescue ArgumentError, TypeError
+              next
+            end
+          end
+
+          def bounds_values(bounds)
+            %w[x y width height].to_h { |attribute| [attribute.to_sym, Integer(bounds[attribute])] }
+          end
+
+          def label_key(label)
+            type = label.attributes["type"]&.value.to_s
+            role = (label["id"] || label["xmi:id"]).to_s
+            end_name = { "EAID_SEL" => "source", "EAID_SML" => "source",
+                         "EAID_TEL" => "target", "EAID_TML" => "target" }
+            side = end_name.find { |prefix, _| role.start_with?(prefix) }&.last
+            suffix = { "UMLAssociationEndLabel" => "role", "UMLMultiplicityLabel" => "multiplicity" }
+            label_kind = suffix[type.split(":").last]
+            "#{side}_#{label_kind}".to_sym if side && label_kind
+          end
+
           def diagram_ends(diagram)
             unique_edges(diagram).each_with_object({}) do |(connector_id, edge), acc|
               acc[connector_id] = [edge["source"], edge["target"]] if edge["source"] && edge["target"]

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

@@ -10,6 +10,7 @@ module Ea
       # the UML-DI owned_element bounds otherwise.
       class DiagramBuilder
         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 :StereotypeProfiles, "ea/sources/xmi/diagram_builder/stereotype_profiles"
         autoload :UmldiEdges, "ea/sources/xmi/diagram_builder/umldi_edges"
@@ -44,11 +45,12 @@ module Ea
 
         def build_one(ext_diagram)
           id = IdNormalizer.from_xmi_id(ext_diagram.id)
-          ext_elements = ExtensionElements.new(ext_diagram)
+          ext_elements = ExtensionElements.new(ext_diagram, connector_subjects: connector_index)
           placed_elements = ext_elements.placed_elements
           placed_connectors = ext_elements.placed_connectors
           props = ext_diagram.properties
           umldi_keywords = keywords_for(id)
+          context = context_diagram?(ext_diagram)
 
           Ea::Model::Diagram.new(
             id: id,
@@ -64,8 +66,7 @@ module Ea
             show_parents: !style_flag?(ext_diagram, "HideParents"),
             hand_draw: style_flag?(ext_diagram, "HandDraw"),
             elements: build_elements(placed_elements, id, umldi_keywords),
-            connectors: build_connectors(placed_connectors,
-                                          placed_elements, id),
+            connectors: build_connectors(placed_connectors, placed_elements, id, context),
             annotations: []
           )
         end
@@ -101,6 +102,13 @@ module Ea
           value.to_i.nonzero? ? true : false
         end
 
+        def context_diagram?(ext_diagram)
+          name = ext_diagram.properties&.name.to_s
+          return true if name.match?(/\AContext Diagram: Package (Clients|Suppliers) of /i)
+
+          style_ex_for(ext_diagram).to_s.match(/(?:\A|;)SuppressFOC=(\d)/)&.public_send(:[], 1) != "1"
+        end
+
         def page_bounds(ext_diagram)
           style = style_for(ext_diagram).to_s
           width = style[/(?:\A|;)DocSize\.cx=(\d+)/, 1]
@@ -130,6 +138,7 @@ module Ea
             line_width: style.line_width,
             font_family: font[:family],
             font_size: font[:size],
+            font_size_unit: "pt",
             font_logical_height: font[:logical_height],
             font_size_inherited: ExtensionStyleParser.split_pairs(style.raw.to_s)["fontsz"] == "0",
             font_bold: style.bold,
@@ -140,10 +149,32 @@ module Ea
             z_order: placed.seqno,
             duid: style.duid,
             umldi_keyword: umldi_keywords[placed.subject],
-            style: (@stereotype_profiles ||= StereotypeProfiles.new(root)).for(placed.subject)
+            style: element_style(placed.subject)
           )
         end
 
+        # XMI preserves UML member order in ownedAttribute. Carry that
+        # provenance to the renderer so it does not replace it with a name sort.
+        def element_style(subject)
+          style = (@stereotype_profiles ||= StereotypeProfiles.new(root)).for(subject)
+          return style unless source_ordered_classifiers.include?(subject)
+
+          style.merge(stored_attribute_order: true)
+        end
+
+        def source_ordered_classifiers
+          @source_ordered_classifiers ||= begin
+            ids = []
+            visit = lambda do |element|
+              ids << element.id if TypeClassifierMap.classifier_type?(element.type)
+              element.packaged_element.to_a.each { |child| visit.call(child) }
+              element.nested_classifier.to_a.each { |child| visit.call(child) }
+            end
+            root.model&.packaged_element.to_a.each { |element| visit.call(element) }
+            ids
+          end
+        end
+
         def build_bounds(left, top, right, bottom)
           return nil unless left && top && right && bottom
 
@@ -152,7 +183,7 @@ module Ea
                                  height: bottom - top)
         end
 
-        def build_connectors(placed_connectors, placed_elements, owner_id)
+        def build_connectors(placed_connectors, placed_elements, owner_id, context)
           # Index elements by DUID so we can resolve SOID/EOID.
           by_duid = placed_elements.each_with_object({}) do |pe, acc|
             acc[pe.style.duid] = pe if pe.style.duid
@@ -160,23 +191,46 @@ module Ea
           by_subject = placed_elements.group_by { |pe| guid_key(pe.subject) }
 
           placed_connectors.each_with_index.map do |placed, index|
-            build_connector(placed, by_duid, by_subject, owner_id, index)
+            connector = build_connector(placed, by_duid, by_subject, owner_id, rank: index, context: context)
+            mark_association_class(connector, placed, placed_elements, context)
           end
         end
 
-        def build_connector(placed, by_duid, by_subject, owner_id, rank)
+        def mark_association_class(connector, placed, placed_elements, context)
+          mark_plain_end_seats(connector, placed, context)
+          reference = association_class_metadata.for(
+            connector_index[placed.subject],
+            placed_subjects: placed_elements.map(&:subject),
+            waypoints: connector.waypoints
+          )
+          return connector unless reference
+
+          connector.style[:association_class_ref] = reference
+          connector.source_anchor = connector.waypoints.first.position
+          connector
+        end
+
+        def mark_plain_end_seats(connector, placed, context)
+          mark_plain_source_seat(connector, placed, context)
+          mark_plain_target_seat(connector, placed, context)
+        end
+
+        def association_class_metadata
+          @association_class_metadata ||= AssociationClassMetadata.new(xmi_path)
+        end
+
+        def build_connector(placed, by_duid, by_subject, owner_id, options)
           geom = placed.geometry
           style = placed.style
-          edge_source, edge_target = umldi_ends(owner_id, placed)
-          source = by_duid[style.soid] || sole_placement(by_subject, edge_source)
-          target = by_duid[style.eoid] || sole_placement(by_subject, edge_target)
+          edge_source, edge_target = connector_ends(owner_id, placed)
+          source, target = placed_ends(style, by_duid, by_subject, edge_source, edge_target)
           ext_meta = connector_meta(placed.subject)
           route = connector_route(placed, source, target, owner_id, ext_meta[:ea_type])
-          Ea::Model::DiagramConnector.new(
+          connector = Ea::Model::DiagramConnector.new(
             id: IdNormalizer.synthetic_id(owner_id, "conn", placed.subject),
             diagram_id: owner_id,
             relationship_ref: placed.subject,
-            paint_order: [rank],
+            paint_order: [options.fetch(:rank)],
             source_duid: style.soid,
             target_duid: style.eoid,
             source_element_ref: source && synthetic_element_id(owner_id, source),
@@ -193,8 +247,111 @@ module Ea
             line_color: style.color,
             line_width: style.line_width,
             hidden: style.hidden,
-            label_boxes: serialize_label_boxes(geom.label_boxes)
+            label_boxes: connector_label_boxes(placed, ext_meta[:ea_type],
+                                               options.fetch(:context) ? nil : owner_id)
           )
+          connector.umldi_label_bounds = if options.fetch(:context)
+                                           {}
+                                         else
+                                           umldi_label_bounds_for(owner_id, placed.subject,
+                                                                  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)
+          connector
+        end
+
+        def umldi_label_bounds_for(owner_id, connector_id, label_boxes)
+          return {} unless xmi_path
+
+          bounds = umldi_edges.label_bounds_for(owner_id, connector_id)
+          return {} unless bounds
+
+          property_roles = umldi_edges.property_role_keys_for(owner_id, connector_id)
+          bounds.reject do |key, _|
+            extension_key = { source_role: :llt, source_multiplicity: :llb,
+                              target_role: :lrt, target_multiplicity: :lrb }.fetch(key)
+            label_boxes.key?(extension_key) && !property_roles.include?(key)
+          end
+        end
+
+        def mark_stored_ray(connector, placed, source, target)
+          return if connector.style[:umldi_route]
+
+          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?
+        end
+
+        def stored_ray_metadata(connector, placed, source, target, stage: :ray_metadata)
+          geom = placed.geometry
+          link = StoredRoute::Link.new(placed.style.raw, geom.path.to_s.tr("$", ";"))
+          bounds = { source: bounds_from_placed(source), target: bounds_from_placed(target) }
+          offsets = { source: [geom.sx, geom.sy], target: [geom.ex, geom.ey] }
+          StoredRoute.new.public_send(stage, connector, link: link, bounds: bounds, offsets: offsets, edge: geom.edge)
+        end
+
+        def mark_association_route(connector, placed, source, target)
+          metadata = stored_ray_metadata(connector, placed, source, target, stage: :association_route)
+          metadata.each { |name, value| connector.public_send("#{name}=", value) }
+        end
+
+        def mark_plain_source_seat(connector, placed, context)
+          return if context || !placed.geometry.path.to_s.empty? || connector.connector_type != "Aggregation"
+          return unless connector.style.to_h.values_at(:mode, :lwidth, :tree) == ["3", "2", nil]
+          return unless connector.source_stereotype.to_s.empty?
+
+          connector.style[:plain_source_seat] = true
+        end
+
+        def mark_plain_target_seat(connector, placed, context)
+          return if context || !placed.geometry.path.to_s.empty? || connector.connector_type != "Association"
+          return unless connector.style.to_h.values_at(:mode, :lwidth, :tree) == ["3", "2", nil]
+          return unless connector.target_stereotype.to_s.empty?
+
+          connector.style[:plain_target_seat] = true
+        end
+
+        PHANTOM_TYPES = %w[Association Aggregation].freeze
+
+        # EA exports a model relationship drawn without a diagram link row as
+        # an Association or Aggregation link with the default style and an
+        # all-zero, EDGE-less, bendless geometry; the QEA source builds it as
+        # a phantom connector.
+        def phantom_link?(placed, type)
+          PHANTOM_TYPES.include?(type) && placed.style.raw == ";Hidden=0;" && default_geometry?(placed.geometry)
+        end
+
+        def default_geometry?(geom)
+          geom.edge.nil? && [geom.sx, geom.sy, geom.ex, geom.ey].all?(&:zero?) &&
+            geom.path.to_s.empty? && geom.label_boxes.to_h.empty?
+        end
+
+        def connector_label_boxes(placed, type, owner_id)
+          return serialize_label_boxes(placed.geometry.label_boxes) unless phantom_link?(placed, type)
+
+          # An empty extension placement can still have saved UMLDI labels.
+          # Synthetic phantom offsets must not suppress those authored bounds.
+          return {} if owner_id && xmi_path && umldi_edges.label_bounds_for(owner_id, placed.subject)
+
+          Qea::DiagramBuilder::DEFAULT_LABEL_BOXES
+        end
+
+        # The saved SOID/EOID can name the model connector's ends in reverse
+        # order; the model connector decides which placement is the source.
+        def placed_ends(style, by_duid, by_subject, edge_source, edge_target)
+          source = by_duid[style.soid] || sole_placement(by_subject, edge_source)
+          target = by_duid[style.eoid] || sole_placement(by_subject, edge_target)
+          return [source, target] unless source && target &&
+                                         reversed_ends?(source, target, edge_source, edge_target)
+
+          [target, source]
+        end
+
+        def reversed_ends?(source, target, edge_source, edge_target)
+          guid_key(edge_source) != guid_key(edge_target) &&
+            guid_key(source.subject) == guid_key(edge_target) &&
+            guid_key(target.subject) == guid_key(edge_source)
         end
 
         def connector_meta(subject_id)
@@ -238,11 +395,34 @@ module Ea
         end
 
         def connector_route(placed, source, target, owner_id, type)
+          phantom_route(placed, source, target, type) || saved_route(placed, source, target, owner_id, type)
+        end
+
+        def saved_route(placed, source, target, owner_id, type)
           native = umldi_waypoints(owner_id, placed) if placed.geometry.bend_points.to_a.empty?
           points = native || compute_waypoints(placed.geometry, source, target,
                                                style: placed.style, connector_type: type)
           native ||= umldi_waypoints(owner_id, placed) if points.empty?
-          { waypoints: native || points, style: native ? { umldi_route: true } : {} }
+          { waypoints: native || points, style: connector_route_style(placed, native) }
+        end
+
+        def phantom_route(placed, source, target, type)
+          return unless source && target && phantom_link?(placed, type)
+
+          points = StoredRoute.new.phantom_waypoints(bounds_from_placed(source), bounds_from_placed(target))
+          { waypoints: points.map { |x, y| Ea::Model::Waypoint.new(position: Ea::Model::Point.new(x: x, y: y)) },
+            style: { lwidth: "1", phantom_outline: true } }
+        end
+
+        def connector_route_style(placed, native)
+          route_style = native ? { umldi_route: true } : {}
+          # Label seats use EA's saved routing mode on every route source;
+          # umldi_route still marks UMLDI waypoints as authoritative.
+          route_style.merge!(Qea::DiagramStyleParser.parse(placed.style.raw).slice(:mode, :lwidth, :tree))
+          # Source-known links without DUIDs use classifier endpoint metadata,
+          # not a saved label box that might refer to the opposite end.
+          route_style[:explicit_end_roles] = true unless placed.style.soid && placed.style.eoid
+          route_style
         end
 
         # EA's unique exported edge supplies bendless routes and recovers
@@ -254,6 +434,15 @@ module Ea
           route&.map { |x, y| Ea::Model::Waypoint.new(position: Ea::Model::Point.new(x: x, y: y)) }
         end
 
+        def connector_ends(diagram_id, placed)
+          umldi_ends(diagram_id, placed) || extension_ends(placed.subject)
+        end
+
+        def extension_ends(subject)
+          connector = connector_index[subject]
+          [connector&.source&.idref, connector&.target&.idref]
+        end
+
         def umldi_ends(diagram_id, placed)
           return unless xmi_path
 

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

@@ -12,8 +12,9 @@ module Ea
       class ExtensionElements
         attr_reader :diagram
 
-        def initialize(diagram)
+        def initialize(diagram, connector_subjects: {})
           @diagram = diagram
+          @connector_subjects = connector_subjects
         end
 
         def placed_elements
@@ -53,9 +54,9 @@ module Ea
 
           placement = ExtensionGeometryParser.parse(row.geometry)
           style = ExtensionStyleParser.parse(row.style)
-          # Connectors carry SOID/EOID in their style; geometry has
-          # only bend routing.
-          return nil unless style.soid && style.eoid
+          # Some EA placements omit both DUIDs. The extension connector
+          # index still identifies these rows without treating shapes as links.
+          return nil unless (style.soid && style.eoid) || @connector_subjects.key?(row.subject)
 
           PlacedConnector.new(
             subject: row.subject,