breadkit-render 0.1.0 → 0.2.0

data/lib/breadkit/render/svg_renderer.rb

@@ -7,8 +7,10 @@ module Breadkit
     class SvgRenderer
       PITCH = 10.0
       RAIL_PATTERNS = %w[+--+ +-+- -+-+ -++-].freeze
+      LABEL_DENSITIES = %w[full compact none].freeze
       OFFBOARD_PIN_PITCH = 1.0
       PALETTE = %w[#d62728 #1f77b4 #2ca02c #9467bd #ff7f0e #17becf].freeze
+      COLORBLIND_PALETTE = %w[#005b96 #a33d00 #006a4e #8a3c68 #176780 #704f9a].freeze
       MODULE_PIN_COLORS = {
         "power" => "#E24B4A", "ground" => "#888780", "clock" => "#EF9F27",
         "data" => "#378ADD", "interrupt" => "#D4537E", "address" => "#888780"
@@ -37,7 +39,7 @@ module Breadkit
                      switch_bg: "#ece7dd", switch_border: "#504c45", switch_button: "#c7c0b5", switch_button_border: "#6c655b",
                      text: "#25312b", label: "#627168", positive: "#cf5955", negative: "#71847e", negative_wire: "#315ea8", lead: "#68766f",
                      component_bg: "#e8eeea", component_border: "#aab7af", module_bg: "#f1efe8",
-                     module_border: "#888780", muted: "#92918b", accent: "#1D6B45" },
+                     module_border: "#888780", muted: "#66665f", accent: "#1D6B45" },
         "dark" => { board: "#202a27", border: "#52625b", groove: "#141c19", hole: "#718178", used_hole: "#d4e2d9",
                     connected_hole: "#9bab9e", resistor_bg: "#6b6248", resistor_border: "#c9ac73",
                     diode_bg: "#4b5550", diode_border: "#aab7af", diode_mark: "#dde6df",
@@ -45,7 +47,7 @@ module Breadkit
                     switch_bg: "#3d4540", switch_border: "#819188", switch_button: "#58665d", switch_button_border: "#a4b6a9",
                     text: "#e8efeb", label: "#c0cdc5", positive: "#ed7168", negative: "#99aaa4", negative_wire: "#76a9f2", lead: "#91a199",
                     component_bg: "#2d3935", component_border: "#607168", module_bg: "#343a3d",
-                    module_border: "#687176", muted: "#889095", accent: "#8fbea1" },
+                    module_border: "#687176", muted: "#b1bfc2", accent: "#8fbea1" },
         "print" => { board: "#ffffff", border: "#555555", groove: "#eeeeee", hole: "#aaaaaa", used_hole: "#333333",
                      connected_hole: "#777777", resistor_bg: "#dddddd", resistor_border: "#555555",
                      diode_bg: "#555555", diode_border: "#333333", diode_mark: "#ffffff",
@@ -53,21 +55,47 @@ module Breadkit
                      switch_bg: "#eeeeee", switch_border: "#444444", switch_button: "#cccccc", switch_button_border: "#444444",
                      text: "#222222", label: "#444444", positive: "#333333", negative: "#777777", negative_wire: "#555555", lead: "#333333",
                      component_bg: "#f4f4f4", component_border: "#555555", module_bg: "#f4f4f4",
-                     module_border: "#666666", muted: "#777777", accent: "#333333" }
-      }.freeze
+                     module_border: "#666666", muted: "#666666", accent: "#333333" }
+      }.tap do |palettes|
+        palettes["colorblind"] = palettes.fetch("light").merge(
+          board: "#f1f5f2", text: "#192923", label: "#43584a", positive: "#a33d00",
+          negative: "#53616a", negative_wire: "#005b96", accent: "#006a4e"
+        )
+      end.freeze
+
+      def render(circuit, crop: "auto", theme: "light", orientation: "portrait", show_nets: false, legend: false, color_by: "wire", annotations: [], rail_pattern: nil, interactive_layers: true, state: nil, active_layer: nil, focus: nil, highlight_net: nil, label_density: "full", diff_wires: {}, theme_colors: {}, font_css: nil, wire_routing: "declared", wire_style: "raised")
+        @multi_board = circuit.respond_to?(:multi_board?) && circuit.multi_board?
+        raise ArgumentError, "--rail-pattern is unavailable for multi-board circuits" if @multi_board && rail_pattern
+        raise ArgumentError, "unknown label density: #{label_density}" unless LABEL_DENSITIES.include?(label_density)
+        raise ArgumentError, "unknown wire routing: #{wire_routing}" unless %w[declared auto].include?(wire_routing)
+        raise ArgumentError, "unknown wire style: #{wire_style}" unless %w[raised flat].include?(wire_style)
 
-      def render(circuit, crop: "auto", theme: "light", orientation: "portrait", show_nets: false, legend: false, color_by: "wire", annotations: [], rail_pattern: nil, interactive_layers: true)
         @circuit, @theme, @orientation, @show_nets, @legend_enabled, @color_by, @annotations = circuit, theme.to_s, orientation.to_s, show_nets, legend, color_by, annotations
+        @label_density = label_density
+        @wire_routing, @wire_style = wire_routing, wire_style
+        @state, @active_layer = state, active_layer&.to_s
+        @diff_wires = diff_wires
+        @nets = circuit.nets(state)
+        @focus_ref = focus&.to_s
+        raise ArgumentError, "unknown component: #{@focus_ref}" if @focus_ref && !circuit.components.key?(@focus_ref)
+        selected_net = @nets.find { |net| net.name == highlight_net.to_s } if highlight_net
+        raise ArgumentError, "unknown net: #{highlight_net}" if highlight_net && !selected_net
+        @emphasis_active = !!(@focus_ref || selected_net)
+        emphasized_nets = @nets.select { |net| net.members.any? { |member| member.start_with?("#{@focus_ref}.") } } if @focus_ref
+        emphasized_nets = emphasized_nets&.select { |net| net == selected_net } if selected_net && @focus_ref
+        emphasized_nets ||= [selected_net].compact
+        @emphasized_wire_ids = emphasized_nets.flat_map(&:members).to_set
+        @emphasized_component_refs = emphasized_nets.flat_map { |net| net.members.filter_map { |member| member.split(".", 2).first if member.include?(".") } }.to_set
         @wire_indexes = circuit.wires.each_with_index.to_h
         @wires_by_id = circuit.wires.to_h { |wire| [wire.id, wire] }
         @rail_definitions = Array(circuit.board.definition.data["rails"]).to_h { |rail| [rail["id"].to_s, rail] }
         @wire_endpoint_refs = circuit.wires.each_with_object({}) { |wire, refs| refs[wire.from] = refs[wire.to] = true }
         @nets_by_member, @nets_by_hole = {}, {}
-        circuit.nets.each do |net|
+        @nets.each do |net|
           net.members.each { |member| @nets_by_member[member] = net }
           net.holes.each { |hole| @nets_by_hole[hole] = net }
         end
-        @net_indexes = circuit.nets.each_with_index.to_h
+        @net_indexes = @nets.each_with_index.to_h
         @board_edge_wires = circuit.wires.select do |wire|
           wire.route == "edge" && !offboard_component(wire.from) && !offboard_component(wire.to)
         end
@@ -81,23 +109,36 @@ module Breadkit
         @offboard_rail_tracks = nil
         @offboard_layouts = {}
         @edge_breakout_offsets = @annotation_states = nil
+        @invalid_colors_warned = Set.new
         raise ArgumentError, "orientation must be portrait or landscape" unless %w[portrait landscape].include?(@orientation)
+        available_layers = circuit.wires.flat_map { |wire| layer_names(wire.layer) } +
+          circuit.components.values.flat_map { |component| layer_names(read(component.attrs, "layer")) }
+        raise ArgumentError, "unknown layer: #{@active_layer}" if @active_layer && !available_layers.include?(@active_layer)
         @layers = if interactive_layers
-          (circuit.wires.flat_map { |wire| layer_names(wire.layer) } +
-            circuit.components.values.flat_map { |component| layer_names(read(component.attrs, "layer")) }).uniq
+          available_layers.uniq
         else
           []
         end
