ea 0.6.139 → 0.6.141

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 34c3f680cb51a88a683e57db2c059fcee8979e5b6b31cfaae4c3cbc3ac91ac86
-  data.tar.gz: a4cbd25958c54c24d6d1801bf4e4cc83f76f42d652f371cf9d491865160d7725
+  metadata.gz: 4f4c5df621df87a4df4467c9cbe157f70ea49d0463a892ed7e57ada3550b1937
+  data.tar.gz: 69fdddf140a6553c565287ce099bfa7f3d70d6c981502c559368c2e9860e70db
 SHA512:
-  metadata.gz: c87682bc64b73abb6502c0dfd71ca7b9209ab8bcd71b79762032d0c4008f80999e3785257b72f39d73a816247d1dbcc5580a70e64f526a8ee98ee1aab32b645a
-  data.tar.gz: ed3c4dd24e1ed8b1bd9c371545d56392cda07b2e0f3223f27d84761b728963c5df7df67fab8da905bdd586150fb94750a5cbe3f2bd1bec9fd11adfd3ec18b9c6
+  metadata.gz: b5d5331f2954387a2ff2e9a93981964421958bac715ca436630b7aca0cefd00107973219d571a01e162692f6037cc695e52f94f04ab8808e899f1d08bd9fdba7
+  data.tar.gz: 6c63841163568dc3b95d840ed14f4d18fd95e7bfc51bf111a8d40b32ae0aec920cf530a99012690f642c6ef4709e6df6adca3917e634f61a5088891fbf99d14c

data/lib/ea/cli/app.rb

@@ -41,6 +41,8 @@ module Ea
            "Diagram operations: list FILE | extract NAME FILE"
       option :format, type: :string, default: "table"
       option :output, **OUTPUT_OPTION, desc: "Output path (extract only)"
+      option :frame, type: :boolean, default: false,
+                     desc: "Draw EA's diagram frame (border, tab, label); default is unframed"
       def diagrams(action, file = nil, name = nil)
         Command::Diagrams
           .new(action: action, file: file, name: name, **symbolize(options))
@@ -81,6 +83,8 @@ module Ea
              desc: "Path to SPA YAML config (overrides model metadata: title, description, etc.)"
       option :mode, type: :string, default: "single_file",
                     desc: "Output mode: single_file | sharded"
+      option :frame, type: :boolean, default: false,
+                     desc: "Draw EA's diagram frame (border, tab, label); default is unframed"
       def spa(file)
         Command::Spa.new(file: file, **symbolize(options)).call
       end
@@ -92,7 +96,10 @@ module Ea
                    desc: "Render every diagram in the source file (NAME ignored)"
       option :output_dir, type: :string,
                           desc: "Directory for --all output (default: <basename>.svgs/)"
+      option :frame, type: :boolean, default: false,
+                     desc: "Draw EA's diagram frame (border, tab, label); default is unframed"
       def svg(name = nil, file = nil)
+        name, file = nil, name if options[:all] && file.nil?
         Command::Svg.new(name: name, file: file, **symbolize(options)).call
       end
 
@@ -113,7 +120,10 @@ module Ea
                       desc: "Output format: svg | png | pdf"
       option :output_dir, type: :string,
                           desc: "Directory for --all output (default: <basename>.renders/)"
+      option :frame, type: :boolean, default: false,
+                     desc: "Draw EA's diagram frame (border, tab, label); default is unframed"
       def render(name = nil, file = nil)
+        name, file = nil, name if options[:all] && file.nil?
         Command::Render.new(name: name, file: file, **symbolize(options)).call
       end
 

data/lib/ea/cli/command/diagrams.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "fileutils"
+
 module Ea
   module Cli
     module Command
@@ -51,7 +53,8 @@ module Ea
 
           svg = Ea::Svg::EaEmitter::Document.new(diagram,
                                                    model_index: document.index_by_id,
-                                                   document: document).render
+                                                   document: document,
+                                                   frame: options[:frame] ? true : false).render
           path = options[:output] || begin
             base = File.basename(file_path, ".*")
             dir = File.dirname(file_path)

