ea 0.6.120 → 0.6.122

data/lib/ea/fonts/metrics.rb

@@ -51,6 +51,9 @@ module Ea
       # Advance used for codepoints missing from the tables.
       DEFAULT_ADVANCE = 0.25
 
+      # Inferred subpixel steps that reproduce EA's near-half-pixel rounding.
+      GDI_SUBPIXELS = 64
+
       # 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) —
@@ -89,6 +92,13 @@ module Ea
         (size.to_f * 10 / 7).round
       end
 
+      # Quantize before rounding: near-half-pixel Carlito advances
+      # round up in EA's output. The 1/64px step is inferred.
+      def gdi_pixel_advance(advance, height)
+        ((advance * height * GDI_SUBPIXELS).round / GDI_SUBPIXELS.to_f).round
+      end
+      private_class_method :gdi_pixel_advance
+
       def compact_compartment_font?(size, family:, unit: "pt")
         family.to_s.casecmp("Cambria").zero? && size == 7 && unit == "pt"
       end
@@ -122,7 +132,7 @@ module Ea
             if cjk?(ch.ord)
               cjk_count += 1
             else
-              latin += ((table[cp_key(ch)] || DEFAULT_ADVANCE) * height).round
+              latin += gdi_pixel_advance(table[cp_key(ch)] || DEFAULT_ADVANCE, height)
             end
           end
           return latin + cjk_count * CJK_ADVANCE * size_pt.to_f
@@ -166,7 +176,7 @@ module Ea
 
       # Families whose EA driver quantizes per-glyph advances
       # (fitted from published textLengths).
-      GDI_HEIGHT_FAMILIES = %w[Carlito].freeze
+      GDI_HEIGHT_FAMILIES = %w[Carlito Arial].freeze
 
       def supported_family?(family)
         !resolve_family(family).nil?

data/lib/ea/model/diagram_element.rb

@@ -22,6 +22,8 @@ module Ea
       attribute :line_width, :integer
       attribute :font_family, :string
       attribute :font_size, :integer
+      # nil: unspecified provenance; true: source delegates to default resolution.
+      attribute :font_size_inherited, :boolean
       attribute :font_logical_height, :integer # original GDI pixel height before point normalization
       attribute :font_size_unit, :string # source font size unit, before theme fallback
       attribute :font_bold, :boolean
@@ -55,6 +57,7 @@ module Ea
         map "lineWidth", to: :line_width
         map "fontFamily", to: :font_family
         map "fontSize", to: :font_size
+        map "fontSizeInherited", to: :font_size_inherited, render_default: true
         map "fontSizeUnit", to: :font_size_unit
         map "fontLogicalHeight", to: :font_logical_height
         map "fontBold", to: :font_bold, render_default: true

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

@@ -138,6 +138,7 @@ module Ea
             style: style_hash,
             font_family: presence(font_style[:font]),
             font_size: font_size_from(font_style),
+            font_size_inherited: font_size_from(font_style).nil?,
             font_size_unit: "pt",
             font_logical_height: font_logical_height_from(font_style),
             font_bold: truthy?(style_hash[:bold]),
@@ -150,14 +151,14 @@ module Ea
           )
         end
 
-        # Negative widths inherit the saved object border, then the diagram theme.
+        # 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)
           [style[:lwth], object&.borderwidth].each do |raw|
             next if raw.nil? || raw.to_s.empty?
 
             width = raw.to_i
-            return width if width >= 0
+            return [width, 1].max if width >= 0
           end
           nil
         end

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

@@ -6,7 +6,7 @@ module Ea
       # Single source of truth for fill + stroke color decisions.
       #
       # Theme :119 applies:
-      #   - Border color (#9A8484) for element strokes
+      #   - Black default element strokes
       #   - Method color for operation text
       # Theme :119 does NOT apply:
       #   - Per-type fill colors (elements use default #FFFFFF)

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