+        @visible_wires = circuit.wires.select { |wire| visible_in_layer?(wire.layer) }
+        @visible_wire_ids = @visible_wires.map(&:id).to_set
+        @visible_components = circuit.components.values.select { |component| visible_in_layer?(read(component.attrs, "layer")) }
+        @auto_routes = {}
         @layer_controls_height = 0
         @rail_pattern = rail_pattern&.to_s
         configure_rail_pattern
+        @auto_router = OrthogonalRouter.new(auto_obstacles) if @wire_routing == "auto"
 
-        @colors = COLORS.fetch(@theme, COLORS.fetch("light"))
-        @conductive_holes = @nets_by_hole.keys.to_set
-        @used_holes = (circuit.components.values.flat_map { |component| component.pins.values.map(&:hole_id) } +
-                       circuit.wires.flat_map { |wire| [wire.from, wire.to].filter_map { |endpoint| circuit.board.hole(endpoint)&.id } } +
+        @colors = COLORS.fetch(@theme, COLORS.fetch("light")).merge(theme_colors)
+        @font_css = font_css
+        @used_holes = (@visible_components.flat_map { |component| component.pins.values.map(&:hole_id) } +
+                       @visible_wires.flat_map { |wire| [wire.from, wire.to].filter_map { |endpoint| circuit.board.hole(endpoint)&.id } } +
                        circuit.supplies.flat_map { |supply| [supply.plus, supply.minus] }).compact.to_set
-        @view_box = view_box(crop)
+        @conductive_holes = if @active_layer
+          @nets.select { |net| visible_net?(net) }.flat_map(&:holes).to_set
+        else
+          @nets_by_hole.keys.to_set
+        end
+        @view_box = view_box(@multi_board ? "none" : crop)
         @layer_controls_height = layer_controls_height unless @layers.empty?
         left, top, width, height = @view_box
         extra_height = legend_height
@@ -109,9 +150,10 @@ module Breadkit
            "#{fmt(left)} #{fmt(top)} #{fmt(width)} #{fmt(height + @layer_controls_height + extra_height)}"]
         end
         svg = ["<?xml version=\"1.0\" encoding=\"UTF-8\"?>",
-               "<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"#{fmt(output_width)}\" height=\"#{fmt(output_height)}\" viewBox=\"#{output_view_box}\" font-family=\"Helvetica, Arial, 'Noto Sans JP', sans-serif\" fill=\"#{@colors[:text]}\" role=\"img\"#{@rail_pattern ? " data-rail-pattern=\"#{@rail_pattern}\"" : ""}>",
+               "<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"#{fmt(output_width)}\" height=\"#{fmt(output_height)}\" viewBox=\"#{output_view_box}\" font-family=\"#{@font_css ? 'BreadkitEmbedded, ' : ''}Helvetica, Arial, 'Noto Sans JP', sans-serif\" fill=\"#{@colors[:text]}\" role=\"img\"#{@rail_pattern ? " data-rail-pattern=\"#{@rail_pattern}\"" : ""}#{@state ? " data-state=\"#{escape(@state.name)}\"" : ""}>",
                "<title>#{escape(circuit.title || "Breadkit circuit")}</title>",
-               "<desc>Breadboard wiring diagram generated by Breadkit.</desc>"]
+               "<desc>#{escape((["Breadboard wiring diagram generated by Breadkit.", (@active_layer ? "Showing layer #{@active_layer}; netlist includes all layers." : nil)] + @nets.map { |net| "#{net.name}: #{net.members.join(', ')}" }).compact.join(' '))}</desc>"]
+        svg << "<style>#{@font_css}</style>" if @font_css
         transform = if @orientation == "portrait"
           "matrix(0 1 -1 0 #{fmt(top + height)} #{fmt(-left + @layer_controls_height)})"
         elsif @layer_controls_height.positive?
@@ -124,6 +166,8 @@ module Breadkit
         svg << "<g id=\"components\">#{components_svg}</g>"
         svg << "<g id=\"offboard\">#{offboard_svg}</g>"
         svg << "<g id=\"wires\">#{wires_svg}</g>"
+        labels = component_labels_overlay_svg
+        svg << "<g id=\"component-labels\">#{labels}</g>" unless labels.empty?
         svg << "<g id=\"labels\">#{labels_svg}</g>"
         svg << "<g id=\"nets\">#{nets_svg}</g><g id=\"annotations\">#{annotations_svg}</g>"
         svg << "</g>" if transform
@@ -168,6 +212,8 @@ module Breadkit
       end
 
       def rail_polarity(id)
+        return @circuit.board.rail_polarity(id) if @multi_board
+
         rail_definition(id)["polarity"]&.to_s || (id.end_with?("+", "-") ? id[-1] : nil)
       end
 
@@ -193,6 +239,8 @@ module Breadkit
       end
 
       def board_svg
+        return named_boards_svg if @multi_board
+
         x, y, width, height = board_bounds
         out = [rect(x, y, width, height, rx: 8, fill: @colors[:board], stroke: @colors[:border], stroke_width: 1)]
         ravine = Array(@circuit.board.definition.data.dig("terminal", "ravine_between"))
@@ -207,35 +255,82 @@ module Breadkit
           next unless id.start_with?("rail:")
           holes = ids.map { |hole_id| @circuit.board.hole(hole_id) }
           next if holes.empty?
-          rail_id = holes.first.rail
-          rail_color = { "+" => @colors[:positive], "-" => @colors[:negative] }.fetch(rail_polarity(rail_id), @colors[:label])
-          positions = holes.map { |hole| display_hole(hole) }
-          first, last = positions.map { |hole| px(hole.x) }.minmax
-          out << rect(first - 3, py(positions.first.y) - 3, last - first + 6, 6,
-                      rx: 3, fill: rail_color, opacity: 0.14, data_rail: rail_id)
+          out << rail_strip_svg(holes)
+        end
+        out.join
+      end
+
+      def named_boards_svg
+        board = @circuit.board
+        out = board.boards.map do |name, definition|
+          holes = board.holes.values.select { |hole| hole.id.start_with?("#{name}.") }
+          xs, ys = holes.map { |hole| px(hole.x) }, holes.map { |hole| py(hole.y) }
+          x, y = xs.min - PITCH * 1.5, ys.min - PITCH * 1.5
+          width, height = xs.max - xs.min + PITCH * 3, ys.max - ys.min + PITCH * 3
+          plate = [rect(x, y, width, height, rx: 8, fill: @colors[:board], stroke: @colors[:border], stroke_width: 1)]
+          ravine = Array(definition.definition.data.dig("terminal", "ravine_between"))
+          rows = ravine.map { |row| holes.find { |hole| hole.row == row.to_s } }
+          if rows.length == 2 && rows.all?
+            groove_y = rows.sum { |hole| py(hole.y) } / rows.length
+            plate << rect(x + PITCH / 2, groove_y - PITCH, width - PITCH, PITCH * 2,
+                          rx: 2, fill: @colors[:groove])
+          end
+          plate << text(x + width - 17, y + 9, name, "font-size" => 8, "font-weight" => 700,
+                        "fill" => @colors[:text], "text-anchor" => "middle")
+          "<g data-board=\"#{escape(name)}\">#{plate.join}</g>"
+        end
+        board.strips.each do |id, ids|
+          next unless id.include?("rail:")
+
+          holes = ids.map { |hole_id| board.hole(hole_id) }
+          next if holes.empty?
+          out << rail_strip_svg(holes)
         end
         out.join
       end
 
+      def rail_strip_svg(holes)
+        rail_id = holes.first.rail
+        color = { "+" => @colors[:positive], "-" => @colors[:negative] }.fetch(rail_polarity(rail_id), @colors[:label])
+        positions = holes.map { |hole| display_hole(hole) }
+        left, right = positions.map { |hole| px(hole.x) }.minmax
+        top, bottom = positions.map { |hole| py(hole.y) }.minmax
+        if bottom - top > right - left
+          rect((left + right) / 2 - 3, top - 3, 6, bottom - top + 6,
+               rx: 3, fill: color, opacity: 0.14, data_rail: rail_id)
+        else
+          rect(left - 3, (top + bottom) / 2 - 3, right - left + 6, 6,
+               rx: 3, fill: color, opacity: 0.14, data_rail: rail_id)
+        end
+      end
+
       def holes_svg
