ea 0.6.140 → 0.6.141

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9db50e16de6c9f9faa698a872686600da15ba3eef0787de0b18b0ea56eca0394
-  data.tar.gz: b537f2b76e1fdb3a5a6dcfd1581db9f651279c5aff4e35882144da2ace23cf26
+  metadata.gz: 4f4c5df621df87a4df4467c9cbe157f70ea49d0463a892ed7e57ada3550b1937
+  data.tar.gz: 69fdddf140a6553c565287ce099bfa7f3d70d6c981502c559368c2e9860e70db
 SHA512:
-  metadata.gz: 9a685c1155369f6800fbfd294feed39ea2b450f482245c30be940c18bb31098466be6dbb0f0e6ca28e90502798ceaf10c8a5bbac0f0739b619b1cc0cd69696cb
-  data.tar.gz: 570de8eaf44e482c0330cc96f17eb2ab89e26a75542c613617b53468040b45dfec9ce597b308cd50b068d0a78e20e415a9cda9e897622f1cc1b1ab2a4e110baa
+  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

@@ -105,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)
@@ -114,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
@@ -152,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
@@ -164,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)
@@ -206,8 +220,16 @@ module Ea
       end
       private_class_method :measured_carlito_widths
 
-      def cambria_text_length(text, size_pt, weight, style)
-        return cambria_cjk_only_length(text, size_pt, weight, style) 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)
 
@@ -223,17 +245,23 @@ module Ea
       private_class_method :cambria_text_length
 
       # Cambria has no Latin table outside 7pt, but a run made only of
-      # characters in the measured MS UI Gothic table is exact at any
-      # measured height. EMPIRICAL FIT (decision a): EA draws a bold
-      # Cambria CJK run at logical height >= 17 with the regular-weight
-      # advances (no synthetic-bold pixel), although the Windows table
-      # records one. Checked on the 116 native legend titles "凡例"
-      # (Cambria bold 12pt, H17): native textLength 34 = 2 x 17, where
-      # the 17:700 entry would give 36. Below H17 bold keeps the bold
-      # table (native 7pt bold "都市計画データ" = 70).
-      def cambria_cjk_only_length(text, size_pt, weight, style)
-        height = gdi_logical_height(size_pt)
-        bold = bold?(weight) && height < CAMBRIA_REGULAR_BOLD_MIN_HEIGHT
+      # 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)

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

@@ -7,6 +7,10 @@ module Ea
         # 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
 
@@ -19,19 +23,26 @@ 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?
-
-            model.waypoints = [ends[0], bend, ends[1]].map { |point| Ea::Model::Waypoint.new(position: point) }
-            model.source_anchor, model.target_anchor = origins
-            model
+            [origins, [ends[0], bend, ends[1]]] if ends.all?
           end
 
           # EMPIRICAL FIT (decision a), not a source-backed rule. A width-0
@@ -48,22 +59,37 @@ module Ea
             return model if context || !reversed_tree_link?(model, link_row, diagram_row, geom)
 
             start, finish = stored_ray_boxes(link_row, diagram_row)
-            bus, start_edge, finish_edge = reversed_tree_levels(start, finish)
-            return model unless bus
+            route = reversed_tree_points(start, finish, geom, stored_bus_levels(link_row))
+            return model unless route
 
-            first = reversed_tree_leg(start, geom[:sx], geom[:sy], start_edge, finish)
-            last = reversed_tree_leg(finish, geom[:ex], geom[:ey], finish_edge, start)
-            model.waypoints = [first, [first[0], bus], [last[0], bus], last].map do |x, y|
+            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 first[1] != start_edge
+            model.style = model.style.to_h.merge(left_seated_source: true) if beside
             model
           end
 
+          # 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
@@ -92,25 +118,37 @@ module Ea
 
           def stored_bus_levels(link_row)
             bends = intermediate_waypoints(link_row)
-            bends.size == 2 && bends.first[1] == bends.last[1]
+            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.
-          def reversed_tree_levels(start, finish)
+          #
+          # 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
-              [bus, start.y, finish.y + finish.height] if bus < start.y
+              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
-              [bus, start.y + start.height, finish.y] if bus > start.y + start.height
+              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 (outside its
-          # x-span but level with it), where the origin itself is kept.
+          # 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).
@@ -124,8 +162,12 @@ module Ea
             pull = span.positive? ? 1 - [offset_y.to_i.abs / span, 1].min : 1
             pulled = (offset_x.to_i.abs * pull).ceil * (offset_x.to_i.negative? ? -1 : 1)
             origin = stored_ray_origin(box, pulled, offset_y)
-            beside = !origin.x.between?(box.x, box.x + box.width) && origin.y.between?(box.y, box.y + box.height)
-            [origin.x, beside ? origin.y : edge_y]
+            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

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

@@ -202,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.

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

@@ -197,9 +197,11 @@ module Ea
 
         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|
@@ -368,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) &&

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/stored_route/reversed_routes.rb