@@ -21,13 +21,8 @@ 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)
-            # EA's note wrap padding is 4: lines fit bounds.width - 4
-            # (9BA1CE54: width 214, longest line tl 210). Pitch and
+            # Lines fit bounds.width - 4. Pitch and
             # first-line offset scale with the note font (9pt: pitch
             # 16 = size+7, first line at bounds.y + 18 = size+9), and
             # each paragraph break adds one blank pitch row
@@ -41,7 +36,8 @@ module Ea
             y_index = 0
             paragraphs = NoteHtml.paragraphs(body)
             paragraphs.flat_map do |para|
-              lines = wrap_paragraph(para.text, usable, size, context.family)
+              lines = wrap_paragraph(para.text, usable, size, context.family,
+                                     logical_height: context.logical_height)
               paragraph_svg = lines.each_with_index.map do |line, i|
                 y = context.bounds.y + first_offset + ((y_index + i) * pitch)
                 TextRenderer.new(
@@ -50,6 +46,7 @@ module Ea
                   y: y,
                   family: context.family, size: context.size,
                   size_unit: context.size_unit,
+                  logical_height: context.logical_height,
                   fill: context.theme.text_color,
                   stroke_in_text: context.theme.stroke_in_text_color,
                   width_factor: context.theme.text_width_factor
@@ -60,14 +57,18 @@ module Ea
             end
           end
 
-          def wrap_paragraph(para, usable, size, family)
-            words = para.strip.split(/\s+/)
+          # Wrap at whitespace until native script-specific break metrics are
+          # established. Every word but the paragraph's last carries its
+          # trailing space into the fit test.
+          def wrap_paragraph(para, usable, size, family, logical_height: nil)
             lines = []
             current = ""
-            words.each do |word|
+            words = para.strip.split(/\s+/)
+            words.each_with_index do |word, index|
               candidate = current.empty? ? word : "#{current} #{word}"
-              width = TextRenderer.estimate_width(candidate, size, nil,
-                                                  family: family).round
+              trailing = index < words.size - 1 ? " " : ""
+              width = TextRenderer.estimate_width("#{candidate}#{trailing}", size, nil,
+                                                  family: family, logical_height: logical_height).round
               if current.empty? || width <= usable
                 current = candidate
               else

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

@@ -15,7 +15,7 @@ module Ea
                 context.bounds,
                 legend: context.model_element.legend,
                 family: context.family,
-                item_font: { size: context.element&.font_size&.nonzero?, unit: context.size_unit,
+                item_font: { size: legend_item_size(context), unit: context.size_unit,
                              logical_height: context.logical_height }
               )
             elsif context.model_element.is_a?(Ea::Model::Note)
@@ -54,6 +54,17 @@ module Ea
             end
           end
 
+          def legend_item_size(context)
+            element = context.element
+            return unless element
+            return element.font_size if element.font_size&.nonzero?
+
+            # Parsed source defaults inherit; unspecified callers keep 9pt.
+            inherited = element.font_size_inherited || element.style&.fetch(:fontsz, nil).to_s == "0"
+            context.size if inherited
+          end
+          private_class_method :legend_item_size
+
           # A Text element with LegendOpts= renders as the legend
           # block rather than a folder silhouette. Dispatch on the
           # presence of the attached Legend payload.

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

@@ -233,7 +233,8 @@ module Ea
         private_class_method :facing_coordinate
 
         def stroke_outline?(connector, bounds)
-          (connector.style.to_h[:lwidth] == "2" || default_model_connector?(connector)) &&
+          (connector.style.to_h[:lwidth] == "2" || default_model_connector?(connector) ||
+           connector.connector_type == "NoteLink") &&
             bounds.all? { |box| box.width.positive? && box.height.positive? } &&
             outline_connector?(connector, bounds)
         end
@@ -311,7 +312,7 @@ module Ea
 
         def outline_connector?(connector, bounds)
           return true if default_model_connector?(connector)
-          return true if %w[Generalization Aggregation].include?(connector.connector_type)
+          return true if %w[Generalization Aggregation NoteLink].include?(connector.connector_type)
 
           return true if association_ray_outline?(connector)
           return false unless stored_association?(connector) || offset_free_association?(connector)

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

@@ -31,22 +31,39 @@ module Ea
           @divider_y_by_ref = divider_y_by_ref
         end
 
+        # EA draws each connector (and its markers) with the pen width
+        # stored in the diagram link style (`LWidth`); links without
+        # the field keep the diagram default.
+        def self.stroke_width_for(connector, default)
+          style = connector.style || {}
+          raw = style[:lwidth] || style["lwidth"]
+          return default if raw.to_s.strip.empty?
+
+          [raw.to_i, 1].max
+        end
+
+        # Layer key for a style group: the plain key at the default
+        # width, suffixed with the width otherwise so layers of
+        # different widths never merge.
+        def self.layer_key(key, width, default)
+          width == default ? key : :"#{key}_w#{width}"
+        end
+
         def layers
-          paths = visible_connectors.filter_map { |c| path_for(c) }
-          return [] if paths.empty?
+          styles = paths_with_styles
 
           if grouped
-            [Layer.new(style_key: LINE_STYLE_KEY, style: line_style,
-                       body: paths.join("\n  "))]
-          else
-            paths.map do |path|
-              Layer.new(style_key: LINE_STYLE_KEY, style: line_style, body: path)
+            styles.group_by(&:first).map do |(width, dashed), entries|
+              line_layer(width, dashed, entries.map(&:last).join("\n  "))
             end
+          else
+            styles.map { |(width, dashed), path| line_layer(width, dashed, path) }
           end
         end
 
-        def line_style
-          "stroke-width:#{stroke_width};stroke-linecap:round;stroke-linejoin:bevel; fill:#000000;fill-opacity:0.00; stroke:#000000; stroke-opacity:1.00"
+        def line_style(width = stroke_width)
+          "stroke-width:#{width};stroke-linecap:round;stroke-linejoin:bevel; " \
+            "fill:#000000;fill-opacity:0.00; stroke:#000000; stroke-opacity:1.00"
         end
 
         # Backwards-compatible render — joins all layers' `<g>`.
@@ -56,6 +73,31 @@ module Ea
 
         private
 
+        def paths_with_styles
+          visible_connectors.filter_map do |connector|
+            path = path_for(connector)
+            next unless path
+
+            [[self.class.stroke_width_for(connector, stroke_width), dashed?(connector)], path]
+          end
+        end
+
+        def line_layer(width, dashed, body)
+          key = dashed ? :connector_line_dashed : LINE_STYLE_KEY
+          style = line_style(width)
+          style += ";stroke-dasharray:6,3" if dashed
+          Layer.new(style_key: self.class.layer_key(key, width, stroke_width),
+                    style: style, body: body)
+        end
+
+        def dashed?(connector)
+          return true if connector.connector_type == "Dependency"
+          return false unless connector.connector_type == "Package"
+
+          relationship = model_index && model_index[connector.relationship_ref]
+          relationship&.stereotype == "import"
+        end
+
         def visible_connectors
           (diagram.connectors || []).select(&:renderable?)
         end

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

@@ -10,13 +10,12 @@ module Ea
         # type.
         #
         # Layout (element bounds cover tab + body together; the tab
-        # occupies the TOP of the stored rect — corpus-verified
-        # against EA-published package polygons, single tab 20px and
-        # stereotype tab 36px, both inside):
+        # occupies the TOP of the stored rect, with its height adjusted
+        # by the font line height for each header row):
         #
         #   ┌───┐
-        #   │tab│   ← top TAB_HEIGHT rows of the bounds;
-        #   │   │     36px when a stereotype is present
+        #   │tab│   ← one name row, or two rows with a stereotype
+        #   │   │
         #   ├───┴──────────┐
         #   │               │  the name renders bold, left-aligned;
         #   │     body      │  the body always starts where the
@@ -148,7 +147,11 @@ module Ea
           end
 
           def tab_height
-            has_stereotype? ? TAB_HEIGHT_DOUBLE : TAB_HEIGHT_SINGLE
+            nominal_height = has_stereotype? ? TAB_HEIGHT_DOUBLE : TAB_HEIGHT_SINGLE
+            rows = has_stereotype? ? 2 : 1
+            # Preserve the nominal padding while each row follows the same
+            # font line height used to place the package header text.
+            nominal_height + rows * (tab_line_height - TAB_LABEL_Y_OFFSET)
           end
 
           def body_points

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

@@ -9,32 +9,15 @@ module Ea
         # chevron) when a stereotype provides a custom icon via
         # ShapeScript.
         #
-        # Currently provides hardcoded fallback polygons for the most
-        # common GML stereotypes (FeatureType, Type) since the source
-        # ShapeScript definitions live in EA's encrypted
-        # InternalTechnologies (TODO.diagrams/87). Future enhancement:
-        # read shapescript from MDG files when available.
+        # Only MDG-provided ShapeScript is rendered.
         class StereotypeIconRenderer
-          # Hardcoded fallback icons keyed by stereotype name.
-          # Each entry is [fill, stroke, points_array].
-          FALLBACK_ICONS = {
-            "FeatureType" => ["#FAF1EC", "#69738C",
-                              [[0, -5], [5, 0], [0, 5], [-5, 0]]],
-            "Type" => ["#FAF1EC", "#69738C",
-                       [[0, -5], [5, 0], [0, 5], [-5, 0]]]
-          }.freeze
-
-          # Default position offset from element's center
-          OFFSET_X = 0
-          OFFSET_Y = 0
-
           attr_reader :classifier, :bounds, :canvas, :mdg_registry
 
           # @param mdg_registry [Ea::Mdg::Registry, nil] optional
           #   registry to look up MDG-provided ShapeScript for the
           #   classifier's stereotype. When provided and the matching
           #   stereotype has a ShapeScript body, it's parsed and
-          #   rendered. Otherwise falls back to FALLBACK_ICONS.
+          #   rendered.
           def initialize(classifier:, bounds:, canvas: nil, mdg_registry: nil)
             @classifier = classifier
             @bounds = bounds
@@ -51,12 +34,12 @@ module Ea
             return "" unless classifier && bounds
             return "" unless stereotype_name
 
-            shapescript_svg || fallback_svg
+            shapescript_svg.to_s
           end
 
           private
 
-          # Try MDG-provided ShapeScript first.
+          # Renders MDG-provided ShapeScript for the stereotype.
           # @return [String, nil] SVG fragment from parsed ShapeScript
           def shapescript_svg
             return nil unless mdg_registry
@@ -83,35 +66,12 @@ module Ea
             nil
           end
 
-          # @return [String] hardcoded fallback polygon, or "" if none
-          def fallback_svg
-            spec = FALLBACK_ICONS[stereotype_name]
-            return "" unless spec
-
-            fill, stroke, points = spec
-            cx = bounds.x + bounds.width / 2 + OFFSET_X
-            cy = bounds.y + bounds.height / 2 + OFFSET_Y
-            translated = points.map { |x, y| translate_point(cx + x, cy + y) }
-            pts_str = translated.map { |x, y| coord(x) + "," + coord(y) }.join(" ")
-            %(<polygon points="#{pts_str}" fill="#{fill}" stroke="#{stroke}" stroke-width="1"/>)
-          end
-
           def stereotype_name
             return nil unless classifier.is_a?(Ea::Model::Classifier)
 
             refs = classifier.stereotype_refs
             refs&.first
           end
-
-          def translate_point(x, y)
-            return [x, y] unless canvas
-
-            [canvas.translate_x(x), canvas.translate_y(y)]
-          end
-
-          def coord(value)
-            Ea::Svg::EaEmitter::Canvas.coord(value)
-          end
         end
       end
     end

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

@@ -11,7 +11,7 @@ module Ea
       class Elements
         DEFAULT_FILL = "#FFFFFF"
         DEFAULT_STROKE = "#000000"
-        DEFAULT_STROKE_WIDTH = 2
+        DEFAULT_STROKE_WIDTH = 1
         DEFAULT_TEXT_COLOR = "#000000"
 
         attr_reader :diagram, :model_index, :canvas, :document
@@ -152,8 +152,10 @@ module Ea
                         []
                       end
           # Titles wrap; content rows grow the drawn box to fit their insets.
-          row_w = [row_content_width(attr_lines, 5, size, family, logical_height),
-                   row_content_width(op_lines, 3, size, family, logical_height),
+          row_w = [row_content_width(attr_lines, 5, size, family,
+                                     logical_height: logical_height,
+                                     content_x_offset: attribute_content_x_offset(size, family, size_unit)),
+                   row_content_width(op_lines, 3, size, family, logical_height: logical_height),
                    Compartment::EnumLiterals.content_width(
                      enum_literals_for(classifier),
                      theme: theme, size: size, family: family,
@@ -178,6 +180,9 @@ module Ea
                                                                 off_canvas_parent_name: parent_name,
                                                                 foreign_package_name: foreign_package_name_for(classifier),
                                                                 suppress_stereotypes: suppress_stereotypes?) : []
+          header_lines = header_lines.map do |text, style|
+            [text, font_resolver.header_style_for(style, element)]
+          end
           geometry = compartment_geometry(bounds, size, attr_lines, op_lines,
                                           tagged_values_for(classifier).size,
                                           header_lines, classifier: classifier, family: family,
@@ -246,7 +251,8 @@ module Ea
           # Real attributes grow the DRAWN box past the stored
           # height instead of being dropped (0CABA7D7: stored h44
           # draws at h59). Grown height = last row baseline + EA's
-          # ~8px bottom padding. Render-local: the diagram-level
+          # trailing padding (7px for compact Cambria, 8px otherwise).
+          # Render-local: the diagram-level
           # canvas still derives from stored bounds.
           # content_bottom_y is nil when no compartment has rows;
           # op_bottom_y is NOT a sentinel (it reports the op-divider
@@ -257,13 +263,15 @@ module Ea
           # Bag': Set enum box stored h59 -> EA 223 fitting six
           # literals); op-only boxes keep the no-growth behavior
           # (op_bottom_y is a divider sentinel, not content).
+          # Saved boxes may already fit rows with less than the growth
+          # padding. Test the baseline for overflow before adding padding.
           if (attr_lines.any? || enum_literals_for(classifier).any?) &&
              grown_bottom.positive? &&
-             grown_bottom + 8 > bounds.y + bounds.height
+             grown_bottom > bounds.y + bounds.height
             bounds = Ea::Model::Bounds.new(
               x: bounds.x, y: bounds.y,
               width: bounds.width,
-              height: grown_bottom + 8 - bounds.y
+              height: grown_bottom + compartment_bottom_padding(size, family, size_unit) - bounds.y
             )
           end
           RenderContext.new(
@@ -293,18 +301,30 @@ module Ea
           )
         end
 
-        def row_content_width(lines, right_pad, size, family, logical_height)
+        def attribute_content_x_offset(size, family, size_unit)
+          offset = (theme.attribute_spec.content_x_offset || Element::AttributeRenderer::DEFAULT_CONTENT_X_OFFSET) +
+                   2 * (size - 7)
+          offset -= 1 if Ea::Fonts::Metrics.compact_compartment_font?(size, family: family, unit: size_unit)
+          offset
+        end
+
+        def compartment_bottom_padding(size, family, size_unit)
+          Ea::Fonts::Metrics.compact_compartment_font?(size, family: family, unit: size_unit) ? 7 : 8
+        end
+
+        def row_content_width(lines, right_pad, size, family, **font_options)
           return nil if lines.to_a.empty?
 
-          tl = lines.filter_map do |line|
+          lines.filter_map do |line|
             text = line.sub(/\A\S /, "")
-            Ea::Fonts::Metrics.text_length(text, size,
-                                           family: family,
-                                           weight: "400", logical_height: logical_height)&.round
-          end.max
-          return nil unless tl
+            length = Ea::Fonts::Metrics.text_length(text, size,
+                                                    family: family,
+                                                    weight: "400", logical_height: font_options[:logical_height])&.round
+            next unless length
 
-          22 + tl + right_pad
+            offset = line.match?(/\A[-+~#]\s/) ? font_options.fetch(:content_x_offset, 22) : 22
+            offset + length + right_pad
+          end.max
         end
 
         def compartment_geometry(bounds, size, attr_lines, op_lines,

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

@@ -43,7 +43,7 @@ module Ea
             return explicit
           end
 
-          theme_family_for(explicit) || diagram_default_family || DEFAULT_FONT_FAMILY
+          default_family_for(explicit)
         end
 
         def size_for(element)
@@ -72,14 +72,29 @@ module Ea
         end
 
         def style_for(element)
-          element&.font_italic ? "italic" : "normal"
+          return "italic" if element&.font_italic
+          return "normal" if element&.style&.key?(:italic)
+
+          diagram.hand_draw ? "italic" : "normal"
+        end
+
+        def header_style_for(style, element)
+          return style unless diagram.hand_draw && style_for(element) == "italic"
+
+          style == :bold ? :bold_italic : style
         end
 
         private
 
+        def default_family_for(explicit)
+          return "Source Sans Pro" if diagram.hand_draw
+
+          theme_family_for(explicit) || diagram_default_family || DEFAULT_FONT_FAMILY
+        end
+
         def theme_family_for(explicit)
           return unless theme.themed?
-          return theme.font_family if DEFAULT_MARKER_FAMILIES.include?(explicit)
+          return theme.font_family || "Carlito" if DEFAULT_MARKER_FAMILIES.include?(explicit)
 
           theme.element_font_family || theme.font_family
         end

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

@@ -79,6 +79,7 @@ module Ea
               text_pos, mult_pos = tree_positions(end_kind, anchor, role,
                                                   text_pos, mult_pos)
               mult_pos = tree_left_multiplicity(end_kind, heading, anchor, mult_box, mult) || mult_pos
+              text_pos = tree_left_property_role(connector, end_kind, heading, anchor, text_box, role) || text_pos
             elsif mult_box && stored_offsets_zero?(mult_box)
               # Start at the legacy default; measured directional seats
               # below replace it for default Cambria labels.
@@ -210,8 +211,9 @@ module Ea
 
           def source_property_seat?(connector, direction, box)
             phantom_property_box?(connector, direction, box) ||
-              (%i[up left right down].include?(direction) && property_role_box?(box, direction) &&
-                source_property_font?(connector, direction))
+              (%i[up left right down].include?(direction) &&
+                property_role_box?(box, direction, connector.style.to_h) &&
+                source_property_font?(connector, direction, box))
           end
 
           # Phantom outlines carry synthesized zero boxes without alignment.
@@ -392,9 +394,23 @@ module Ea
               [nil, "V"].include?(style[:tree])
           end
 
-          def property_role_box?(box, direction)
-            alignments = direction == :down ? [1] : [0, 1]
-            box && alignments.include?(box["alignment"]) && default_presentation?(box)
+          def property_role_box?(box, direction, style = {})
+            return false unless box && default_presentation?(box)
+            return [0, 1].include?(box["alignment"]) unless direction == :down
+
+            case box["alignment"]
+            when 1 then true
+            when 0 then persisted_plain_down_box?(box, style)
+            else false
+            end
+          end
+
+          # Persisted alignment-0 boxes on untreed routes use the downward
+          # seat, including saved rays; the "OS" route also seats absent boxes.
+          def persisted_plain_down_box?(box, style)
+            return true if orthogonal_stub_route?(style)
+
+            !stored_offsets_zero?(box) && style[:tree].nil?
           end
 
           def property_role_offsets(direction)
@@ -405,26 +421,58 @@ module Ea
             end
           end
 
-          def source_property_font?(connector, direction)
+          def source_property_font?(connector, direction, box)
             source_property_cambria?(connector) &&
-              source_property_route?(connector.style.to_h, direction)
+              source_property_route?(connector.style.to_h, direction, box)
           end
 
           def source_property_cambria?(connector)
             font_family.to_s.casecmp("Cambria").zero? && property_label?(connector, :source)
           end
 
-          def source_property_route?(style, direction)
+          def source_property_route?(style, direction, box)
             case direction
-            when :left then left_property_route?(style)
             when :right then style.values_at(:mode, :lwidth, :tree) == %w[3 2 H]
-            when :down then downward_property_route?(style)
-            else %w[0 2].include?(style[:lwidth]) && style[:tree] != "OS"
+            when :up then upward_property_route?(style)
+            when :left then orthogonal_stub_route?(style) || left_property_route?(style)
+            else downward_source_route?(style, box)
             end
           end
 
+          def downward_source_route?(style, box)
+            [orthogonal_stub_route?(style), lateral_horizontal_route?(style), mode_two_route?(style),
+             downward_property_route?(style), persisted_width_zero_down_box?(box, style)].any?
+          end
+
+          def persisted_width_zero_down_box?(box, style)
+            box["alignment"]&.zero? && !stored_offsets_zero?(box) && style[:stored_association_ray] != true &&
+              style.values_at(:mode, :lwidth, :tree) == ["3", "0", nil]
+          end
+
+          # Mode 3, width 2 on the horizontal lateral tree.
+          def lateral_horizontal_route?(style)
+            style.values_at(:mode, :lwidth, :tree) == %w[3 2 LH]
+          end
+
+          # Mode 2, width 2 without a tree seats like the other width-2 modes.
+          def mode_two_route?(style)
+            style.values_at(:mode, :lwidth, :tree) == ["2", "2", nil]
+          end
+
+          def upward_property_route?(style)
+            return orthogonal_stub_route?(style) if style[:tree] == "OS"
+
+            %w[0 2].include?(style[:lwidth])
+          end
+
+          # The "OS" route seats its Property roles at the same directional
+          # corner seats as the untreed width-2 route.
+          def orthogonal_stub_route?(style)
+            style.values_at(:mode, :lwidth, :tree) == %w[3 2 OS]
+          end
+
           def left_property_route?(style)
-            downward_property_route?(style) ||
+            downward_property_route?(style) || mode_two_route?(style) ||
               (style[:mode] == "3" && %w[0 2].include?(style[:lwidth]) &&
                 [nil, "H", "LV"].include?(style[:tree]))
           end
@@ -456,6 +504,15 @@ module Ea
             [x + SEAT_X_INSET + width, y + 15] if width
           end
 
+          # An absent source box on a leftward tree leg seats a Property role
+          # at the leftward Property seat, not the rightward tree default.
+          def tree_left_property_role(connector, end_kind, heading, anchor, box, role)
+            return nil unless leg_direction(end_kind, heading) == :left && box&.[]("alignment")&.zero?
+            return nil unless connector.style.to_h.values_at(:mode, :lwidth) == %w[3 2]
+
+            source_property_seat(connector, :left, anchor, box, role)
+          end
+
           # A tree-route source leaving left seats its multiplicity like any
           # other leftward source rather than at the rightward tree default.
           def tree_left_multiplicity(end_kind, heading, anchor, box, mult)