-        @circuit.board.holes.values.map do |hole|
+        output = ["<defs><circle id=\"h\" r=\"1.3\"/><circle id=\"u\" r=\"1.8\"/></defs>",
+                  "<style>#holes use{fill:#{@colors[:hole]};opacity:.75}#holes use.c{fill:#{@colors[:connected_hole]}}#holes use.o{fill:#{@colors[:used_hole]};opacity:1}</style>"]
+        output.concat(@circuit.board.holes.values.map do |hole|
           used = @used_holes.include?(hole.id)
           connected = @conductive_holes.include?(hole.id)
           display = display_hole(hole)
-          attrs = { fill: used ? @colors[:used_hole] : (connected ? @colors[:connected_hole] : @colors[:hole]),
-                    data_hole: hole.id, opacity: used ? 1 : 0.75 }
-          attrs[:data_occupied] = true if used
-          attrs[:data_connected] = true if connected
-          circle(px(display.x), py(display.y), used ? 1.8 : 1.3, **attrs)
-        end.join
+          dot = used ? "u" : "h"
+          class_name = used ? " class=\"o\" data-occupied=\"true\"" : (connected ? " class=\"c\"" : "")
+          class_name += " data-connected=\"true\"" if connected
+          attrs = "href=\"##{dot}\" x=\"#{coord(px(display.x))}\" y=\"#{coord(py(display.y))}\" data-hole=\"#{escape(hole.id)}\"#{class_name}"
+          attrs += " data-net=\"#{escape(@nets_by_hole[hole.id].name)}\"" if @nets_by_hole[hole.id]
+          title = [hole.id, @nets_by_hole[hole.id]&.name].compact.join(" / ")
+          "<use #{attrs}><title>#{escape(title)}</title></use>"
+        end)
+        output.join
       end
 
       def labels_svg
+        return named_board_labels_svg if @multi_board
+
         out = []
         number_y = @orientation == "portrait" ? py(-1) : py(@circuit.board.height)
         @circuit.board.definition.data.dig("terminal", "rows").each do |row|
           y = @circuit.board.holes.values.find { |hole| hole.row == row }&.y
-          out << text(-7, py(y), row, "font-size" => 8, "font-weight" => 500, "fill" => @colors[:label], "text-anchor" => "middle") if y
+          row_x = @orientation == "landscape" ? board_bounds.then { |left, _top, width, _height| left + width - 6 } : -7
+          out << text(row_x, py(y), row, "font-size" => 8, "font-weight" => 500, "fill" => @colors[:label], "text-anchor" => "middle") if y
         end
         (1..@circuit.board.width).each do |col|
           next unless col == 1 || (col % 5).zero?
@@ -250,6 +345,30 @@ module Breadkit
         out.join
       end
 
+      def named_board_labels_svg
+        out = []
+        @circuit.board.boards.each do |name, definition|
+          holes = @circuit.board.holes.values.select { |hole| hole.id.start_with?("#{name}.") }
+          terminal_holes = holes.select { |hole| hole.kind == :terminal }
+          left_x = terminal_holes.map(&:x).min
+          Array(definition.definition.data.dig("terminal", "rows")).each do |row|
+            hole = terminal_holes.find { |item| item.row == row.to_s }
+            out << text(px(left_x) - 7, py(hole.y), row, "font-size" => 8, "font-weight" => 500,
+                        "fill" => @colors[:label], "text-anchor" => "middle") if hole
+          end
+          number_y = @orientation == "portrait" ? py(-1) : py(definition.height)
+          (1..definition.width).each do |col|
+            next unless col == 1 || (col % 5).zero?
+
+            number_x = px(left_x + col - 1) + (@orientation == "portrait" ? 5 : 0)
+            out << text(number_x + (@orientation == "portrait" ? 3 : 0), number_y, col,
+                        "font-size" => @orientation == "portrait" ? 6 : 7, "font-weight" => 500,
+                        "fill" => @colors[:text], "text-anchor" => "middle")
+          end
+        end
+        out.join
+      end
+
       def components_svg
         @circuit.components.values.map do |component|
           pins = component.pins.values.filter_map { |pin| [pin, @circuit.board.hole(pin.hole_id)] if pin.hole_id }
@@ -257,7 +376,20 @@ module Breadkit
           xs, ys = pins.map { |_pin, hole| px(display_hole(hole).x) }, pins.map { |_pin, hole| py(display_hole(hole).y) }
           center_x, center_y = (xs.min + xs.max) / 2.0, (ys.min + ys.max) / 2.0
           shape = component.part.data.dig("render", "shape")
