ea 0.6.139 → 0.6.141

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,15 +191,17 @@ 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)
           # 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
-          end
+          # A DUID shared by several placements names none of them (QEA
+          # placement_order_reversed? needs a unique match too).
+          by_duid = placed_elements.select { |pe| pe.style.duid }.group_by { |pe| pe.style.duid }
+                                   .select { |_duid, placements| placements.one? }
+                                   .transform_values(&:first)
           by_subject = placed_elements.group_by { |pe| guid_key(pe.subject) }
 
           placed_connectors.each_with_index.map do |placed, index|
@@ -245,7 +259,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 +271,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
 
@@ -293,9 +310,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)
@@ -342,14 +370,28 @@ module Ea
         # 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)
+          named = [by_duid[style.soid], by_duid[style.eoid]]
+          source = named[0] || sole_placement(by_subject, edge_source)
+          target = named[1] || sole_placement(by_subject, edge_target)
+          if source.equal?(target) && named.one?
+            source, target = subject_placements(by_subject, named, edge_source, edge_target)
+          end
           return [source, target] unless source && target &&
                                          reversed_ends?(source, target, edge_source, edge_target)
 
           [target, source]
         end
 
+        # One stale DUID falls back to the relationship's own end, which can
+        # be the very placement the other DUID named; two distinct ends never
+        # share a box, so each end then takes its own subject's placement. A
+        # link whose SOID and EOID are one DUID is a genuine self link.
+        def subject_placements(by_subject, named, edge_source, edge_target)
+          [edge_source, edge_target].zip(named).map do |subject, placement|
+            sole_placement(by_subject, subject) || (placement if guid_key(placement&.subject) == guid_key(subject))
+          end
+        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) &&
@@ -358,12 +400,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
 
@@ -515,8 +558,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/extension_style_parser.rb

@@ -51,7 +51,7 @@ module Ea
             next nil unless pair.include?("=")
 
             key, value = pair.split("=", 2)
-            [key, value] if key && value && !value.empty?
+            [key.strip, value] if key && value && !value.empty?
           end.to_h
         end
 

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,78 @@
+# 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)
+            route = reversed_tree_points(start, finish, ray_geometry(offsets, edge), stored_bus_levels(link))
+            return {} unless route
+
+            reversed_tree_fields(model, route[0], route[1])
+          end
+
+          def reversed_tree_fields(model, points, beside)
+            style = model.style.to_h.except(:umldi_route, :reversed_ends)
+            style[:left_seated_source] = true if beside
+            ends = [point_for(points.first), point_for(points.last)]
+            { waypoints: points_to_waypoints(points),
+              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)
+
+            origins, points = reversed_corner_points(bounds.values_at(:source, :target), ray_geometry(offsets, edge),
+                                                     intermediate_waypoints(link).first)
+            return {} unless points
+
+            { waypoints: points_to_waypoints(points.map { |point| [point.x, point.y] }),
+              source_anchor: origins[0], target_anchor: origins[1] }
+          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

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

@@ -9,6 +9,9 @@ module Ea
       # boxes). Returns nil where QEA would fall back to bare SX/SY deltas,
       # which the generic router keeps handling.
       class StoredRoute < Qea::DiagramBuilder
+        autoload :ReversedRoutes, "ea/sources/xmi/stored_route/reversed_routes"
+        include ReversedRoutes
+
         Link = Struct.new(:style, :path, :geometry)
         Connector = Struct.new(:connector_type)
 
@@ -29,6 +32,9 @@ module Ea
         # Saved rays retain origins and computed boundary ports, matching QEA.
         def ray_metadata(model, link:, bounds:, offsets:, edge:)
           if model.connector_type == "Generalization"
+            overlap = mode2_overlap_metadata(model, link, bounds, offsets, edge)
+            return overlap unless overlap.empty?
+
             return generalization_ray_metadata(model, link, bounds, offsets, edge)
           end
 
@@ -49,11 +55,10 @@ module Ea
         # UMLDI fallback. A single stored corner and an empty-path stored ray
         # carry mathematical origins that the generic facing-edge route loses.
         def association_route(model, link:, bounds:, offsets:, edge:)
-          overlap = umldi_association_metadata(model, link, bounds, offsets, edge)
-          return overlap unless overlap.empty?
-
-          partial = partial_port_metadata(model, link, bounds, offsets, edge)
-          return partial unless partial.empty?
+          ROUTE_STAGES.each do |stage|
+            found = method(stage).call(model, link, bounds, offsets, edge)
+            return found unless found.empty?
+          end
 
           return {} unless stored_association_candidate?(model, bounds)
 