@@ -18,21 +18,17 @@ module Ea
             return {} unless reversed_tree_candidate?(model, link, bounds, offsets)
 
             start, finish = bounds.values_at(:source, :target)
-            bus, start_edge, finish_edge = reversed_tree_levels(start, finish)
-            return {} unless bus
+            route = reversed_tree_points(start, finish, ray_geometry(offsets, edge), stored_bus_levels(link))
+            return {} unless route
 
-            geom = ray_geometry(offsets, edge)
-            first = reversed_tree_leg(start, geom[:sx], geom[:sy], start_edge, finish)
-            last = reversed_tree_leg(finish, geom[:ex], geom[:ey], finish_edge, start)
-
-            reversed_tree_fields(model, first, last, bus, first[1] != start_edge)
+            reversed_tree_fields(model, route[0], route[1])
           end
 
-          def reversed_tree_fields(model, first, last, bus, beside)
+          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(first), point_for(last)]
-            { waypoints: points_to_waypoints([first, [first[0], bus], [last[0], bus], last]),
+            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
@@ -49,26 +45,14 @@ module Ea
           def reversed_corner_metadata(model, link, bounds, offsets, edge)
             return {} unless reversed_corner_candidate?(model, link, bounds, offsets, edge)
 
-            boxes = bounds.values_at(:source, :target)
-            origins = corner_origins(boxes, ray_geometry(offsets, edge))
-            bend = Ea::Model::Point.new(**%i[x y].zip(intermediate_waypoints(link).first).to_h)
-            ends = origins.zip(boxes).map { |origin, box| corner_exit(origin, bend, box) }
-            ends.all? ? corner_fields(origins, bend, ends) : {}
-          end
+            origins, points = reversed_corner_points(bounds.values_at(:source, :target), ray_geometry(offsets, edge),
+                                                     intermediate_waypoints(link).first)
+            return {} unless points
 
-          def corner_fields(origins, bend, ends)
-            { waypoints: points_to_waypoints([ends[0], bend, ends[1]].map { |point| [point.x, point.y] }),
+            { waypoints: points_to_waypoints(points.map { |point| [point.x, point.y] }),
               source_anchor: origins[0], target_anchor: origins[1] }
           end
 
-          def corner_origins(boxes, geom)
-            [stored_ray_origin(boxes[0], geom[:sx], geom[:sy]), stored_ray_origin(boxes[1], geom[:ex], geom[:ey])]
-          end
-
-          def corner_exit(origin, bend, box)
-            inside_box?(origin, box) ? diagonal_corner_exit(origin, bend, box) : origin
-          end
-
           def reversed_corner_candidate?(model, link, bounds, offsets, edge)
             model.connector_type == "Association" && model.style[:reversed_ends] && edge == 2 &&
               model.style.to_h.values_at(:mode, :lwidth, :tree) == ["3", "0", nil] &&

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

@@ -12,7 +12,7 @@ module Ea
       # 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
-      # of the diagram's own package. Misses: 2 outliers.
+      # or instance of the diagram's own package. Misses: 2 outliers.
       class BottomMargin
         BARE = 10
         LINE_ALLOWANCE = 21
@@ -41,7 +41,7 @@ module Ea
           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_classifier?(model, diagram)
+                         home_element?(model, diagram)
 
           LINE_ALLOWANCE + points(element)
         end
@@ -60,17 +60,21 @@ module Ea
           model.is_a?(Ea::Model::Note) && model.note_type != "Text"
         end
 
-        # A classifier that lives in the diagram's own package draws no
-        # "(from Package)" row under its name (nor an owner-class
-        # qualifier), so EA keeps only the bare margin below it. Checked
-        # on the 7 PLATEAU diagrams whose lowest class is in the
-        # diagram's package (all natively 10) against the 84 that are
-        # foreign (all 28..31).
-        def self.home_classifier?(model, diagram)
-          model.is_a?(Ea::Model::Classifier) &&
+        # 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 &&
-            model.nested_parent_name.to_s.empty?
+            model.package_id == diagram.package_id
         end
 
         # A Text element of the diagram's own package keeps 13 + its