-          body = case shape
+          shape = "to92" if shape == "generic" && %w[transistor 2n3904 2n3906 bc547 bc557].include?(component.part.id)
+          shape = "potentiometer" if shape == "generic" && component.part.id == "pot"
+          template = component.part.data.dig("render", "svg")
+          body = if rail_module?(component)
+            rail_module_svg(component, pins)
+          elsif template
+            values = { "ref" => component.ref, "value" => component.value,
+                       "fill" => component.part.data.dig("render", "fill") || @colors[:component_bg],
+                       "stroke" => component.part.data.dig("render", "stroke") || @colors[:component_border],
+                       "text_color" => component.part.data.dig("render", "text_color") || @colors[:text] }
+            lead_lines(pins, center_x, center_y) +
+              %(<g data-part-template="#{escape(component.part.id)}" transform="translate(#{fmt(center_x)} #{fmt(center_y)})">#{SvgTemplate.new(template).render(values)}</g>)
+          else
+            case shape
           when "resistor" then resistor_svg(component, pins, center_x, center_y)
           when "led_5mm" then led_svg(component, pins, center_x, center_y)
           when "diode" then diode_svg(component, pins, center_x, center_y)
@@ -265,9 +397,16 @@ module Breadkit
           when "dip" then dip_svg(component, pins)
           when "module" then module_svg(component, pins)
           when "tact_switch" then switch_svg(component, pins, center_x, center_y)
+          when "seven_segment" then seven_segment_svg(component, pins, center_x, center_y)
+          when "rgb_led_5mm" then rgb_led_svg(component, pins, center_x, center_y)
+          when "to92" then to92_svg(component, pins, center_x, center_y)
+          when "potentiometer" then potentiometer_svg(component, pins, center_x, center_y)
           else generic_svg(component, pins, center_x, center_y)
+            end
           end
-          body = "<g data-ref=\"#{escape(component.ref)}\">#{body}</g>"
+          opacity = @emphasis_active && !emphasized_component?(component.ref) ? " opacity=\"0.18\"" : ""
+          switch = Array(component.part.data["switch"]).empty? ? "" : " data-switch=\"#{escape(component.ref)}\""
+          body = "<g data-ref=\"#{escape(component.ref)}\"#{switch}#{opacity}>#{body}</g>"
           layer_group(body, read(component.attrs, "layer"))
         end.compact.join
       end
@@ -277,27 +416,95 @@ module Breadkit
         out << rect(x - 12, y - 4, 24, 8, rx: 3, fill: @colors[:resistor_bg], stroke: @colors[:resistor_border], data_ref: component.ref)
         bands = resistor_bands(component.value, bands: component.attrs[:bands] || 4)
         bands.each_with_index { |color, index| out << rect(x - (bands.length == 5 ? 9 : 7) + index * 4, y - 4, 1.7, 8, fill: color) }
-        out << text(x, y - 7, "#{component.ref} #{component.value}", "font-size" => 5, "font-weight" => 500, "text-anchor" => "middle")
         out.join
       end
 
+      def component_labels_overlay_svg
+        return "" if @label_density == "none"
+
+        @label_wire_bounds = @visible_wires.filter_map do |wire|
+          from, to = endpoint_point(wire.from), endpoint_point(wire.to)
+          next unless from && to
+
+          wire_route_points(wire, from, to).each_cons(2).map do |first, last|
+            [*([px(first[0]), px(last[0])].minmax), *([py(first[1]), py(last[1])].minmax)]
+          end
+        end
+        @visible_components.filter_map do |component|
+          holes = component.pins.values.filter_map { |pin| @circuit.board.hole(pin.hole_id) }
+          next if holes.empty?
+
+          xs, ys = holes.map { |hole| px(display_hole(hole).x) }, holes.map { |hole| py(display_hole(hole).y) }
+          x, y = xs.minmax.sum / 2.0, ys.minmax.sum / 2.0
+          shape = component.part.data.dig("render", "shape")
+          label, baseline, font_size, background, foreground = case shape
+          when "resistor" then [value_label(component, shape), y - 7, 5, @colors[:board], @colors[:text]]
+          when "led_5mm" then [component.ref, y - 8, 5, @colors[:board], @colors[:text]]
+          when "diode" then [component.ref, y - 5, 4.5, @colors[:board], @colors[:text]]
+          when "capacitor", "electrolytic" then [value_label(component, shape), y - 6, 4.5, @colors[:board], @colors[:text]]
+          when "dip" then [component.part.data.dig("render", "label") || component.ref, y + 1.5, 4.5, @colors[:dip_bg], @colors[:dip_text]]
+          else next
+          end
+          width = [label.to_s.length * font_size * 0.62 + 6, 13].max
+          baseline = clear_label_baseline(x, baseline, width, font_size)
+          background_options = { rx: 2, fill: background }
+          background_options[:transform] = "rotate(-90 #{fmt(x)} #{fmt(baseline)})" if @rotated_scene
+          opacity = @emphasis_active && !emphasized_component?(component.ref) ? " opacity=\"0.18\"" : ""
+          body = rect(x - width / 2, baseline - font_size - 2, width, font_size + 4, **background_options)
+          body += text(x, baseline, label, "font-size" => font_size, "font-weight" => 500,
+                       "fill" => foreground, "text-anchor" => "middle", "paint-order" => "stroke",
+                       "stroke" => background, "stroke-width" => 1.5, "stroke-linejoin" => "round")
+          layer_group("<g data-ref=\"#{escape(component.ref)}\"#{opacity}>#{body}</g>", read(component.attrs, "layer"))
+        end.join
+      end
+
+      def value_label(component, shape)
+        return component.ref if @label_density == "compact" || !component.value
+
+        "#{component.ref} #{Breadkit::Value.new(component.value, category: shape)}"
+      end
+
+      def clear_label_baseline(x, baseline, width, font_size)
+        near = width / 2 + 5
+        far = width / 2 + 12
+        [baseline, baseline - near, baseline + near, baseline - far, baseline + far].min_by do |candidate|
+          bounds = label_bounds(x, candidate, width, font_size)
+          view_left, view_top, view_width, view_height = @view_box
+          clipped = bounds[0] < view_left || bounds[1] < view_top ||
+                    bounds[2] > view_left + view_width || bounds[3] > view_top + view_height
+          [clipped ? 1 : 0, label_wire_overlaps(bounds), (candidate - baseline).abs]
+        end
+      end
+
+      def label_bounds(x, baseline, width, font_size)
+        return [x - font_size - 2, baseline - width / 2, x + 2, baseline + width / 2] if @rotated_scene
+
+        [x - width / 2, baseline - font_size - 2, x + width / 2, baseline + 2]
+      end
+
+      def label_wire_overlaps(bounds)
+        left, top, right, bottom = bounds
+        @label_wire_bounds.count do |segments|
+          segments.any? do |x1, x2, y1, y2|
+            x1 <= right + 1 && x2 >= left - 1 && y1 <= bottom + 1 && y2 >= top - 1
+          end
+        end
+      end
+
       def led_svg(component, pins, x, y)
         out = [lead_lines(pins, x, y)]
         color = component.attrs[:color].to_s.downcase
         color = "red" if color.empty?
-        valid_color = CSS_COLOR_NAMES.include?(color) || /\A#(?:[0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})\z/.match?(color)
-        raise Error, "invalid LED color: #{color}" unless valid_color
+        color = render_color(color, "LED #{component.ref}") { "red" }
         color = { "red" => "#df5550", "green" => "#5fbf69", "blue" => "#6a9df0", "yellow" => "#f0d958" }.fetch(color, color)
         out << circle(x, y, 5.5, fill: color, stroke: @colors[:component_border], data_ref: component.ref)
         out << polarity_marker(component, pins, x, y, 5.0, @colors[:component_border])
-        out << text(x, y - 8, component.ref, "font-size" => 5, "font-weight" => 500, "text-anchor" => "middle")
         out.join
       end
 
       def diode_svg(component, pins, x, y)
         [lead_lines(pins, x, y), rect(x - 7, y - 3, 14, 6, rx: 1, fill: @colors[:diode_bg], stroke: @colors[:diode_border], data_ref: component.ref),
-         polarity_marker(component, pins, x, y, 3.0, @colors[:diode_mark]),
-         text(x, y - 5, component.ref, "font-size" => 4.5, "font-weight" => 500, "text-anchor" => "middle")].join
+         polarity_marker(component, pins, x, y, 3.0, @colors[:diode_mark])].join
       end
 
       def capacitor_svg(component, pins, x, y, electrolytic:)
@@ -310,7 +517,6 @@ module Breadkit
           offset_y = offset_x.zero? ? (positive && positive[1] > y ? 5 : -5) : 0
           out << text(x + offset_x, y + offset_y + 1.5, "+", "font-size" => 4, "text-anchor" => "middle")
         end
-        out << text(x, y - 6, component.ref, "font-size" => 4.5, "font-weight" => 500, "text-anchor" => "middle")
         out.join
       end
 
@@ -322,11 +528,11 @@ module Breadkit
         notch_x = first_pin && px(first_pin.x) > xs.sum / xs.length ? x2 - 2 : x1 + 2
         out << tag("path", d: "M #{fmt(notch_x)} #{fmt(middle - 2)} Q #{fmt(notch_x + (notch_x == x1 + 2 ? 2 : -2))} #{fmt(middle)} #{fmt(notch_x)} #{fmt(middle + 2)}",
                     fill: "none", stroke: @colors[:dip_notch], stroke_width: 0.8)
-        out << text((x1 + x2) / 2, middle + 1.5, component.part.data.dig("render", "label") || component.ref,
-                    "font-size" => 4.5, "fill" => @colors[:dip_text], "text-anchor" => "middle")
         pins.each do |pin, hole|
           display = display_hole(hole)
-          out << text(px(display.x), py(display.y) + (display.y > 4 ? 4 : -2), pin.number, "font-size" => 3.5, "text-anchor" => "middle")
+          number = text(px(display.x), py(display.y) + (display.y > 4 ? 4 : -2), pin.number,
+                        "font-size" => 3.5, "text-anchor" => "middle")
+          out << %(<g data-dip-pin="#{escape(component.ref)}.#{escape(pin.name)}"><title>Pin #{escape(pin.number)}: #{escape(pin.name)}</title>#{number}</g>)
         end
         out.join
       end
@@ -340,6 +546,9 @@ module Breadkit
                     stroke: render["stroke"] || @colors[:module_border], stroke_width: 1,
                     data_ref: component.ref)]
         pin_definitions = component.part.data["pins"].to_h { |definition| [definition["num"].to_s, definition] }
+        pad_points = pins.map { |_pin, hole| display_hole(hole).then { |display| [px(display.x), py(display.y)] } }
+        rotated_footprint = [90, 270].include?(component.attrs[:rotate])
+        portrait_labels, landscape_labels = [], []
         pins.each do |pin, hole|
           display = display_hole(hole)
           pin_x, pin_y = px(display.x), py(display.y)
@@ -352,11 +561,42 @@ module Breadkit
           label = definition && definition["label"]
           next unless label
           label = pin.name if label == true