@@ -67,6 +72,69 @@ module Ea
 
         private
 
+        ROUTE_STAGES = %i[umldi_association_metadata shared_overlap_metadata
+                          source_row_metadata auto_port_elbow_metadata reversed_tree_metadata
+                          reversed_corner_metadata reversed_lateral_tree_metadata partial_port_metadata].freeze
+
+        # Overlap rules need both end boxes and every end offset.
+        def ray_inputs?(bounds, offsets)
+          bounds.values.all? && offsets.values.flatten.none?(&:nil?)
+        end
+
+        # A Mode 2 Generalization whose stored Path is a horizontal jog is EA's
+        # auto-route: QEA replaces the stored bends with one vertical ray, and
+        # the same QEA rule decides it here.
+        def mode2_overlap_metadata(model, link, bounds, offsets, edge)
+          return {} if link.path.to_s.empty? || !ray_inputs?(bounds, offsets)
+
+          candidate = association_model(model, bounds, offsets)
+          initial = candidate.waypoints
+          mode2_overlap_ray(candidate, link, bounds, ray_geometry(offsets, edge), false)
+          return {} if candidate.waypoints.equal?(initial)
+
+          { waypoints: candidate.waypoints, source_anchor: candidate.source_anchor,
+            target_anchor: candidate.target_anchor, has_geometry_offsets: true }
+        end
+
+        # A stored (non-UMLDI) Association through the shared overlap row takes
+        # QEA's overlap origins and flush ports, decided by the same QEA rule.
+        def shared_overlap_metadata(model, link, bounds, offsets, edge)
+          return {} if model.style[:umldi_route] || !ray_inputs?(bounds, offsets)
+
+          candidate = association_model(model, bounds, offsets)
+          geom = ray_geometry(offsets, edge)
+          association_stored_ray(candidate, link, bounds, geom, false) if association_ray_style?(model.style.to_h)
+          overlap_ray_origins(candidate, link, bounds, geom, false)
+          return {} unless candidate.style[:overlap_ray]
+
+          association_metadata(candidate)
+        end
+
+        # A Mode 2 Association with unequal end offsets and no (or a stale) Path
+        # rides the source row, as QEA's source_row_association_ray decides.
+        def source_row_metadata(model, link, bounds, offsets, edge)
+          return {} if model.style[:umldi_route] || !ray_inputs?(bounds, offsets)
+
+          candidate = association_model(model, bounds, offsets)
+          source_row_association_ray(candidate, link, bounds, ray_geometry(offsets, edge), false)
+          return {} unless candidate.style[:overlap_ray]
+
+          association_metadata(candidate)
+        end
+
+        # A Mode 2 Association with uniform offsets, EDGE 4 and no Path keeps its
+        # physical ports and takes QEA's elbow, even when UMLDI saved a straight
+        # route (30D62231, 934F4502).
+        def auto_port_elbow_metadata(model, link, bounds, offsets, edge)
+          return {} unless ray_inputs?(bounds, offsets)
+
+          candidate = association_model(model, bounds, offsets)
+          auto_port_elbow(candidate, link, bounds, ray_geometry(offsets, edge), false)
+          return {} unless candidate.style[:auto_port_elbow]
+
+          association_metadata(candidate)
+        end
+
         def umldi_association_metadata(model, link, bounds, offsets, edge)
           overlap = umldi_overlap_metadata(model, link, bounds, offsets, edge)
           return overlap unless overlap.empty?
@@ -99,7 +167,9 @@ module Ea
           return {} unless umldi_overlap_candidate?(model, bounds, offsets)
 
           candidate = association_model(model, bounds, offsets)
-          overlap_ray_origins(candidate, link, bounds, ray_geometry(offsets, edge), false)
+          geom = ray_geometry(offsets, edge)
+          association_stored_ray(candidate, link, bounds, geom, false) if association_ray_style?(model.style.to_h)
+          overlap_ray_origins(candidate, link, bounds, geom, false)
           return {} unless candidate.style[:overlap_ray]
 
           { source_anchor: candidate.source_anchor, target_anchor: candidate.target_anchor,
@@ -162,6 +232,13 @@ module Ea
                                y: box.y + box.height / 2 + offset[1].to_i)
         end
 
