ea 0.6.17 → 0.6.19

data/lib/ea/fonts/metrics.rb

@@ -4,12 +4,14 @@ require "json"
 
 module Ea
   module Fonts
-    # Advance-width metrics for Carlito, metric-compatible with
-    # Calibri. EA's exported textLength values encode Carlito
-    # advances scaled by per-style factors, so text widths computed
-    # here match EA's published SVGs to sub-pixel precision — far
-    # tighter than the legacy fitted-codepoint table, and style-aware
-    # (bold/italic variants), which the legacy table lacked.
+    # Advance-width metrics for the fonts EA's published SVGs use:
+    # Carlito (metric-compatible with Calibri), Arial, and Arial
+    # Narrow. EA's exported textLength values encode per-family,
+    # per-style, per-POINT-SIZE scale factors applied to the font's
+    # design advances (fitted by exact-count maximization against
+    # EA-published SVGs), so text widths computed here match EA's
+    # output to sub-pixel precision — far tighter than any legacy
+    # fitted-codepoint table, and style/size aware.
     module Metrics
       DATA_PATH = File.expand_path("carlito_metrics.json", __dir__)
 
@@ -21,16 +23,23 @@ module Ea
         [true, true] => :bold_italic
       }.freeze
 
-      # Families whose glyph metrics match the Carlito tables.
-      SUPPORTED_FAMILIES = %w[Carlito Calibri].freeze
+      # Families metric-compatible with a data-file family (the key
+      # is rendered even when the QEA named the other one).
+      FAMILY_ALIASES = {
+        "calibri" => "Carlito",
+        "carlito" => "Carlito",
+        "arial" => "Arial",
+        "arial narrow" => "Arial Narrow"
+      }.freeze
 
       # Advance used for codepoints missing from the tables.
       DEFAULT_ADVANCE = 0.25
 