-          label_gap = @orientation == "portrait" ? 10 : 3.8
-          label_y = pin_y + (center_y > pin_y ? label_gap : -label_gap)
-          label_anchor = @orientation == "portrait" ? (center_y > pin_y ? "end" : "start") : "middle"
-          out << text(pin_x, label_y, label, "font-size" => 5.8, "font-weight" => 500,
-                      "fill" => render["text_color"] || @colors[:text], "text-anchor" => label_anchor)
+          length = label.to_s.length * 5.8 * 0.6
+          label_transform = nil
+          if @orientation == "landscape" && width > height * 1.5 && pins.length >= 8
+            inward = center_y > pin_y
+            label_x, label_y = pin_x, pin_y + (inward ? 6 : -6)
+            label_anchor = inward ? "start" : "end"
+            label_transform = "rotate(90 #{fmt(label_x)} #{fmt(label_y)})"
+          elsif @orientation == "landscape" && rotated_footprint
+            label_x = pin_x
+            label_y = [pin_y - 9, pin_y + 9, pin_y - 18, pin_y + 18].find do |candidate|
+              candidate.between?(y + 4, y + height - 4) &&
+                landscape_labels.none? { |other_x, other_y, other_length| (label_x - other_x).abs < (length + other_length) / 2 &&
+                  (candidate - other_y).abs < 5.8 } &&
+                pad_points.none? { |pad_x, pad_y| (label_x - pad_x).abs < length / 2 + 3.3 && (candidate - pad_y).abs < 6.2 }
+            end || pin_y
+            landscape_labels << [label_x, label_y, length]
+            label_anchor = "middle"
+          elsif @orientation == "portrait" && rotated_footprint
+            label_y = pin_y - length / 2 - 9
+            label_x = [pin_x, pin_x - 9, pin_x + 9, pin_x - 18, pin_x + 18].find do |candidate|
+              candidate.between?(x + 3, x + width - 3) &&
+                portrait_labels.none? { |other_x, other_y, other_length| (candidate - other_x).abs < 5.8 &&
+                  (label_y - other_y).abs < (length + other_length) / 2 } &&
+                pad_points.none? { |pad_x, pad_y| (candidate - pad_x).abs < 6.2 && (label_y - pad_y).abs < length / 2 + 3.3 }
+            end || pin_x
+            portrait_labels << [label_x, label_y, length]
+            label_anchor = "middle"
+          else
+            label_gap = @orientation == "portrait" ? 10 : 3.8
+            label_x, label_y = pin_x, pin_y + (center_y > pin_y ? label_gap : -label_gap)
+            label_anchor = @orientation == "portrait" ? (center_y > pin_y ? "end" : "start") : "middle"
+          end
+          attrs = { "font-size" => 5.8, "font-weight" => 500, "fill" => render["text_color"] || @colors[:text],
+                    "text-anchor" => label_anchor }
+          attrs["transform"] = label_transform if label_transform
+          out << text(label_x, label_y, label, attrs)
         end
         label = render["label"] || component.ref
         font_size = [[ [width, height].min / 6, 6].max, 10].min
@@ -377,6 +617,8 @@ module Breadkit
       end
 
       def module_bounds(component, pins)
+        return component.body_bounds(@circuit.board) if component.respond_to?(:body_bounds)
+
         xs, ys = pins.map { |_pin, hole| hole.x }, pins.map { |_pin, hole| hole.y }
         render = component.part.data.fetch("render")
         width_mm, height_mm = render.fetch("size_mm").map { |value| Float(value) }
@@ -388,10 +630,64 @@ module Breadkit
         [center_x - width / 2, center_y - height / 2, width, height]
       end
 
+      def rail_module?(component)
+        definitions = component.part.data["pins"] || []
+        !definitions.empty? && definitions.all? { |pin| pin["mount"] == "rail" }
+      end
+
+      def rail_module_bounds(pins)
+        xs = pins.map { |_pin, hole| hole.x }
+        ys = pins.map { |_pin, hole| hole.y }
+        board_left, board_right = @board_extents.fetch(:x)
+        width, height = 19.0, 11.0
+        x = xs.sum / xs.length.to_f <= (board_left + board_right) / 2.0 ? board_left - 21.5 : board_right + 2.5
+        [x, (ys.min + ys.max) / 2.0 - height / 2, width, height]
+      end
+
+      def rail_pin_label(pin, index)
+        { "LEFT_POS" => "L+", "LEFT_GND" => "L−", "RIGHT_POS" => "R+", "RIGHT_GND" => "R−" }.fetch(pin.name) { ("A".ord + index).chr }
+      end
+
+      def rail_module_svg(component, pins)
+        x, y, width, height = rail_module_bounds(pins)
+        title = component.part.data.dig("render", "label") || component.part.id
+        out = ["<title>#{escape(title)} · logical pin map; verify physical fit</title>",
+               rect(px(x), py(y + height), px(width), px(height), rx: 3,
+                    fill: @colors[:module_bg], stroke: @colors[:module_border], stroke_width: 1,
+                    data_ref: component.ref)]
+        out << text(px(x + 0.8), py(y + height - 1.4), component.ref, "font-size" => 13,
+                    "font-weight" => 700, "fill" => @colors[:text])
+        out << text(px(x + 0.8), py(y + height - 2.5), "Logical pins · verify fit", "font-size" => 10,
+                    "fill" => @colors[:label])
+        master = read(component.attrs, "master")
+        left = read(component.attrs, "left")
+        right = read(component.attrs, "right")
+        if master || left || right
+          mode = ->(value) { { "v3_3" => "3.3 V", "v5" => "5 V", "off" => "OFF" }.fetch(value.to_s, value.to_s) }
+          out << text(px(x + 0.8), py(y + height - 3.5), "Master #{master.to_s.upcase} · Left #{mode.call(left)}", "font-size" => 9.2,
+                      "fill" => @colors[:text])
+          out << text(px(x + 0.8), py(y + height - 4.4), "Right #{mode.call(right)}", "font-size" => 9.2,
+                      "fill" => @colors[:text])
+        end
+        pins.each_with_index do |(pin, hole), index|
+          display = display_hole(hole)
+          color = MODULE_PIN_COLORS.fetch(pin.role.to_s, @colors[:lead])
+          short = rail_pin_label(pin, index)
+          out << circle(px(display.x), py(display.y), 6, fill: color, stroke: @colors[:module_border],
+                        stroke_width: 0.8, data_pin: "#{component.ref}.#{pin.name}")
+          out << text(px(display.x), py(display.y) + 2.2, short, "font-size" => 6.5,
+                      "font-weight" => 700, "fill" => "#ffffff", "text-anchor" => "middle")
+          out << text(px(x + 0.8), py(y + height - 6.0 - index),
+                      "#{short}  #{pin.name}  #{hole.id}", "font-size" => 10, "fill" => @colors[:text])
+        end
+        %(<g data-rail-module="logical">#{out.join}</g>)
+      end
+
       def switch_svg(component, pins, x, y)
         out = [lead_lines(pins, x, y)]
         out << rect(x - 12, y - 10, 24, 20, rx: 2, fill: @colors[:switch_bg], stroke: @colors[:switch_border], data_ref: component.ref)
-        out << circle(x, y, 5, fill: @colors[:switch_button], stroke: @colors[:switch_button_border])
+        closed = @state&.closed_switches&.any? { |item, _pair| item.equal?(component) }
+        out << circle(x, y, 5, fill: closed ? @colors[:accent] : @colors[:switch_button], stroke: @colors[:switch_button_border])
         out << text(x, y - 13, component.ref, "font-size" => 5, "font-weight" => 500, "text-anchor" => "middle")
         out.join
       end
@@ -403,6 +699,53 @@ module Breadkit
         out.join
       end
 
+      def to92_svg(component, pins, x, y)
+        out = [lead_lines(pins, x, y)]
+        path = "M #{fmt(x - 8)} #{fmt(y - 4)} H #{fmt(x + 8)} V #{fmt(y)} A 8 8 0 0 1 #{fmt(x - 8)} #{fmt(y)} Z"
+        out << tag("path", d: path, fill: @colors[:dip_bg], stroke: @colors[:dip_border], stroke_width: 1,
+                            data_shape: "to92")
+        out << text(x, y + 1.5, component.ref, "font-size" => 4.5, "fill" => @colors[:dip_text], "text-anchor" => "middle")
+        out.join
+      end
+
+      def potentiometer_svg(component, pins, x, y)
+        out = [lead_lines(pins, x, y)]
+        out << rect(x - 12, y - 8, 24, 16, rx: 2, fill: @colors[:component_bg], stroke: @colors[:component_border])
+        out << circle(x, y, 6, fill: @colors[:switch_button], stroke: @colors[:switch_button_border],
+                                data_shape: "potentiometer")
+        out << line(x - 3, y + 3, x + 3, y - 3, @colors[:switch_button_border], 1.2)
+        out << text(x, y - 11, component.ref, "font-size" => 4.5, "text-anchor" => "middle")
+        out.join
+      end
+
+      def seven_segment_svg(component, pins, x, y)
+        out = [lead_lines(pins, x, y)]
+        out << rect(x - 13, y - 23, 26, 46, rx: 2, fill: @colors[:component_bg],
+                    stroke: @colors[:component_border], data_ref: component.ref)
+        out << rect(x - 9, y - 19, 18, 38, rx: 1, fill: "#201c20")
+        segments = {
+          "A" => [x - 6, y - 16, 12, 2], "G" => [x - 6, y - 1, 12, 2], "D" => [x - 6, y + 14, 12, 2],
+          "F" => [x - 8, y - 14, 2, 12], "B" => [x + 6, y - 14, 2, 12],
+          "E" => [x - 8, y + 2, 2, 12], "C" => [x + 6, y + 2, 2, 12]
+        }
+        segments.each do |name, (left, top, width, height)|
+          out << rect(left, top, width, height, rx: 0.5, fill: "#d96960", opacity: 0.45, data_segment: name)
+        end
+        out << circle(x + 6, y + 16, 1, fill: "#d96960", opacity: 0.45, data_segment: "DP")
+        out << text(x, y - 26, component.ref, "font-size" => 5, "text-anchor" => "middle")
+        out.join
+      end
+
+      def rgb_led_svg(component, pins, x, y)
+        out = [lead_lines(pins, x, y)]
+        out << circle(x, y, 7, fill: @colors[:component_bg], stroke: @colors[:component_border], data_ref: component.ref)
+        { "R" => [-3.3, "#e35d59"], "G" => [0, "#66c786"], "B" => [3.3, "#6a9df0"] }.each do |channel, (offset, color)|
+          out << circle(x + offset, y, 2.4, fill: color, opacity: 0.75, data_channel: channel)
+        end
+        out << text(x, y - 10, component.ref, "font-size" => 5, "text-anchor" => "middle")
+        out.join
+      end
+
       def offboard_svg
         @circuit.components.values.filter_map do |component|
           next unless component.part.placement == "offboard"
@@ -428,7 +771,8 @@ module Breadkit
             pin_x, pin_y = offboard_pin_point(component, index)
             pin_color = MODULE_PIN_COLORS.fetch(pin.role.to_s, @colors[:lead])
             out << circle(px(pin_x), py(pin_y), 1.7, fill: pin_color, stroke: @colors[:module_bg],
-                          stroke_width: 0.6, data_pin: "#{component.ref}.#{pin.name}", data_pin_type: pin.role)
+                          stroke_width: 0.6, data_pin: "#{component.ref}.#{pin.name}", data_pin_type: pin.role,
+                          data_net: @nets_by_member["#{component.ref}.#{pin.name}"]&.name)
             references = ["#{component.ref}.#{pin.name}", "#{component.ref}.#{pin.number}"]
             connected = references.any? { |reference| @wire_endpoint_refs.key?(reference) }
             label_side = component.attrs[:side].to_s == "left"