+        # XMI has no QEA database from which to infer a wider element outline,
+        # so the saved connector width stands. A border-aware variant changed no
+        # connector in the PLATEAU census.
+        def association_outline_width(model, _link, _bounds)
+          model.style[:lwidth]
+        end
+
         def stored_ray_boxes(_link, bounds)
           bounds.values_at(:source, :target)
         end

data/lib/ea/spa/generator.rb

@@ -17,7 +17,8 @@ module Ea
       attr_reader :document, :mode, :output_path, :shard_url_for, :configuration
 
       def initialize(document, output:, mode: nil, shard_url_for: nil,
-                     configuration: nil)
+                     configuration: nil, frame: false)
+        @frame = frame
         @document = document
         @output_path = output
         @mode = (mode || DEFAULT_MODE).to_sym
@@ -32,7 +33,8 @@ module Ea
       def projector
         @projector ||= Projector.new(document,
                                       shard_url_for: shard_url_for,
-                                      configuration: configuration)
+                                      configuration: configuration,
+                                      frame: @frame)
       end
 
       def strategy_class

data/lib/ea/spa/projector.rb

@@ -15,8 +15,9 @@ module Ea
     class Projector
       attr_reader :document, :shard_url_for, :configuration
 
-      def initialize(document, shard_url_for: nil, configuration: nil)
+      def initialize(document, shard_url_for: nil, configuration: nil, frame: false)
         @document = document
+        @frame = frame
         @shard_url_for = shard_url_for || default_shard_url
         @configuration = configuration
       end
@@ -288,7 +289,8 @@ module Ea
         payload["svg"] = Ea::Svg::EaEmitter::Document.new(
           diagram,
           model_index: document.index_by_id,
-          document: document
+          document: document,
+          frame: @frame
         ).render
         payload
       rescue StandardError => e

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

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      # Space EA leaves below the lowest element of an unframed export.
+      #
+      # EMPIRICAL FIT (no stored selector was found; measured on the 187
+      # PLATEAU QEA diagrams whose native SVG is available, 172 match):
+      # below the lowest element the canvas keeps 21 + its font size in
+      # points (the objectstyle fontsz is in tenths of a point, 0 meaning
+      # the 7pt default): 31 for fontsz 100, 30 for 90, 28 for the
+      # default. A plain Note, and a Package that draws no "(from
+      # Parent)" subtitle, keep the bare 10 margin, as does a classifier
+      # or instance of the diagram's own package. Misses: 2 outliers.
+      class BottomMargin
+        BARE = 10
+        LINE_ALLOWANCE = 21
+        HOME_TEXT_ALLOWANCE = 13
+        DEFAULT_POINTS = 7
+
+        def self.for(diagram, model_index)
+          lowest = lowest_elements(diagram)
+          return CanvasAnchor::BOTTOM_MARGIN if lowest.empty?
+
+          lowest.map { |element| of(element, diagram, model_index) }.max
+        end
+
+        def self.lowest_elements(diagram)
+          placed = (diagram.elements || []).select { |e| e.bounds || e.image_bounds }
+          bottom = placed.map { |e| edge(e) }.max
+          placed.select { |e| edge(e) == bottom }
+        end
+
+        def self.edge(element)
+          bounds = element.bounds || element.image_bounds
+          bounds.y + bounds.height
+        end
+
+        def self.of(element, diagram, model_index)
+          model = model_index && model_index[element.model_element_ref]
+          return home_text_margin(element) if home_text?(model, diagram)
+          return BARE if plain_note?(model) || bare_package?(model, diagram) ||
+                         home_element?(model, diagram)
+
+          LINE_ALLOWANCE + points(element)
+        end
+
+        # QEA keeps the raw objectstyle fontsz; XMI keeps only the GDI
+        # pixel height it was rendered at (tenths * 96 / 720, floored).
+        def self.points(element)
+          tenths = element.style && element.style[:fontsz].to_i
+          return tenths / 10 if tenths.to_i.positive?
+
+          pixels = element.font_logical_height.to_i.abs
+          pixels.positive? ? (pixels * 0.75).round : DEFAULT_POINTS
+        end
+
+        def self.plain_note?(model)
+          model.is_a?(Ea::Model::Note) && model.note_type != "Text"
+        end
+
+        # An element of the diagram's own package (a classifier, nested
+        # in an owner class or not, or an instance) draws no "(from
+        # Package)" row under its name, so EA keeps only the bare margin
+        # below it. EMPIRICAL FIT, checked on: the 7 PLATEAU diagrams
+        # whose lowest class is in the diagram's package (all natively
+        # 10) against the 84 foreign ones (all 28..31); basic.qea
+        # 3B8BD087 and D14AA320 (lowest an own-package "Object B"
+        # instance) and 372F7F7B, 4FC1D352, 6D0349D5 (lowest a Klass
+        # nested in "Class A.x" / "Class B" of the own package), all
+        # natively 10; and the foreign basic instances, natively 28.
+        def self.home_element?(model, diagram)
+          (model.is_a?(Ea::Model::Classifier) ||
+            model.is_a?(Ea::Model::InstanceSpecification)) &&
+            !diagram.package_id.to_s.empty? &&
+            model.package_id == diagram.package_id
+        end
+
+        # A Text element of the diagram's own package keeps 13 + its
+        # font size in points (22 at 9pt) instead of the foreign 21 + size.
+        # EMPIRICAL FIT on a single sample (PLATEAU 2E98EA19, fontsz 90,
+        # natively 22); the 8 foreign Text cases (28..30) are unaffected.
+        def self.home_text?(model, diagram)
+          model.is_a?(Ea::Model::Note) && model.note_type == "Text" &&
+            !diagram.package_id.to_s.empty? &&
+            model.package_id == diagram.package_id
+        end
+
+        def self.home_text_margin(element)
+          HOME_TEXT_ALLOWANCE + points(element)
+        end
+
+        def self.bare_package?(model, diagram)
+          return false unless model.is_a?(Ea::Model::Package)
+
+          parent = model.parent_id
+          !(diagram.show_foreign && !parent.to_s.empty? &&
+            parent != diagram.package_id)
+        end
+      end
+    end
+  end
+end

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