-      # Carlito has no CJK glyphs; EA's renderer falls back to a
-      # proportional CJK font whose advances measure ~0.709em at the
-      # NOMINAL size (not scaled by the per-style factors) — fitted
-      # from EA-published textLengths (52 mixed-script samples).
+      # Carlito/Arial have no CJK glyphs; EA's renderer falls back to
+      # a proportional CJK font whose advances measure ~0.709em at
+      # the NOMINAL size (not scaled by the per-style factors) —
+      # fitted from EA-published textLengths (52 mixed-script
+      # samples).
       CJK_ADVANCE = 0.709
       CJK_RANGES = [
         (0x3000..0x303F),   # CJK punctuation
@@ -48,18 +57,23 @@ module Ea
         return nil unless supported_family?(family)
         return nil if text.nil? || text.empty?
 
-        latin, cjk_count = split_advance(text, weight: weight, style: style)
-        (latin * size_pt.to_f * factor_for(weight, style) +
+        latin, cjk_count = split_advance(text, family: family,
+                                                weight: weight, style: style)
+        (latin * size_pt.to_f * factor_for(family, size_pt, weight, style) +
          cjk_count * CJK_ADVANCE * size_pt.to_f).round(3)
       end
 
       def supported_family?(family)
-        SUPPORTED_FAMILIES.include?(family.to_s)
+        !resolve_family(family).nil?
+      end
+
+      def resolve_family(family)
+        FAMILY_ALIASES[family.to_s.downcase]
       end
 
       # Returns [latin_em (factor-scaled later), cjk_glyph_count].
-      def split_advance(text, weight: nil, style: nil)
-        table = table_for(weight, style)
+      def split_advance(text, family: nil, weight: nil, style: nil)
+        table = table_for(family, weight, style)
         latin = 0.0
         cjk = 0
         text.each_char.each do |ch|
@@ -76,12 +90,20 @@ module Ea
         CJK_RANGES.any? { |range| range.cover?(cp) }
       end
 
-      def factor_for(weight, style)
-        data["factors"][STYLE_KEYS.fetch([bold?(weight), italic?(style)], :regular).to_s]
+      # EA's scale factor varies by point size (GDI quantization):
+      # Carlito regular fits 1.390 at 7pt but 1.432 at 9pt. Sizes
+      # without a fitted entry use the style's default (7pt, the
+      # corpus's dominant size).
+      def factor_for(family, size_pt, weight, style)
+        style = STYLE_KEYS.fetch([bold?(weight), italic?(style)], :regular).to_s
+        table = data["factors"].fetch(resolve_family(family), {})
+                                  .fetch(style, {})
+        table[size_pt.to_i.to_s] || table["default"] || 1.0
       end
 
-      def table_for(weight, style)
-        data["advance"][STYLE_KEYS.fetch([bold?(weight), italic?(style)], :regular).to_s]
+      def table_for(family, weight, style)
+        style = STYLE_KEYS.fetch([bold?(weight), italic?(style)], :regular).to_s
+        data["advance"].fetch(resolve_family(family), {}).fetch(style, {})
       end
 
       def data
@@ -100,28 +122,46 @@ module Ea
         format("U+%04X", ch.ord)
       end
 
-      # Resolves the four Carlito style TTFs through the fontist gem
-      # (system index + downloaded formulas). Empty when fontist is
-      # unavailable or Carlito is not installed.
-      def carlito_font_files
+      # Resolves a family's four style TTFs through the fontist gem
+      # (system index + downloaded formulas). Style variants are
+      # identified from each file's head.macStyle bits — filenames
+      # vary across fontist formulas and system copies ("ArialBd",
+      # "Arial Narrow Bold"), so name-matching is unreliable. The
+      # first file matching each style wins (fontist orders the
+      # downloaded formulas ahead of system copies). Empty when
+      # fontist is unavailable or the family is not installed.
+      def font_files_for(family)
         require "fontist"
-        styles = %w[Regular Bold Italic BoldItalic]
-        Fontist::SystemFont.find("Carlito").filter_map do |path|
+        Fontist::SystemFont.find(family).each_with_object({}) do |path, out|
           next unless path.downcase.end_with?(".ttf")
 
-          style = File.basename(path, ".ttf").delete_prefix("Carlito-")
-          match = styles.find { |s| s.casecmp?(style) }
-          next unless match
+          style = style_from_mac_style(path)
+          next unless style
 
-          [match, path]
-        end.to_h
+          out[style] ||= path
+        end
       rescue LoadError, StandardError => e
-        raise if ENV['EA_FONTS_DEBUG']
+        raise if ENV["EA_FONTS_DEBUG"]
 
         {}
       end
 
-      # Reads advance widths from a TTF via the fontian gem (used by
+      # head.macStyle: bit 0 = BOLD, bit 1 = ITALIC.
+      def style_from_mac_style(path)
+        require "fontisan"
+        font = Fontisan::FontLoader.load(path)
+        mac_style = font.table("head").mac_style
+        key = [mac_style & 1 == 1, mac_style & 2 == 2]
+        STYLE_KEYS[key]
+      end
+
+      # Carlito's data-file name (historical) differs from the
+      # fontist family name used to resolve its TTFs.
+      def carlito_font_files
+        font_files_for("Carlito")
+      end
+
+      # Reads advance widths from a TTF via the fontisan gem (used by
       # `rake fonts:validate` to re-derive the tables).
       def advances_from_font(path)
         require "fontisan"

data/lib/ea/model/diagram_connector.rb

@@ -19,6 +19,11 @@ module Ea
       attribute :target_edge, :integer
       attribute :connector_type, :string
       attribute :direction, :string
+      # t_connector.SourceStereotype / DestStereotype — EA renders
+      # the «Property» end-label exactly on the stereotyped end
+      # (corpus-verified; direction alone does not decide).
+      attribute :source_stereotype, :string
+      attribute :target_stereotype, :string
       attribute :waypoints, Waypoint, collection: true, initialize_empty: true
       attribute :label, :string
       attribute :style, :hash, default: -> { {} }
@@ -54,6 +59,8 @@ module Ea
         map "targetPort", to: :target_port
         map "connectorType", to: :connector_type
         map "direction", to: :direction
+        map "sourceStereotype", to: :source_stereotype
+        map "targetStereotype", to: :target_stereotype
         map "waypoints", to: :waypoints, render_empty: true
         map "label", to: :label
         map "style", to: :style

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

@@ -199,6 +199,8 @@ module Ea
             relationship_ref: ref_for_raw_connector(conn),
             connector_type: conn.connector_type,
             direction: conn.direction,
+            source_stereotype: conn.sourcestereotype,
+            target_stereotype: conn.deststereotype,
             waypoints: waypoints,
             label_boxes: DEFAULT_LABEL_BOXES,
             style: {},
@@ -240,6 +242,8 @@ module Ea
             relationship_ref: ref_for_connector(link_row),
             connector_type: connector&.connector_type,
             direction: connector&.direction,
+            source_stereotype: connector&.sourcestereotype,
+            target_stereotype: connector&.deststereotype,
             waypoints: waypoints_for_link(link_row, diagram_row),
             source_port: connection_port(diagram_row, connector, :source, geom),
             target_port: connection_port(diagram_row, connector, :target, geom),

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

@@ -8,20 +8,14 @@ module Ea
       # stays a small value-object with just coordinate translation
       # and formatting concerns.
       #
-      # Sources contributing to the bounds:
-      #   - ElementBounds:    logical x-extent, logical+image y-extent
-      #   - ConnectorBounds:  waypoint positions
-      #   - MarkerExtent:     MARKER_EXTENT padding around end points
-      #   - PackageTabExtent: extra space above Package elements for
-      #                       the tab polygon (which sits above the
-      #                       element's logical top).
-      #
-      # Each source is a method returning an Array<[x, y]> points.
-      # Composing new sources = adding a method, no modification of
-      # existing ones (OCP).
+      # Corpus-verified against 3,663 EA-published reference SVGs:
+      # EA's canvas covers the ELEMENT RECTS only — connector
+      # waypoints, arrow markers, and package-tab overhangs do NOT
+      # extend it. Width = element extent + 85 is exact on 72% of
+      # the corpus; height = element extent + 76 exact on 50% (the
+      # remainder carry invisible per-diagram reservations below
+      # the content).
       class BoundsCalculator
-        MARKER_EXTENT = 15
-        PACKAGE_TAB_HEIGHT = 20
         # EA's canvas includes non-uniform frame insets around the
         # element content. Reverse-engineered from reference SVG
         # byte-diff: maintenance diagram has element 169x80 at
@@ -30,11 +24,12 @@ module Ea
         #   canvas_width  = element_width + INSET_LEFT + INSET_RIGHT
         #   canvas_height = element_height + INSET_TOP + INSET_BOTTOM
         # The top inset accommodates the frame tab + label space
-        # above the element.
+        # above the element. The bottom inset 36 matches the
+        # dominant corpus mode (50% of 3,663 diagrams).
         INSET_LEFT = 35
         INSET_RIGHT = 50
         INSET_TOP = 40
-        INSET_BOTTOM = 57
+        INSET_BOTTOM = 36
 
         attr_reader :diagram, :model_index
 
@@ -44,11 +39,7 @@ module Ea
         end
 
         def compute
-          points = []
-          points.concat(element_points)
-          points.concat(connector_points)
-          points.concat(marker_points)
-          points.concat(package_tab_points)
+          points = element_points
           return [0, 0, 1, 1] if points.empty?
 
           xs = points.map(&:first)
@@ -85,57 +76,6 @@ module Ea
           end
           pts
         end
-
-        # Package elements render with a tab polygon ABOVE the
-        # element's logical top edge (height PACKAGE_TAB_HEIGHT).
-        # Include those points so the canvas reserves space.
-        def package_tab_points
-          return [] if model_index.nil?
-
-          pts = []
-          (diagram.elements || []).each do |e|
-            ref = e.model_element_ref
-            next unless ref
-
-            candidate = model_index[ref]
-            next unless candidate.is_a?(Ea::Model::Package)
-
-            primary = e.bounds || e.image_bounds
-            next unless primary
-
-            pts << [primary.x, primary.y - PACKAGE_TAB_HEIGHT]
-            pts << [primary.x + primary.width, primary.y]
-          end
-          pts
-        end
-
-        def connector_points
-          pts = []
-          (diagram.connectors || []).each do |c|
-            (c.waypoints || []).each do |wp|
-              next unless wp.position
-
-              pts << [wp.position.x, wp.position.y]
-            end
-          end
-          pts
-        end
-
-        def marker_points
-          pts = []
-          (diagram.connectors || []).each do |c|
-            waypoints = (c.waypoints || []).map(&:position).compact
-            next unless waypoints.size >= 2
-
-            source = waypoints.first
-            target = waypoints.last
-            pts << [source.x - MARKER_EXTENT, source.y - MARKER_EXTENT]
-            pts << [source.x + MARKER_EXTENT, source.y + MARKER_EXTENT]
-            pts << [target.x - MARKER_EXTENT, target.y - MARKER_EXTENT]
-            pts << [target.x + MARKER_EXTENT, target.y + MARKER_EXTENT]
-          end
-          pts
-        end
       end
     end
   end

data/lib/ea/svg/ea_emitter/compartment/note_body.rb

@@ -21,10 +21,16 @@ module Ea
             %(<g style="#{group_style(context)}">\n#{text_blocks.join("\n")}\n</g>)
           end
 
+          # EA wraps note text by MEASURED width (Carlito advances),
+          # not character count: lines break at the last word whose
+          # cumulative integer textLength fits bounds.width - 15.
+          # Verified against EA-published reference SVGs.
           def wrapped_lines(context, body)
-            max_chars = [(context.bounds.width / (context.size * 0.6)).floor, 10].max
+            usable = context.bounds.width - 15
+            size = context.size
+            family = context.family
             body.to_s.split(/\n/).flat_map do |para|
-              para.gsub(/(.{1,#{max_chars}})(\s+|$)/, "\\1\n").strip.split(/\n/)
+              wrap_paragraph(para, usable, size, family)
             end.each_with_index.map do |line, idx|
               y = context.bounds.y + context.theme.note.text_y_offset +
                   (idx * context.theme.note.line_height)
@@ -40,6 +46,26 @@ module Ea
             end
           end
 
+          def wrap_paragraph(para, usable, size, family)
+            words = para.strip.split(/\s+/)
+            lines = []
+            current = ""
+            words.each do |word|
+              candidate = current.empty? ? word : "#{current} #{word}"
+              width = TextRenderer.estimate_width(candidate, size, nil,
+                                                  family: family).round
+              if current.empty? || width <= usable
+                current = candidate
+              else
+                lines << current
+                current = word
+              end
+            end
+            lines << current unless current.empty?
+            lines
+          end
+          module_function :wrap_paragraph
+
           def group_style(context)
             "stroke-width:1;stroke-linecap:round;stroke-linejoin:bevel; " \
               "fill:#{context.theme.text_color};fill-opacity:1.00; " \

data/lib/ea/svg/ea_emitter/element/attribute_renderer.rb

@@ -67,7 +67,11 @@ module Ea
                                          lookup: lookup).to_s
               end
             else
-              props.flat_map do |prop|
+              # EA lists attribute rows alphabetically (case-
+              # insensitive) — corpus-verified: 991 boxes strictly
+              # alphabetical vs 24 strictly stored-Pos order.
+              props.sort_by { |p| [p.name.to_s.downcase, p.name.to_s] }
+                   .flat_map do |prop|
                 lines = []
                 stereotype = property_stereotype(prop)
                 lines << "«#{stereotype}»" if stereotype

data/lib/ea/svg/ea_emitter/element/enumeration_literal_renderer.rb

@@ -13,9 +13,13 @@ module Ea
         # Rendered as a third compartment below the attribute
         # compartment for Enumeration classifiers.
         class EnumerationLiteralRenderer
+          # EA lists literals alphabetically (case-insensitive) and
+          # spaces rows at the same 13px pitch as attributes at 7pt
+          # (size + 6) — corpus-verified against EA-published SVGs.
           def self.render(literals, bounds:, first_y:, family:, size:)
-            line_h = size + 4
-            text_blocks = literals.each_with_index.map do |literal, idx|
+            line_h = size + 6
+            sorted = literals.sort_by { |l| [l.name.to_s.downcase, l.name.to_s] }
+            text_blocks = sorted.each_with_index.map do |literal, idx|
               y = first_y + (idx * line_h)
               build_text(bounds.x + 5, y, literal.name.to_s, family, size)
             end

data/lib/ea/svg/ea_emitter/element/header_line_pipeline.rb

@@ -11,16 +11,17 @@ module Ea
         #
         # Context (Struct) carries everything a provider might need:
         #   classifier, diagram_package_id, visually_nested,
-        #   umldi_keyword, bounds_width, font_size,
-        #   off_canvas_parent_name
+        #   umldi_keyword, bounds_width, font_size, family,
+        #   off_canvas_parent_name, foreign_package_name
         #
         # Each provider implements:
         #   def self.call(context)  →  Array<[[text, style], ...]>
         module HeaderLinePipeline
           Context = Struct.new(:classifier, :diagram_package_id,
                                :visually_nested, :umldi_keyword,
-                               :bounds_width, :font_size,
+                               :bounds_width, :font_size, :family,
                                :off_canvas_parent_name,
+                               :foreign_package_name,
                                keyword_init: true)
 
           PROVIDERS = [

data/lib/ea/svg/ea_emitter/element/header_line_provider/name.rb

@@ -8,16 +8,19 @@ module Ea
           # Emits the classifier's display name, with these behaviors:
           #
           # - Bold-italic for abstract Klass; bold otherwise.
-          # - Qualified name wrap when the rendered width exceeds the
-          #   element bounds. EA splits "pkg::Class" across two lines
-          #   when the combined width is too wide.
+          # - Foreign elements (owning package ≠ the diagram's package,
+          #   gated on t_diagram.ShowForeign) render the qualified
+          #   name "OwningPackage::Name".
+          # - Qualified-name wrap: when the combined integer
+          #   textLength exceeds the element bounds width, EA splits
+          #   "pkg::Class" across two lines ("pkg::" then "Class"),
+          #   each centered independently. Corpus-verified: every
+          #   wrapped header overflows its box and every single-line
+          #   header fits (tightest observed slack 6px).
           #
           # InstanceSpecification returns [] (InstanceSpec provider
           # already emitted the full label).
           class Name
-            QUALIFIED_WRAP_WIDTH_FACTOR = 0.55
-            QUALIFIED_WRAP_PADDING = 8
-
             def self.call(context)
               classifier = context.classifier
               return [] if classifier.is_a?(Ea::Model::InstanceSpecification)
@@ -34,9 +37,9 @@ module Ea
 
             def self.wrapped_name_lines(classifier, context, weight)
               name = display_name(classifier)
+              name = "#{context.foreign_package_name}::#{name}" if context.foreign_package_name
               unless context.bounds_width && name.include?("::") &&
-                     name_exceeds_bounds?(name, context.bounds_width,
-                                           context.font_size || 9)
+                     name_exceeds_bounds?(name, context, weight)
                 return [[name, weight]]
               end
 
@@ -44,15 +47,18 @@ module Ea
               [["#{qualifier}::", weight], [base, weight]]
             end
 
-            def self.name_exceeds_bounds?(name, bounds_width, font_size)
-              TextRenderer.estimate_width(name, font_size,
-                                          QUALIFIED_WRAP_WIDTH_FACTOR) >
-                (bounds_width - QUALIFIED_WRAP_PADDING)
+            def self.name_exceeds_bounds?(name, context, weight)
+              font_style = weight == :bold_italic ? "italic" : "normal"
+              len = TextRenderer.estimate_width(
+                name, context.font_size || 9, nil,
+                family: context.family, weight: "700", style: font_style
+              ).round
+              len > context.bounds_width
             end
 
-            # EA renders the plain classifier name in element headers.
-            # (Some ISO-corpus diagrams show "Pkg::Name" headers — the
-            # storage of that flag is not in the QEA; render plain.)
+            # EA renders the plain classifier name in element headers;
+            # qualification is layered on by the pipeline via
+            # context.foreign_package_name.
             def self.display_name(classifier, *_)
               classifier.name.to_s
             end

data/lib/ea/svg/ea_emitter/element/header_line_provider/stereotype_label.rb

@@ -51,20 +51,12 @@ module Ea
               refs.map { |ref| "«#{canonical(ref)}»" }
             end
 
-            # EA displays canonical stereotype spellings regardless of
-            # how the QEA stored them (property → Property). Prefer the
-            # MDG alias registry when its definition is available; the
-            # overrides map covers the spellings verified directly
-            # against EA-published reference SVGs.
-            DISPLAY_OVERRIDES = {
-              "property" => "Property",
-              "featuretype" => "FeatureType",
-              "objecttype" => "ObjectType",
-              "codelist" => "CodeList"
-            }.freeze
-
+            # EA renders the stereotype string exactly as stored in
+            # t_object.Stereotype — corpus-verified: 3,284 placements
+            # render verbatim ('CodeList', 'codeList', 'codelist',
+            # 'featureType' …), zero case-canonicalized.
             def self.canonical(ref)
-              DISPLAY_OVERRIDES.fetch(ref.downcase, ref)
+              ref
             end
 
             def self.fallback_name(classifier)

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

@@ -69,7 +69,9 @@ module Ea
                                                                 umldi_keyword: element.umldi_keyword,
                                                                 bounds_width: raw_bounds&.width,
                                                                 font_size: size,
-                                                                off_canvas_parent_name: parent_name) : []
+                                                                family: family,
+                                                                off_canvas_parent_name: parent_name,
+                                                                foreign_package_name: foreign_package_name_for(classifier)) : []
           is_classifier = classifier.is_a?(Ea::Model::Classifier)
           attr_lines = if is_classifier && show_attributes?
                          Element::AttributeRenderer.lines_for(
@@ -214,6 +216,26 @@ module Ea
           Ea::Model::Constraint.new(name: name, kind: "Marker")
         end
 
+        # EA qualifies a placed classifier's header with its owning
+        # package name ("OwningPackage::Name") exactly when the
+        # diagram's t_diagram.ShowForeign flag is set AND the
+        # classifier lives in a different package than the diagram
+        # (descendant packages included). Corpus-verified (450
+        # diagrams): ShowForeign=0 renders plain everywhere.
+        def foreign_package_name_for(classifier)
+          return nil unless diagram.show_foreign
+          return nil unless classifier.is_a?(Ea::Model::Classifier)
+
+          pkg_id = classifier.package_id
+          return nil if pkg_id.nil? || pkg_id == diagram.package_id
+
+          pkg = model_index ? model_index[pkg_id] : nil
+          return nil unless pkg.is_a?(Ea::Model::Package)
+
+          name = pkg.name.to_s
+          name.empty? ? nil : name
+        end
+
         # EA renders the off-canvas parent classifier's name as an
         # italic line at the top of a placed element's header when
         # ALL of these hold:

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

@@ -61,7 +61,7 @@ module Ea
               text_pos, mult_pos = tree_positions(end_kind, anchor, role,
                                                   text_pos, mult_pos)
             end
-            show_property = property_label?(connector)
+            show_property = property_label?(connector, end_kind)
 
             build_texts(role:, mult:, standalone:,
                         text_pos:, mult_pos:, show_property:)
@@ -113,27 +113,18 @@ module Ea
             end
           end
 
-          # EA renders «property» between role name and multiplicity
-          # ONLY for directed associations/aggregations — those with
-          # t_connector.Direction set to "Source -> Destination" or
-          # "Destination -> Source". "Unspecified" / "Bi-Directional"
-          # connectors do NOT get the stereotype label.
-          #
-          # Verified against both QEAs (output by the same EA in the
-          # same run):
-          #   - basic.qea: 4 Associations with Direction="Unspecified"
-          #     and role+mult → 0 «property» labels.
-          #   - plateau QEA: aggregations with Direction="Destination
-          #     -> Source" → «property» rendered (737 instances across
-          #     137 diagrams).
-          UNDIRECTED_DIRECTIONS = %w[Unspecified Bi-Directional].freeze
-
-          def property_label?(connector)
-            direction = connector.direction.to_s
-            return false if direction.empty?
-            return false if UNDIRECTED_DIRECTIONS.include?(direction)
-
-            true
+          # EA renders «Property» between role name and multiplicity
+          # exactly on connector ends carrying
+          # t_connector.SourceStereotype / DestStereotype = "Property"
+          # (case-insensitive; stored variants include "property").
+          # Direction does not decide — Fig 11's directed aggregations
+          # carry no end stereotype and render none, while the CityGML
+          # profile diagrams mark ends explicitly.
+          PROPERTY_KEYWORD = "property"
+
+          def property_label?(connector, end_kind)
+            stereo = end_kind == :source ? connector.source_stereotype : connector.target_stereotype
+            stereo.to_s.downcase == PROPERTY_KEYWORD
           end
 
           def role_empty?(role)

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

@@ -47,6 +47,10 @@ module Ea
         end
 
         def texts_for(connector)
+          # EA never labels NoteLink connectors — the note text lives
+          # in t_connector.Name but renders only inside the Note box.
+          return [] if connector.connector_type.to_s.casecmp("NoteLink").zero?
+
           points = waypoint_pairs(connector)
           return [] if points.size < 2
 

data/lib/ea/theme/definition.rb

@@ -62,7 +62,7 @@ module Ea
                                           tab_label_padding: 10,
                                           default_tab_width: 105).freeze
       DEFAULT_NOTE = NoteSpec.new(fold_size: 12, text_x_offset: 5,
-                                    text_y_offset: 12, line_height: 12).freeze
+                                    text_y_offset: 12, line_height: 13).freeze
 
       def initialize(id:, name: nil, font_family: nil, font_size: nil,
                      font_size_unit: "pt", text_weight_normal: 400,

data/lib/ea/version.rb

@@ -4,5 +4,5 @@ module Ea
   # Gem release version. Extracted to its own file so the
   # `gem-release` tool's `gem bump` can find and update it via the
   # standard `lib/<gem>/version.rb` convention.
-  VERSION = "0.6.17"
+  VERSION = "0.6.19"
 end