@@ -446,7 +790,8 @@ module Breadkit
             out << text(label_x, label_y, pin.name, "font-size" => 5.4, "fill" => connected ? @colors[:text] : @colors[:muted],
                         "text-anchor" => anchor, data_pin_label: "#{component.ref}.#{pin.name}")
           end
-          layer_group(out.join, read(component.attrs, "layer"))
+          opacity = @emphasis_active && !emphasized_component?(component.ref) ? " opacity=\"0.18\"" : ""
+          layer_group("<g data-ref=\"#{escape(component.ref)}\"#{opacity}>#{out.join}</g>", read(component.attrs, "layer"))
         end.join
       end
 
@@ -481,15 +826,10 @@ module Breadkit
         @circuit.wires.each do |wire|
           from, to = endpoint_point(wire.from), endpoint_point(wire.to)
           next unless from && to
-          color = @theme == "print" ? "#222222" : (wire.color || wire_color(wire))
-          path = if wire.route == "arc"
-            control_y = (py(from[1]) + py(to[1])) / 2.0 - 8
-            "M #{fmt(px(from[0]))} #{fmt(py(from[1]))} Q #{fmt((px(from[0]) + px(to[0])) / 2)} #{fmt(control_y)} #{fmt(px(to[0]))} #{fmt(py(to[1]))}"
-          elsif wire.route == "edge"
-            edge_route(wire, from, to)
-          else
-            "M #{fmt(px(from[0]))} #{fmt(py(from[1]))} L #{fmt(px(to[0]))} #{fmt(py(to[1]))}"
-          end
+          chosen = @color_by == "net" ? wire_color(wire) : (wire.color || wire_color(wire))
+          color = @theme == "print" ? "#222222" : render_color(chosen, "wire #{wire.id}") { wire_color(wire) }
+          color = { "removed" => "#d94c48", "added" => "#23a86b" }.fetch(@diff_wires[wire.id], color)
+          path = wire_path(wire, from, to)
           dash = if wire.dashed
             " stroke-dasharray=\"5 4\""
           elsif @theme == "print"
@@ -497,26 +837,63 @@ module Breadkit
           else
             ""
           end
-          casing = "<path d=\"#{path}\" fill=\"none\" stroke=\"#{@colors[:board]}\" stroke-width=\"3.6\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>"
-          wire_svg = "<path d=\"#{path}\" fill=\"none\" stroke=\"#{escape(color)}\" stroke-width=\"2.4\" stroke-linecap=\"round\" stroke-linejoin=\"round\" data-ref=\"#{escape(wire.id)}\"#{dash}/>"
+          casing = @wire_style == "flat" ? "" : "<path d=\"#{path}\" fill=\"none\" stroke=\"#{@colors[:board]}\" stroke-width=\"3.6\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>"
+          net_attr = @nets_by_member[wire.id] ? " data-net=\"#{escape(@nets_by_member[wire.id].name)}\"" : ""
+          diff_attr = @diff_wires[wire.id] ? " data-diff=\"#{@diff_wires[wire.id]}\"" : ""
+          wire_svg = "<path d=\"#{path}\" fill=\"none\" stroke=\"#{escape(color)}\" stroke-width=\"#{@wire_style == 'flat' ? '1.8' : '2.4'}\" stroke-linecap=\"round\" stroke-linejoin=\"round\" data-ref=\"#{escape(wire.id)}\"#{net_attr}#{diff_attr}#{dash}/>"
           dots = [from, to].uniq.map do |x, y|
             circle(px(x), py(y), 2.8, fill: color, stroke: @colors[:board], stroke_width: 1.2,
                    data_wire: wire.id)
           end
           alternative = wire.electrical == false
-          casings << layer_group(casing, wire.layer, alternative: alternative)
-          lines << layer_group(wire_svg, wire.layer, alternative: alternative)
-          markers << layer_group(dots.join, wire.layer, alternative: alternative)
+          casings << layer_group(emphasis_group(casing, wire.id), wire.layer, alternative: alternative)
+          lines << layer_group(emphasis_group(wire_svg, wire.id), wire.layer, alternative: alternative)
+          markers << layer_group(emphasis_group(dots.join, wire.id), wire.layer, alternative: alternative)
         end
         (casings + lines + markers).join
       end
 
+      def wire_path(wire, from, to)
+        if wire.route == "arc"
+          control_y = (py(from[1]) + py(to[1])) / 2.0 - 8
+          "M #{fmt(px(from[0]))} #{fmt(py(from[1]))} Q #{fmt((px(from[0]) + px(to[0])) / 2)} #{fmt(control_y)} #{fmt(px(to[0]))} #{fmt(py(to[1]))}"
+        elsif wire.route == "edge"
+          edge_route(wire, from, to)
+        elsif @wire_routing == "auto" && !offboard_component(wire.from) && !offboard_component(wire.to)
+          points = wire_route_points(wire, from, to)
+          "M #{points.map { |x, y| "#{fmt(px(x))} #{fmt(py(y))}" }.join(' L ')}"
+        else
+          "M #{fmt(px(from[0]))} #{fmt(py(from[1]))} L #{fmt(px(to[0]))} #{fmt(py(to[1]))}"
+        end
+      end
+
       def layer_names(value)
         Array(value).filter_map { |name| name.to_s unless name.nil? || name.to_s.empty? }
       end
 
+      def emphasized_component?(ref)
+        @focus_ref ? ref == @focus_ref : @emphasized_component_refs.include?(ref)
+      end
+
+      def emphasis_group(svg, wire_id)
+        return svg unless @emphasis_active && !@emphasized_wire_ids.include?(wire_id)
+
+        "<g opacity=\"0.18\">#{svg}</g>"
+      end
+
+      def visible_in_layer?(names)
+        layers = layer_names(names)
+        !@active_layer || layers.empty? || layers.include?(@active_layer)
+      end
+
+      def visible_net?(net)
+        !@active_layer || net.holes.any? { |id| @used_holes.include?(id) } ||
+          net.members.any? { |member| @visible_wire_ids.include?(member) }
+      end
+
       def layer_group(content, names, alternative: false)
         names = layer_names(names)