@@ -33,12 +33,19 @@ module Ea
 
         attr_reader :diagram, :model_index
 
+        # Where the leftmost model x lands: 30 + min_x capped at 35. A
+        # negative min_x keeps the 30 of min_x 0 (the corpus has none),
+        # so content left of the origin is not drawn off the canvas.
+        def self.inset_left_for(min_x)
+          [[INSET_LEFT - 5 + min_x, INSET_LEFT - 5].max, INSET_LEFT].min
+        end
+
         def initialize(diagram, model_index: nil)
           @diagram = diagram
           @model_index = model_index
         end
 
-        attr_reader :effective_inset_left
+        attr_reader :effective_inset_left, :max_x, :max_y
 
         def compute
           points = element_points
@@ -48,10 +55,12 @@ module Ea
           ys = points.map(&:last)
           min_x = xs.min || 0
           min_y = ys.min || 0
+          @max_x = xs.max
+          @max_y = ys.max
           # Left inset scales from 30 up to the 35 cap with the
           # stored leftmost x: leftmost drawn x = 30 + min_x capped
           # at 35 (corpus: min_x 0 -> 30, 2 -> 32, 4 -> 34, >=5 -> 35).
-          @effective_inset_left = [INSET_LEFT - 5 + min_x, INSET_LEFT].min
+          @effective_inset_left = self.class.inset_left_for(min_x)
           [
             min_x,
             min_y,
@@ -60,19 +69,7 @@ module Ea
           ]
         end
 
-        private
-
-        # Element x-extent: logical bounds only (matches EA's canvas
-        # left/right exactly).
-        # Element y-extent: union of logical + image_bounds (image
-        # extends below bounds for shadow / image padding), plus the
-        # "(from Parent)" subtitle extent: EA draws the subtitle 15px
-        # below the body and its text descent adds ~4 more, reserving
-        # 19px of canvas below subtitle-bearing packages (the +19
-        # height family: 05DF5000 Main, Metadata All, package
-        # Clients/Suppliers contexts).
-        SUBTITLE_CANVAS_EXTRA = 19
-
+        # Canvas points reserved below "(from Parent)" subtitles.
         def subtitle_points
           pts = []
           (diagram.elements || []).each do |e|
@@ -86,6 +83,19 @@ module Ea
           pts
         end
 
+        private
+
+        # Element x-extent: logical bounds only (matches EA's canvas
+        # left/right exactly).
+        # Element y-extent: union of logical + image_bounds (image
+        # extends below bounds for shadow / image padding), plus the
+        # "(from Parent)" subtitle extent: EA draws the subtitle 15px
+        # below the body and its text descent adds ~4 more, reserving
+        # 19px of canvas below subtitle-bearing packages (the +19
+        # height family: 05DF5000 Main, Metadata All, package
+        # Clients/Suppliers contexts).
+        SUBTITLE_CANVAS_EXTRA = 19
+
         def element_points
           pts = []
           (diagram.elements || []).each do |e|