data/lib/ea/cli/command/render.rb

@@ -22,6 +22,12 @@ module Ea
 
         private
 
+        # `--format` names the image format here (svg|png|pdf), not the
+        # table/json output formatter, so the result listing is a table.
+        def formatter
+          Ea::Cli::Output.instance_for(:table)
+        end
+
         def render_one
           diagram = find_diagram
           write_diagram(diagram, resolve_output_path(diagram))
@@ -57,7 +63,8 @@ module Ea
         def render_svg(diagram)
           emitter_for_mode.new(diagram,
                                model_index: document.index_by_id,
-                               document: document).render
+                               document: document,
+                               frame: options[:frame] ? true : false).render
         end
 
         def svg_to_png(svg)

data/lib/ea/cli/command/spa.rb

@@ -22,7 +22,8 @@ module Ea
             document,
             output: output_path,
             mode: mode,
-            configuration: spa_configuration
+            configuration: spa_configuration,
+            frame: options[:frame] ? true : false
           ).generate
 
           formatter.render([[output_path]], columns: [:written_to])

data/lib/ea/cli/command/svg.rb

@@ -26,9 +26,7 @@ module Ea
 
         def render_one
           diagram = find_diagram
-          svg = emitter_for_mode.new(diagram,
-                                       model_index: document.index_by_id,
-                                       document: document).render
+          svg = render_svg(diagram)
 
           output_path = resolve_output_path(diagram)
           FileUtils.mkdir_p(File.dirname(output_path))
@@ -41,9 +39,7 @@ module Ea
           out_dir = options[:output_dir] || default_output_dir
           FileUtils.mkdir_p(out_dir)
           paths = document.diagrams.map do |diagram|
-            svg = emitter_for_mode.new(diagram,
-                                         model_index: document.index_by_id,
-                                         document: document).render
+            svg = render_svg(diagram)
             path = File.join(out_dir, "#{diagram.id}.svg")
             File.write(path, svg)
             path
@@ -52,6 +48,13 @@ module Ea
           formatter.render(paths.map { |p| [p] }, columns: [:written_to])
         end
 
+        def render_svg(diagram)
+          emitter_for_mode.new(diagram,
+                               model_index: document.index_by_id,
+                               document: document,
+                               frame: options[:frame] ? true : false).render
+        end
+
         def default_output_dir
           base = File.basename(file_path, ".*")
           dir = File.dirname(file_path)

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.
@@ -103,6 +105,7 @@ module Ea
         # Source sizes 90 and 100 both export as 9pt but retain
         # distinct 12px and 13px logical heights. Apply that same
         # source-height delta to the existing compartment spacing.
+        logical_height = source_logical_height(logical_height)
         adjustment = if logical_height && unit == "pt" &&
                         GDI_HEIGHT_FAMILIES.include?(resolve_family(family))
                        logical_height - gdi_logical_height(size)
@@ -112,6 +115,13 @@ module Ea
         size + offset + adjustment
       end
 
+      # A source logical height of 0 or less (QEA floors tiny fontsz to
+      # 0) carries no information: treat it as absent.
+      def source_logical_height(height)
+        height = height.to_i
+        height if height.positive?
+      end
+
       def gdi_logical_height(size)
         (size.to_f * 10 / 7).round
       end
@@ -150,11 +160,17 @@ module Ea
       # textLength is the SUM of those per-glyph integers - corpus
       # fitted to 97-100% exact on 10k Carlito texts (bold 7pt
       # 1666/1671). The legacy sum-then-round model matched only 27%.
-      def text_length(text, size_pt, family: nil, weight: nil, style: nil, logical_height: nil)
+      #
+      # `legend_title` marks a diagram-legend title, the only context in
+      # which a bold Cambria CJK run takes regular-weight advances.
+      def text_length(text, size_pt, family: nil, weight: nil, style: nil, logical_height: nil,
+                      legend_title: false)
         return nil unless supported_family?(family)
         return nil if text.nil? || text.empty?
 