+        return names.include?(@active_layer) ? content : "" if @active_layer && !names.empty?
         return content if names.empty?
 
         attributes = "data-layers=\"#{escape(JSON.generate(names))}\""
@@ -610,7 +987,7 @@ module Breadkit
 
       def nets_svg
         return "" unless @show_nets
-        @circuit.nets.map do |net|
+        @nets.select { |net| visible_net?(net) }.map do |net|
           hole = @circuit.board.hole(net.holes.first)
           next unless hole
           display = display_hole(hole)
@@ -636,6 +1013,11 @@ module Breadkit
             out << text(x + 15, y, net.name, "font-size" => 5.5)
             y += 9
           end
+          dip_pin_map_lines.each do |pin_line|
+            out << text(x, y, pin_line, "font-size" => 5.5)
+            y += 7
+          end
+          y += 2 unless dip_pin_map_lines.empty?
         end
         @annotations.each_with_index do |item, index|
           message = read(item, "message") || read(item, "rule")
@@ -652,11 +1034,35 @@ module Breadkit
         return "#222222" if @theme == "print"
 
         wire = net.members.filter_map { |member| @wires_by_id[member] }.first
-        wire ? (wire.color || wire_color(wire)) : PALETTE[@net_indexes.fetch(net) % PALETTE.length]
+        chosen = @color_by == "net" ? wire_color(wire) : (wire&.color || wire_color(wire)) if wire
+        wire ? render_color(chosen, "wire #{wire.id}") { wire_color(wire) } : wire_palette[@net_indexes.fetch(net) % wire_palette.length]
+      end
+
+      def render_color(value, context)
+        valid = if Breadkit.const_defined?(:Color)
+          Breadkit::Color.valid?(value)
+        else
+          CSS_COLOR_NAMES.include?(value.to_s.downcase) || /\A#(?:[0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})\z/i.match?(value.to_s)
+        end
+        return value if valid
+
+        fallback = yield
+        unless @invalid_colors_warned.include?(context)
+          warn "bkrender: invalid color #{value.inspect} for #{context}; using #{fallback}"
+          @invalid_colors_warned << context
+        end
+        fallback
       end
 
       def legend_nets
-        @circuit.nets.reject { |net| net.members.length == 1 && net.holes.empty? }
+        @nets.select { |net| visible_net?(net) && !(net.members.length == 1 && net.holes.empty?) }
+      end
+
+      def dip_pin_map_lines
+        @visible_components.select { |component| component.part.data.dig("render", "shape") == "dip" }.flat_map do |component|
+          names = component.pins.values.sort_by { |pin| pin.number.to_i }.map { |pin| "#{pin.number} #{pin.name}" }
+          annotation_lines("#{component.ref} pins: #{names.join(' · ')}")
+        end
       end
 
       def annotations_svg
@@ -684,41 +1090,70 @@ module Breadkit
               x, y = px(point[0]), py(point[1])
               anchor ||= [x, y]
               out << circle(x, y, 5, fill: "none", stroke: color, stroke_width: 1.5)
+              annotation_state = read(item, "state")
+              if read(item, "rule") == "Electrical/ShortCircuit" && @visible_wire_ids.include?(id) &&
+                  (annotation_state.nil? || annotation_state.to_s == @state&.name.to_s)
+                finish = endpoint_point(wire.to)
+                out << tag("path", d: wire_path(wire, point, finish), fill: "none", stroke: color,
+                           stroke_width: 5, stroke_linecap: "round", stroke_dasharray: "5 4", opacity: 0.85,
+                           data_short_path: id) if finish
+              end
             end
           end
+          Array(read(targets, "pins")).each do |ref|
+            point = endpoint_point(ref)
+            next unless point
+
+            x, y = px(point[0]), py(point[1])
+            anchor ||= [x, y]
+            out << circle(x, y, 4, fill: "none", stroke: color, stroke_width: 1.5, data_pin: ref)
+          end
           Array(read(targets, "components")).each do |ref|
             component = @circuit.components[ref]
+            next unless component
+
+            if component.part.placement == "offboard"
+              x, y, width, height, = offboard_layout(component)
+              left, top = px(x), py(y + height)
+              anchor ||= [left + px(width) / 2, top + px(height) / 2]
+              out << rect(left - 3, top - 3, px(width) + 6, px(height) + 6,
+                          fill: "none", stroke: color, stroke_width: 1.5, data_component: ref)
+              next
+            end
             holes = component && component.pins.values.map { |pin| @circuit.board.hole(pin.hole_id) }.compact
-            next if holes.nil? || holes.empty?
+            next if holes.empty?
             xs, ys = holes.map { |hole| px(display_hole(hole).x) }, holes.map { |hole| py(display_hole(hole).y) }
             anchor ||= [(xs.min + xs.max) / 2, (ys.min + ys.max) / 2]
             out << rect(xs.min - 7, ys.min - 7, xs.max - xs.min + 14, ys.max - ys.min + 14,
-                        fill: "none", stroke: color, stroke_width: 1.5)
+                        fill: "none", stroke: color, stroke_width: 1.5, data_component: ref)
           end
           Array(read(targets, "nets")).each do |name|
             state_name = read(item, "state")
+            state = @state
             if state_name
-              @annotation_states ||= @circuit.states("all").to_h { |candidate| [candidate.name, candidate] }
-              state = @annotation_states[state_name]
+              @annotation_states ||= {}
+              state = @annotation_states.fetch(state_name) do
+                @annotation_states[state_name] = StateSelection.resolve(@circuit, state_name)
+              end
               next unless state
             end
             net = @circuit.nets(state).find { |candidate| candidate.name == name }
             next unless net
-            if net.holes.empty?
-              point = net.members.filter_map { |member| endpoint_point(member) }.first
-              if point
-                x, y = px(point[0]), py(point[1])
-                anchor ||= [x, y]
-                out << circle(x, y, 4, fill: "none", stroke: color, stroke_width: 1.5)
-              end
-            end
-            net.holes.each do |id|
+            points = net.holes.filter_map do |id|
               hole = @circuit.board.hole(id)
-              next unless hole
-              display = display_hole(hole)
-              x, y = px(display.x), py(display.y)
-              anchor ||= [x, y]
-              out << circle(x, y, 3, fill: "none", stroke: color, stroke_width: 1)
+              display = display_hole(hole) if hole
+              [px(display.x), py(display.y)] if display
+            end
+            points = net.members.filter_map { |member| endpoint_point(member)&.then { |x, y| [px(x), py(y)] } } if points.empty?
+            next if points.empty?
+
+            xs, ys = points.map(&:first), points.map(&:last)
+            anchor ||= points.first
+            if points.length == 1
+              out << circle(xs.first, ys.first, 4, fill: "none", stroke: color, stroke_width: 1.5, data_net: name)
+            else
+              out << rect(xs.min - 4, ys.min - 4, xs.max - xs.min + 8, ys.max - ys.min + 8,
+                          rx: 4, fill: "none", stroke: color, stroke_width: 1.2, data_net: name)
             end
           end
           if anchor
@@ -768,16 +1203,21 @@ module Breadkit
       end
 
       def view_box(mode)
-        offboard = @circuit.components.values.any? { |component| component.part.placement == "offboard" }
-        wire_points = @circuit.wires.flat_map do |wire|
+        offboard = @visible_components.any? { |component| component.part.placement == "offboard" }
+        wire_points = @visible_wires.flat_map do |wire|
           from, to = endpoint_point(wire.from), endpoint_point(wire.to)
           from && to ? wire_route_points(wire, from, to) : []
         end
         if mode == "none" || (@used_holes.empty? && !offboard)
           left, top, width, height = board_bounds
-          module_points = wire_points + @circuit.components.values.flat_map do |component|
+          module_points = wire_points + @visible_components.flat_map do |component|
             if component.part.placement == "offboard"
               offboard_bounds(component)