-        return cambria_text_length(text, size_pt, weight, style) if resolve_family(family) == "Cambria"
+        if resolve_family(family) == "Cambria"
+          return cambria_text_length(text, size_pt, weight, style, logical_height, legend_title: legend_title)
+        end
 
         advance_text_length(text, size_pt, family, weight, style, logical_height)
       end
@@ -162,7 +178,7 @@ module Ea
       def advance_text_length(text, size_pt, family, weight, style, logical_height)
         resolved = resolve_family(family)
         if GDI_HEIGHT_FAMILIES.include?(resolved)
-          height = logical_height || gdi_logical_height(size_pt)
+          height = source_logical_height(logical_height) || gdi_logical_height(size_pt)
           table = table_for(family, weight, style)
           fallback = cjk_fallback_widths(resolved, height, weight, style)
           measured_latin = measured_carlito_widths(resolved, height, weight, style)
@@ -204,8 +220,16 @@ module Ea
       end
       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
+      # True for Cambria outside the 7pt tables, where a run is measured
+      # character by character when it is not wholly in the CJK table.
+      def piecewise_family?(family, size_pt)
+        resolve_family(family) == "Cambria" && size_pt.to_f.to_r != 7
+      end
+
+      def cambria_text_length(text, size_pt, weight, style, logical_height = nil, legend_title: false)
+        unless size_pt.to_f.to_r == 7
+          return cambria_cjk_only_length(text, size_pt, weight, style, logical_height, legend_title: legend_title)
+        end
         return nil unless ["", "0", "400", "normal", "700", "bold"].include?(weight.to_s)
         return nil unless ["", "normal", "italic"].include?(style.to_s)
 
@@ -220,6 +244,30 @@ 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 the
+      # measured height (the source logical height when it is positive,
+      # else the one derived from the point size). A run with any other
+      # character is nil here; TextRenderer.estimate_width then prices
+      # the characters one at a time.
+      #
+      # EMPIRICAL FIT (decision a), legend titles only: EA draws a bold
+      # Cambria legend title 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. Every other bold
+      # run, and a title below H17, keeps the bold table (native 7pt
+      # bold "都市計画データ" = 70).
+      def cambria_cjk_only_length(text, size_pt, weight, style, logical_height = nil, legend_title: false)
+        height = source_logical_height(logical_height) || gdi_logical_height(size_pt)
+        bold = bold?(weight) && !(legend_title && 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,12 @@ module Ea
       class DiagramBuilder
         # Internal geometry for choosing the facing edges of stored routes.
         module Routing
+          REVERSED_TREE_BUS_OFFSET = 50
+          # A leg may start beside its box only this far from it (the one native
+          # case, 5038EEE3 connector 212, is 9px away); any other leg that
+          # leaves the box's x-span would be detached, so the fit yields.
+          REVERSED_TREE_BESIDE_REACH = 10
+
           private
 
           # Offsets stay attached to semantic Start/End IDs even when the
@@ -17,21 +23,153 @@ module Ea
             connector = database.find_connector(link_row.connectorid)
             return model unless connector && reversed_corner_link?(link_row, diagram_row, connector)
 
-            boxes = stored_ray_boxes(link_row, diagram_row)
+            origins, points = reversed_corner_points(stored_ray_boxes(link_row, diagram_row), geom,
+                                                     intermediate_waypoints(link_row).first)
+            return model unless points
+
+            model.waypoints = points.map { |point| Ea::Model::Waypoint.new(position: point) }
+            model.source_anchor, model.target_anchor = origins
+            model
+          end
+
+          # Shared by QEA and XMI: clip each leg of the single saved bend from
+          # its stored origin, retaining origins outside their box. Returns
+          # [origins, [start, bend, end]], or nil when a leg cannot be clipped.
+          def reversed_corner_points(boxes, geom, corner)
             origins = [stored_ray_origin(boxes[0], geom[:sx], geom[:sy]),
                        stored_ray_origin(boxes[1], geom[:ex], geom[:ey])]
-            x, y = intermediate_waypoints(link_row).first
-            bend = Ea::Model::Point.new(x: x, y: y)
+            bend = Ea::Model::Point.new(x: corner[0], y: corner[1])
             ends = origins.zip(boxes).map do |origin, box|
               inside_box?(origin, box) ? diagonal_corner_exit(origin, bend, box) : origin
             end
-            return model unless ends.all?
+            [origins, [ends[0], bend, ends[1]]] if ends.all?
+          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)
+            route = reversed_tree_points(start, finish, geom, stored_bus_levels(link_row))
+            return model unless route
+
+            points, beside = route
+            model.waypoints = points.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 beside
+            model
+          end
 