+            elsif rail_module?(component)
+              pins = component.pins.values.filter_map { |pin| [pin, @circuit.board.hole(pin.hole_id)] if pin.hole_id }
+              next [] if pins.empty?
+              x, y, module_width, module_height = rail_module_bounds(pins)
+              [[x, y], [x + module_width, y + module_height]]
             elsif component.part.data.dig("render", "shape") == "module"
               pins = component.pins.values.filter_map { |pin| [pin, @circuit.board.hole(pin.hole_id)] if pin.hole_id }
               next [] if pins.empty?
@@ -804,9 +1244,15 @@ module Breadkit
           [display.x, display.y] if display
         end
         points.concat(wire_points)
-        points.concat(@circuit.components.values.select { |component| component.part.placement == "offboard" }
+        points.concat(@visible_components.select { |component| component.part.placement == "offboard" }
                               .flat_map { |component| offboard_bounds(component) })
-        points.concat(@circuit.components.values.flat_map do |component|
+        points.concat(@visible_components.flat_map do |component|
+          if rail_module?(component)
+            pins = component.pins.values.filter_map { |pin| [pin, @circuit.board.hole(pin.hole_id)] if pin.hole_id }
+            next [] if pins.empty?
+            x, y, width, height = rail_module_bounds(pins)
+            next [[x, y], [x + width, y + height]]
+          end
           next [] unless component.part.data.dig("render", "shape") == "module"
           pins = component.pins.values.filter_map { |pin| [pin, @circuit.board.hole(pin.hole_id)] if pin.hole_id }
           next [] if pins.empty?
@@ -821,7 +1267,7 @@ module Breadkit
       def legend_height
         return 0 unless @legend_enabled || !@annotations.empty?
 
-        20 + (@legend_enabled ? legend_nets.length * 9 : 0) +
+        20 + (@legend_enabled ? legend_nets.length * 9 + dip_pin_map_lines.length * 7 + (dip_pin_map_lines.empty? ? 0 : 2) : 0) +
           @annotations.each_with_index.sum { |item, index| annotation_lines("#{index + 1}. #{read(item, "message") || read(item, "rule")}").length * 7 + 2 }
       end
 
@@ -837,12 +1283,13 @@ module Breadkit
         parsed = Breadkit::HoleId.parse(endpoint, board: @circuit.board)
         if parsed.kind == :pin
           component = @circuit.components[parsed.ref]
-          if component&.part&.placement == "offboard"
-            pins = component.pins.values
-            pin = pins.find { |item| item.name == parsed.pin || item.number == parsed.pin }
-            return unless pin
-            return offboard_pin_point(component, pins.index(pin))
-          end
+          pin = component&.pin(parsed.pin)
+          return unless pin
+          return offboard_pin_point(component, component.pins.values.index(pin)) if component.part.placement == "offboard"
+
+          hole = @circuit.board.hole(pin.hole_id)
+          display = display_hole(hole) if hole
+          return [display.x, display.y] if display
         end
         hole = @circuit.board.hole(endpoint)
         display = display_hole(hole) if hole
@@ -861,11 +1308,41 @@ module Breadkit
           edge_route_points(wire, from, to)
         elsif wire.route == "arc"
           [from, [(from[0] + to[0]) / 2.0, (from[1] + to[1]) / 2.0 + 0.8], to]
+        elsif @wire_routing == "auto" && !offboard_component(wire.from) && !offboard_component(wire.to)
+          @auto_routes[wire.id] ||= @auto_router.route(from, to)
         else
           [from, to]
         end
       end
 
+      def auto_obstacles
+        @visible_components.filter_map do |component|
+          next if component.part.placement == "offboard" || rail_module?(component)
+          pins = component.pins.values.filter_map { |pin| @circuit.board.hole(pin.hole_id) }
+          next if pins.empty?
+
+          xs, ys = pins.map { |hole| display_hole(hole).x }, pins.map { |hole| display_hole(hole).y }
+          shape = component.part.data.dig("render", "shape")
+          if shape == "module"
+            x, y, width, height = module_bounds(component, pins.map { |hole| [nil, hole] })
+            [x, y, x + width, y + height]
+          elsif (size = component.part.data.dig("render", "size_mm"))
+            width, height = size.map { |value| value.to_f / 2.54 }
+            center_x, center_y = (xs.min + xs.max) / 2.0, (ys.min + ys.max) / 2.0
+            [center_x - width / 2, center_y - height / 2, center_x + width / 2, center_y + height / 2]
+          elsif shape == "dip"
+            [xs.min - 0.4, (ys.min + ys.max) / 2.0 - 0.4, xs.max + 0.4, (ys.min + ys.max) / 2.0 + 0.4]
+          else
+            half_width, half_height = { "resistor" => [1.2, 0.4], "led_5mm" => [0.55, 0.55],
+                                        "tact_switch" => [1.2, 1.0], "potentiometer" => [1.2, 0.8],
+                                        "diode" => [0.7, 0.3], "rgb_led_5mm" => [0.7, 0.7],
+                                        "to92" => [0.8, 0.6] }.fetch(shape, [0.9, 0.5])
+            center_x, center_y = (xs.min + xs.max) / 2.0, (ys.min + ys.max) / 2.0
+            [center_x - half_width, center_y - half_height, center_x + half_width, center_y + half_height]
+          end
+        end
+      end
+
       def edge_route_points(wire, from, to)
         module_from = offboard_component(wire.from)
         module_to = offboard_component(wire.to)
@@ -897,7 +1374,12 @@ module Breadkit
               [module_point, [module_point[0], lane], [x, lane], [x, board_point[1]], board_point]
             else
               y = board_point[1] + breakout
-              [module_point, [lane, module_point[1]], [lane, y], [board_point[0], y], board_point]
+              detour = landscape_terminal_detour(board_point[0], lane, y, index)
+              if detour
+                [module_point, [lane, module_point[1]], [lane, detour], [board_point[0], detour], [board_point[0], y], board_point]
+              else
+                [module_point, [lane, module_point[1]], [lane, y], [board_point[0], y], board_point]
+              end
             end
           elsif hole&.kind == :rail && @orientation == "portrait"
             component = module_from || module_to
@@ -924,6 +1406,19 @@ module Breadkit
         points
       end
 
+      def landscape_terminal_detour(from_x, to_x, y, index)
+        obstacles = @visible_components.filter_map do |component|
+          next unless component.part.placement == "footprint" && component.part.data.dig("render", "shape") == "module"
+
+          pins = component.pins.values.filter_map { |pin| [pin, @circuit.board.hole(pin.hole_id)] if pin.hole_id }
+          next if pins.empty?
+
+          x, bottom, width, height = module_bounds(component, pins)
+          bottom + height if y.between?(bottom - 0.3, bottom + height + 0.3) && [from_x, to_x].min < x + width && [from_x, to_x].max > x
+        end
+        obstacles.max && obstacles.max + 1.2 + index * 0.35
+      end
+
       def edge_breakout_offset(wire, x)
         @edge_breakout_offsets ||= begin
           groups = Hash.new { |hash, key| hash[key] = [] }
@@ -1080,14 +1575,18 @@ module Breadkit
       def wire_color(wire)
         if @color_by == "net"
           net = @nets_by_member[wire.id] || @nets_by_hole[wire.from]
-          voltage = net && @circuit.potentials.values[net.name]
+          voltage = net && @circuit.potentials(@state).values[net.name]
           return voltage.positive? ? @colors[:positive] : (voltage.negative? ? @colors[:negative_wire] : @colors[:text]) if voltage
           if net
             hash = net.name.each_byte.reduce(2_166_136_261) { |value, byte| ((value ^ byte) * 16_777_619) & 0xffffffff }
-            return PALETTE[hash % PALETTE.length]
+            return wire_palette[hash % wire_palette.length]
           end
         end
-        PALETTE[@wire_indexes.fetch(wire) % PALETTE.length]
+        wire_palette[@wire_indexes.fetch(wire) % wire_palette.length]
+      end
+
+      def wire_palette
+        @theme == "colorblind" ? COLORBLIND_PALETTE : PALETTE
       end
 
       def resistor_bands(value, bands: 4)
@@ -1128,6 +1627,10 @@ module Breadkit
         format("%.2f", value.to_f)
       end
 
+      def coord(value)
+        fmt(value).sub(/\.?0+\z/, "")
+      end
+
       def escape(value)
         CGI.escapeHTML(value.to_s)
       end