-            model.waypoints = [ends[0], bend, ends[1]].map { |point| Ea::Model::Waypoint.new(position: point) }
-            model.source_anchor, model.target_anchor = origins
+          # The reversed-tree route points and whether the Start leg starts
+          # beside its box, or nil when the fit does not apply: no usable bus
+          # level, a stored bus that is not the discarded one (see
+          # reversed_tree_levels), or a leg that cannot stay attached to its box.
+          def reversed_tree_points(start, finish, geom, stored_bus)
+            bus, start_edge, finish_edge = reversed_tree_levels(start, finish, stored_bus)
+            return 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)
+            return unless first && last
+
+            points = [first, [first[0], bus], [last[0], bus], last].chunk_while { |a, b| a == b }.map(&:first)
+            [points, first[1] != start_edge]
+          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.first[1] if 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.
+          #
+          # EMPIRICAL FIT (decision a): a stored bus is replaced only when it
+          # is a 50px tree bus off one of the two facing edges, as EA lays
+          # them out: 50px past the Start box (the Path follows SOID/EOID
+          # order; the QEA y670 = Start edge 720 - 50 of all five 5038EEE3
+          # links) or already 50px past the End box (the XMI Path of three
+          # of them, y568). A stored bus anywhere else is a real route.
+          def reversed_tree_levels(start, finish, stored_bus)
+            if finish.y + finish.height < start.y
+              bus = finish.y + finish.height + REVERSED_TREE_BUS_OFFSET
+              discarded = start.y - REVERSED_TREE_BUS_OFFSET
+              edges = [start.y, finish.y + finish.height]
+              [bus, *edges] if bus < start.y && [bus, discarded].include?(stored_bus)
+            elsif start.y + start.height < finish.y
+              bus = finish.y - REVERSED_TREE_BUS_OFFSET
+              discarded = start.y + start.height + REVERSED_TREE_BUS_OFFSET
+              edges = [start.y + start.height, finish.y]
+              [bus, *edges] if bus > edges.first && [bus, discarded].include?(stored_bus)
+            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 (just outside its
+          # x-span but level with it), where the origin itself is kept. Nil
+          # for an origin that would leave the leg detached.
+          #
+          # 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)
+            return [origin.x, edge_y] if origin.x.between?(box.x, box.x + box.width)
+
+            reach = REVERSED_TREE_BESIDE_REACH
+            beside = origin.y.between?(box.y, box.y + box.height) &&
+                     origin.x.between?(box.x - reach, box.x + box.width + reach)
+            [origin.x, origin.y] if beside
+          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 +180,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 +837,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 +869,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)
@@ -195,7 +202,10 @@ module Ea
         end
 
         def build_connectors(diagram_row)
-          links = database.diagram_links_for(diagram_row.diagram_id) || []
+          # A link row whose connector no longer exists (EA leaves them
+          # behind when a connector is deleted) has nothing to draw.
+          links = (database.diagram_links_for(diagram_row.diagram_id) || [])
+                  .select { |link_row| database.find_connector(link_row.connectorid) }
           context = ContextDiagramSupport.context?(diagram_row)
           # EA regenerates context diagrams at draw time; their
           # Hidden link rows are stale and never render.
@@ -475,6 +485,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 +505,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