circuit-to-svg 0.0.210 → 0.0.211

package/dist/index.js

@@ -1783,7 +1783,7 @@ function getSoftwareUsedString(circuitJson) {
 var package_default = {
   name: "circuit-to-svg",
   type: "module",
-  version: "0.0.209",
+  version: "0.0.210",
   description: "Convert Circuit JSON to SVG",
   main: "dist/index.js",
   files: [
@@ -3211,7 +3211,7 @@ function createSvgObjectsFromPinoutComponent(elm, ctx) {
   const [x, y] = applyToPoint29(transform, [center.x, center.y]);
   const scaledWidth = width * Math.abs(transform.a);
   const scaledHeight = height * Math.abs(transform.d);
-  const transformStr = `translate(${x}, ${y}) rotate(${-rotation})`;
+  const transformStr = `translate(${x}, ${y})`;
   const children = [
     {
       name: "rect",
@@ -3222,14 +3222,14 @@ function createSvgObjectsFromPinoutComponent(elm, ctx) {
         y: (-scaledHeight / 2).toString(),
         width: scaledWidth.toString(),
         height: scaledHeight.toString(),
-        fill: COMPONENT_FILL_COLOR
+        fill: COMPONENT_FILL_COLOR,
+        transform: `rotate(${rotation}deg)`
       },
       value: "",
       children: []
     }
   ];
   if (sourceComponent?.name) {
-    const isTall = scaledHeight > scaledWidth * 1.5;
     const labelFontSize = Math.min(scaledWidth, scaledHeight) * 0.4;
     children.push({
       name: "text",
@@ -3241,8 +3241,7 @@ function createSvgObjectsFromPinoutComponent(elm, ctx) {
         "font-size": `${labelFontSize}px`,
         "font-family": "sans-serif",
         "text-anchor": "middle",
-        "dominant-baseline": "middle",
-        transform: isTall ? "rotate(90)" : ""
+        "dominant-baseline": "middle"
       },
       children: [
         {
@@ -3694,9 +3693,77 @@ function createSvgObjectsFromPinoutSmtPad(pad, ctx) {
 // lib/pinout/svg-object-fns/create-svg-objects-from-pinout-port.ts
 import { applyToPoint as applyToPoint33 } from "transformation-matrix";
 import { calculateElbow } from "calculate-elbow";
+
+// lib/pinout/svg-object-fns/pinout-label-box.ts
+function createPinoutLabelBox(params) {
+  const {
+    rectX,
+    rectY,
+    rectWidth,
+    rectHeight,
+    textX,
+    textY,
+    text,
+    fontSize,
+    labelBackground,
+    labelColor,
+    rx = 4,
+    ry = 4,
+    fontFamily = "Arial, sans-serif",
+    fontWeight = "bold",
+    textAnchor = "middle",
+    dominantBaseline = "middle"
+  } = params;
+  return [
+    {
+      name: "rect",
+      type: "element",
+      attributes: {
+        x: rectX.toString(),
+        y: rectY.toString(),
+        width: rectWidth.toString(),
+        height: rectHeight.toString(),
+        fill: labelBackground,
+        rx: typeof rx === "number" ? rx.toString() : rx,
+        ry: typeof ry === "number" ? ry.toString() : ry,
+        stroke: "none"
+      },
+      children: [],
+      value: ""
+    },
+    {
+      name: "text",
+      type: "element",
+      attributes: {
+        x: textX.toString(),
+        y: textY.toString(),
+        fill: labelColor,
+        "font-size": `${fontSize}px`,
+        "font-family": fontFamily,
+        "font-weight": fontWeight,
+        "text-anchor": textAnchor,
+        "dominant-baseline": dominantBaseline
+      },
+      children: [
+        {
+          type: "text",
+          value: text,
+          name: "",
+          attributes: {},
+          children: []
+        }
+      ],
+      value: ""
+    }
+  ];
+}
+
+// lib/pinout/svg-object-fns/create-svg-objects-from-pinout-port.ts
 var LABEL_COLOR = "rgb(255, 255, 255)";
 var LABEL_BACKGROUND = "rgb(0, 0, 0)";
 var LINE_COLOR = "rgba(0, 0, 0, 0.6)";
+var PIN_NUMBER_BACKGROUND = "rgb(200, 200, 200)";
+var PIN_NUMBER_COLOR = "rgb(0, 0, 0)";
 function createSvgObjectsFromPinoutPort(pcb_port, ctx) {
   const label_info = ctx.label_positions.get(pcb_port.pcb_port_id);
   if (!label_info) return [];
@@ -3718,26 +3785,33 @@ function createSvgObjectsFromPinoutPort(pcb_port, ctx) {
     {}
   );
   const line_points = [...elbow_path, label_pos].map((p) => `${p.x},${p.y}`).join(" ");
-  const full_label = [label, ...aliases].join(" | ");
-  const fontSize = 11;
-  const textWidth = full_label.length * fontSize * 0.6;
-  const bgPadding = 5;
-  const rectHeight = fontSize + 2 * bgPadding;
-  const rectWidth = textWidth + 2 * bgPadding;
+  const numberMatch = /^pin(\d+)$/i.exec(label);
+  const tokensWithStyle = [
+    {
+      text: numberMatch ? numberMatch[1] : label,
+      bg: numberMatch ? PIN_NUMBER_BACKGROUND : LABEL_BACKGROUND,
+      color: numberMatch ? PIN_NUMBER_COLOR : LABEL_COLOR
+    },
+    ...aliases.map((t) => ({
+      text: t,
+      bg: LABEL_BACKGROUND,
+      color: LABEL_COLOR
+    }))
+  ];
+  const scale10 = Math.abs(ctx.transform.a);
+  const LABEL_RECT_HEIGHT_MM2 = 2.2;
+  const rectHeight = LABEL_RECT_HEIGHT_MM2 * scale10;
+  const fontSize = rectHeight * (11 / 21);
+  const bgPadding = (rectHeight - fontSize) / 2;
+  const gap = bgPadding;
+  const tokenRects = tokensWithStyle.map(({ text, bg, color }) => {
+    const safeText = text ?? "";
+    const textWidth = safeText.length * fontSize * 0.6;
+    const rectWidth = textWidth + 2 * bgPadding;
+    return { text: safeText, rectWidth, bg, color };
+  });
   const text_y = label_pos.y;
-  let rectX;
-  let text_x;
-  if (edge === "left") {
-    rectX = label_pos.x - rectWidth;
-    text_x = label_pos.x - rectWidth / 2;
-  } else if (edge === "right") {
-    rectX = label_pos.x;
-    text_x = label_pos.x + rectWidth / 2;
-  } else {
-    rectX = label_pos.x - rectWidth / 2;
-    text_x = label_pos.x;
-  }
-  return [
+  const objects = [
     {
       name: "polyline",
       type: "element",
@@ -3749,202 +3823,239 @@ function createSvgObjectsFromPinoutPort(pcb_port, ctx) {
       },
       children: [],
       value: ""
-    },
-    {
-      name: "rect",
-      type: "element",
-      attributes: {
-        x: rectX.toString(),
-        y: (text_y - rectHeight / 2).toString(),
-        width: rectWidth.toString(),
-        height: rectHeight.toString(),
-        fill: LABEL_BACKGROUND,
-        rx: "8",
-        // More rounded corners
-        ry: "8",
-        stroke: "none"
-      },
-      children: [],
-      value: ""
-    },
-    {
-      name: "text",
-      type: "element",
-      attributes: {
-        x: text_x.toString(),
-        y: text_y.toString(),
-        fill: LABEL_COLOR,
-        "font-size": `${fontSize}px`,
-        "font-family": "Arial, sans-serif",
-        "font-weight": "bold",
-        "text-anchor": "middle",
-        "dominant-baseline": "middle"
-      },
-      children: [
-        {
-          type: "text",
-          value: full_label,
-          name: "",
-          attributes: {},
-          children: []
-        }
-      ],
-      value: ""
     }
   ];
-}
-
-// lib/pinout/calculate-label-positions.ts
-import { applyToPoint as applyToPoint34 } from "transformation-matrix";
-
-// lib/pinout/pinout-utils.ts
-import { su as su6 } from "@tscircuit/circuit-json-util";
-function getPortLabelInfo(port, soup) {
-  const source_port = su6(soup).source_port.get(port.source_port_id);
-  if (!source_port) return null;
-  const eligible_hints = source_port.port_hints?.filter(
-    (h) => !/^\d+$/.test(h) && !["left", "right", "top", "bottom"].includes(h)
-  ) ?? [];
-  let label = eligible_hints[0];
-  if (!label) label = source_port.name;
-  if (!label) return null;
-  const aliases = eligible_hints.filter((h) => h !== label);
-  return { text: label, aliases };
-}
-function getClosestEdge(port_pos_real, board_bounds) {
-  const dists = {
-    left: port_pos_real.x - board_bounds.minX,
-    right: board_bounds.maxX - port_pos_real.x,
-    top: board_bounds.maxY - port_pos_real.y,
-    bottom: port_pos_real.y - board_bounds.minY
-  };
-  let closest_edge = "left";
-  let min_dist = dists.left;
-  if (dists.right < min_dist) {
-    min_dist = dists.right;
-    closest_edge = "right";
-  }
-  if (dists.top < min_dist) {
-    min_dist = dists.top;
-    closest_edge = "top";
-  }
-  if (dists.bottom < min_dist) {
-    min_dist = dists.bottom;
-    closest_edge = "bottom";
+  if (edge === "left") {
+    let currentX = label_pos.x;
+    for (const { text, rectWidth, bg, color } of tokenRects) {
+      const rectX = currentX - rectWidth;
+      const text_x = rectX + rectWidth / 2;
+      objects.push(
+        ...createPinoutLabelBox({
+          rectX,
+          rectY: text_y - rectHeight / 2,
+          rectWidth,
+          rectHeight,
+          textX: text_x,
+          textY: text_y,
+          text,
+          fontSize,
+          labelBackground: bg,
+          labelColor: color
+        })
+      );
+      currentX = rectX - gap;
+    }
+  } else if (edge === "right") {
+    let currentX = label_pos.x;
+    for (const { text, rectWidth, bg, color } of tokenRects) {
+      const rectX = currentX;
+      const text_x = rectX + rectWidth / 2;
+      objects.push(
+        ...createPinoutLabelBox({
+          rectX,
+          rectY: text_y - rectHeight / 2,
+          rectWidth,
+          rectHeight,
+          textX: text_x,
+          textY: text_y,
+          text,
+          fontSize,
+          labelBackground: bg,
+          labelColor: color
+        })
+      );
+      currentX = rectX + rectWidth + gap;
+    }
+  } else {
+    const totalWidth = tokenRects.reduce((acc, t) => acc + t.rectWidth, 0) + gap * Math.max(0, tokenRects.length - 1);
+    let currentX = label_pos.x - totalWidth / 2;
+    for (const { text, rectWidth, bg, color } of tokenRects) {
+      const rectX = currentX;
+      const text_x = rectX + rectWidth / 2;
+      objects.push(
+        ...createPinoutLabelBox({
+          rectX,
+          rectY: text_y - rectHeight / 2,
+          rectWidth,
+          rectHeight,
+          textX: text_x,
+          textY: text_y,
+          text,
+          fontSize,
+          labelBackground: bg,
+          labelColor: color
+        })
+      );
+      currentX = rectX + rectWidth + gap;
+    }
   }
-  return closest_edge;
+  return objects;
 }
 
 // lib/pinout/calculate-label-positions.ts
+import "@tscircuit/circuit-json-util";
+import { applyToPoint as applyToPoint34 } from "transformation-matrix";
 var STAGGER_OFFSET_MIN = 20;
-var STAGGER_OFFSET_PER_PIN = 2;
-var STAGGER_OFFSET_STEP = 15;
+var STAGGER_OFFSET_PER_PIN = 3;
+var STAGGER_OFFSET_STEP = 18;
 var ALIGNED_OFFSET_MARGIN = 10;
-var FONT_SIZE = 11;
-var BG_PADDING = 5;
-var LABEL_RECT_HEIGHT = FONT_SIZE + 2 * BG_PADDING;
-var LABEL_MARGIN = 5;
-function calculateVerticalEdgeLabels(edge, ports, {
+var LABEL_RECT_HEIGHT_MM = 1.6;
+var LABEL_PITCH_MM = 2.54;
+function calculateVerticalEdgeLabels(edge, pinout_labels, {
   transform,
   soup,
   board_bounds,
   svgHeight
 }, label_positions) {
-  const edge_ports = ports.map((port) => ({
-    port,
-    y: applyToPoint34(transform, [port.x, port.y])[1],
-    label_info: getPortLabelInfo(port, soup)
-  })).filter((p) => p.label_info).sort((a, b) => a.y - b.y);
+  const x_coords = pinout_labels.map((l) => l.pcb_port.x);
+  const counts = {};
+  for (const x of x_coords) {
+    const rounded = x.toFixed(1);
+    counts[rounded] = (counts[rounded] || 0) + 1;
+  }
+  let edge_ports;
+  if (Object.keys(counts).length > 1 && pinout_labels.length > 2) {
+    const sorted_x_groups = Object.entries(counts).sort((a, b) => b[1] - a[1]);
+    const primary_x = parseFloat(sorted_x_groups[0][0]);
+    const primary_pins = pinout_labels.filter(
+      (l) => Math.abs(l.pcb_port.x - primary_x) < 0.2
+    );
+    const other_pins = pinout_labels.filter(
+      (l) => Math.abs(l.pcb_port.x - primary_x) >= 0.2
+    );
+    const mapToEdgePort = (pinout_label) => ({
+      pcb_port: pinout_label.pcb_port,
+      y: applyToPoint34(transform, [
+        pinout_label.pcb_port.x,
+        pinout_label.pcb_port.y
+      ])[1],
+      aliases: pinout_label.aliases
+    });
+    primary_pins.sort((a, b) => b.pcb_port.y - a.pcb_port.y);
+    other_pins.sort((a, b) => b.pcb_port.y - a.pcb_port.y);
+    const max_y_primary = primary_pins.length > 0 ? Math.max(...primary_pins.map((p) => p.pcb_port.y)) : -Infinity;
+    const max_y_other = other_pins.length > 0 ? Math.max(...other_pins.map((p) => p.pcb_port.y)) : -Infinity;
+    const combined_pins = max_y_other > max_y_primary ? [...other_pins, ...primary_pins] : [...primary_pins, ...other_pins];
+    edge_ports = combined_pins.map(mapToEdgePort);
+  } else {
+    edge_ports = pinout_labels.map((pinout_label) => ({
+      pcb_port: pinout_label.pcb_port,
+      y: applyToPoint34(transform, [
+        pinout_label.pcb_port.x,
+        pinout_label.pcb_port.y
+      ])[1],
+      aliases: pinout_label.aliases
+    })).sort((a, b) => a.y - b.y);
+  }
   if (edge_ports.length === 0) return;
   const board_edge_x = applyToPoint34(transform, [
     edge === "left" ? board_bounds.minX : board_bounds.maxX,
     0
   ])[0];
   const num_labels = edge_ports.length;
-  const middle_index = (num_labels - 1) / 2;
+  const x_coords_counts = {};
+  for (const pl of pinout_labels) {
+    const rounded = pl.pcb_port.x.toFixed(1);
+    x_coords_counts[rounded] = (x_coords_counts[rounded] || 0) + 1;
+  }
+  let main_group_pin_port_ids = /* @__PURE__ */ new Set();
+  if (Object.keys(x_coords_counts).length > 1 && pinout_labels.length > 2) {
+    const sorted_x_groups = Object.entries(x_coords_counts).sort(
+      (a, b) => b[1] - a[1]
+    );
+    const primary_x = parseFloat(sorted_x_groups[0][0]);
+    const primary_pins = pinout_labels.filter(
+      (l) => Math.abs(l.pcb_port.x - primary_x) < 0.2
+    );
+    main_group_pin_port_ids = new Set(
+      primary_pins.map((p) => p.pcb_port.pcb_port_id)
+    );
+  }
+  const main_group_indices = edge_ports.map((ep, i) => {
+    if (main_group_pin_port_ids.has(ep.pcb_port.pcb_port_id)) {
+      return i;
+    }
+    return -1;
+  }).filter((i) => i !== -1);
+  const geometric_middle_index = (num_labels - 1) / 2;
+  const scale10 = Math.abs(transform.a);
+  const label_rect_height = LABEL_RECT_HEIGHT_MM * scale10;
+  const label_pitch = LABEL_PITCH_MM * scale10;
+  const label_margin = Math.max(0, label_pitch - label_rect_height);
   const stagger_offset_base = STAGGER_OFFSET_MIN + num_labels * STAGGER_OFFSET_PER_PIN;
-  const max_stagger_offset = stagger_offset_base + middle_index * STAGGER_OFFSET_STEP;
+  const max_stagger_offset = stagger_offset_base + geometric_middle_index * STAGGER_OFFSET_STEP;
   const aligned_label_offset = max_stagger_offset + ALIGNED_OFFSET_MARGIN;
-  const total_labels_height = num_labels * LABEL_RECT_HEIGHT + Math.max(0, num_labels - 1) * LABEL_MARGIN;
-  let current_y = (svgHeight - total_labels_height) / 2 + LABEL_RECT_HEIGHT / 2;
-  edge_ports.forEach(({ port, label_info }, i) => {
-    const dist_from_middle = Math.abs(i - middle_index);
-    const stagger_rank = middle_index - dist_from_middle;
+  const num_other_pins = num_labels - main_group_indices.length;
+  const num_pins_to_stack = main_group_indices.length === 0 ? num_labels : num_other_pins;
+  const stack_total_height = num_pins_to_stack * label_rect_height + Math.max(0, num_pins_to_stack - 1) * label_margin;
+  let current_y;
+  if (main_group_indices.length > 0 && num_other_pins > 0) {
+    const main_group_y_coords = main_group_indices.map((i) => edge_ports[i].y);
+    const min_main_group_y = Math.min(...main_group_y_coords);
+    const max_main_group_y = Math.max(...main_group_y_coords);
+    const main_group_top_extent = min_main_group_y - label_rect_height / 2;
+    const main_group_bottom_extent = max_main_group_y + label_rect_height / 2;
+    const other_pin_indices = edge_ports.map((_, index) => index).filter((index) => !main_group_indices.includes(index));
+    const others_are_above = other_pin_indices[0] < main_group_indices[0];
+    if (others_are_above) {
+      const stack_bottom_edge = main_group_top_extent - label_margin;
+      current_y = stack_bottom_edge - stack_total_height + label_rect_height / 2;
+    } else {
+      const stack_top_edge = main_group_bottom_extent + label_margin;
+      current_y = stack_top_edge + label_rect_height / 2;
+    }
+  } else {
+    current_y = (svgHeight - stack_total_height) / 2 + label_rect_height / 2;
+  }
+  const is_all_main_group = main_group_indices.length === num_labels;
+  edge_ports.forEach(({ pcb_port, aliases }, i) => {
+    let stagger_rank;
+    if (main_group_indices.length > 0) {
+      if (main_group_indices.includes(i)) {
+        stagger_rank = geometric_middle_index;
+      } else {
+        const min_lg_idx = Math.min(...main_group_indices);
+        const max_lg_idx = Math.max(...main_group_indices);
+        let dist_from_main_group;
+        if (i < min_lg_idx) {
+          dist_from_main_group = min_lg_idx - i;
+        } else {
+          dist_from_main_group = i - max_lg_idx;
+        }
+        stagger_rank = geometric_middle_index - dist_from_main_group;
+      }
+    } else {
+      const dist_from_middle = Math.abs(i - geometric_middle_index);
+      stagger_rank = geometric_middle_index - dist_from_middle;
+    }
     const stagger_offset = stagger_offset_base + stagger_rank * STAGGER_OFFSET_STEP;
     const sign = edge === "left" ? -1 : 1;
+    const is_main_group_pin = main_group_indices.includes(i);
+    const y_pos = is_all_main_group ? edge_ports[i].y : main_group_indices.length > 0 && is_main_group_pin ? edge_ports[i].y : current_y;
     const elbow_end = {
       x: board_edge_x + sign * stagger_offset,
-      y: current_y
+      y: y_pos
     };
     const label_pos = {
       x: board_edge_x + sign * aligned_label_offset,
-      y: current_y
+      y: y_pos
     };
-    label_positions.set(port.pcb_port_id, {
-      text: label_info.text,
-      aliases: label_info.aliases,
+    label_positions.set(pcb_port.pcb_port_id, {
+      text: aliases[0],
+      aliases: aliases.slice(1),
       elbow_end,
       label_pos,
       edge
     });
-    current_y += LABEL_RECT_HEIGHT + LABEL_MARGIN;
-  });
-}
-function calculateHorizontalEdgeLabels(edge, ports, {
-  transform,
-  soup,
-  board_bounds,
-  svgWidth
-}, label_positions) {
-  const edge_ports = ports.map((port) => ({
-    port,
-    x: applyToPoint34(transform, [port.x, port.y])[0],
-    label_info: getPortLabelInfo(port, soup)
-  })).filter((p) => p.label_info).sort((a, b) => a.x - b.x);
-  if (edge_ports.length === 0) return;
-  const board_edge_y = applyToPoint34(transform, [
-    0,
-    edge === "top" ? board_bounds.maxY : board_bounds.minY
-  ])[1];
-  const labels_with_widths = edge_ports.map((p) => {
-    const label = [p.label_info.text, ...p.label_info.aliases].join(" | ");
-    const textWidth = label.length * FONT_SIZE * 0.6;
-    const rectWidth = textWidth + 2 * BG_PADDING;
-    return { ...p, rectWidth };
-  });
-  const num_labels = labels_with_widths.length;
-  const middle_index = (num_labels - 1) / 2;
-  const stagger_offset_base = STAGGER_OFFSET_MIN + num_labels * STAGGER_OFFSET_PER_PIN;
-  const max_stagger_offset = stagger_offset_base + middle_index * STAGGER_OFFSET_STEP;
-  const aligned_label_offset = max_stagger_offset + ALIGNED_OFFSET_MARGIN;
-  const total_labels_width = labels_with_widths.reduce((sum, l) => sum + l.rectWidth, 0) + Math.max(0, num_labels - 1) * LABEL_MARGIN;
-  let current_x = (svgWidth - total_labels_width) / 2;
-  labels_with_widths.forEach(({ port, label_info, rectWidth }, i) => {
-    const dist_from_middle = Math.abs(i - middle_index);
-    const stagger_rank = middle_index - dist_from_middle;
-    const stagger_offset = stagger_offset_base + stagger_rank * STAGGER_OFFSET_STEP;
-    const sign = edge === "top" ? -1 : 1;
-    const label_center_x = current_x + rectWidth / 2;
-    const elbow_end = {
-      x: label_center_x,
-      y: board_edge_y + sign * stagger_offset
-    };
-    const label_pos = {
-      x: label_center_x,
-      y: board_edge_y + sign * aligned_label_offset
-    };
-    label_positions.set(port.pcb_port_id, {
-      text: label_info.text,
-      aliases: label_info.aliases,
-      elbow_end,
-      label_pos,
-      edge
-    });
-    current_x += rectWidth + LABEL_MARGIN;
+    if (!(main_group_indices.length > 0 && is_main_group_pin)) {
+      current_y += label_rect_height + label_margin;
+    }
   });
 }
 var calculateLabelPositions = ({
-  ports_by_edge,
+  left_labels,
+  right_labels,
   transform,
   soup,
   board_bounds,
@@ -3955,7 +4066,7 @@ var calculateLabelPositions = ({
   const shared_params = { transform, soup, board_bounds };
   calculateVerticalEdgeLabels(
     "left",
-    ports_by_edge.left,
+    left_labels,
     {
       ...shared_params,
       svgHeight
@@ -3964,34 +4075,54 @@ var calculateLabelPositions = ({
   );
   calculateVerticalEdgeLabels(
     "right",
-    ports_by_edge.right,
+    right_labels,
     {
       ...shared_params,
       svgHeight
     },
     label_positions
   );
-  calculateHorizontalEdgeLabels(
-    "top",
-    ports_by_edge.top,
-    {
-      ...shared_params,
-      svgWidth
-    },
-    label_positions
-  );
-  calculateHorizontalEdgeLabels(
-    "bottom",
-    ports_by_edge.bottom,
-    {
-      ...shared_params,
-      svgWidth
-    },
-    label_positions
-  );
   return label_positions;
 };
 
+// lib/pinout/pinout-utils.ts
+import { su as su7 } from "@tscircuit/circuit-json-util";
+function getPortLabelInfo(port, soup) {
+  const source_port = su7(soup).source_port.get(port.source_port_id);
+  if (!source_port) return null;
+  const eligible_hints = source_port.port_hints?.filter(
+    (h) => !/^\d+$/.test(h) && !["left", "right", "top", "bottom"].includes(h)
+  ) ?? [];
+  let label = eligible_hints[0];
+  if (!label) label = source_port.name;
+  if (!label) return null;
+  const aliases = eligible_hints.filter((h) => h !== label);
+  return { text: label, aliases };
+}
+function getClosestEdge(port_pos_real, board_bounds) {
+  const dists = {
+    left: port_pos_real.x - board_bounds.minX,
+    right: board_bounds.maxX - port_pos_real.x,
+    top: board_bounds.maxY - port_pos_real.y,
+    bottom: port_pos_real.y - board_bounds.minY
+  };
+  let closest_edge = "left";
+  let min_dist = dists.left;
+  if (dists.right < min_dist) {
+    min_dist = dists.right;
+    closest_edge = "right";
+  }
+  if (dists.top < min_dist) {
+    min_dist = dists.top;
+    closest_edge = "top";
+  }
+  if (dists.bottom < min_dist) {
+    min_dist = dists.bottom;
+    closest_edge = "bottom";
+  }
+  return closest_edge;
+}
+
 // lib/pinout/convert-circuit-json-to-pinout-svg.ts
 var OBJECT_ORDER3 = [
   "pcb_board",
@@ -4029,8 +4160,8 @@ function convertCircuitJsonToPinoutSvg(soup, options) {
   const padding = 20;
   const circuitWidth = maxX - minX + 2 * padding;
   const circuitHeight = maxY - minY + 2 * padding;
-  const svgWidth = options?.width ?? 800;
-  const svgHeight = options?.height ?? 600;
+  const svgWidth = options?.width ?? 1200;
+  const svgHeight = options?.height ?? 768;
   const scaleX = svgWidth / circuitWidth;
   const scaleY = svgHeight / circuitHeight;
   const scaleFactor = Math.min(scaleX, scaleY);
@@ -4047,18 +4178,45 @@ function convertCircuitJsonToPinoutSvg(soup, options) {
   const pinout_ports = soup.filter(
     (elm) => elm.type === "pcb_port" && elm.is_board_pinout
   );
-  const ports_by_edge = {
-    left: [],
-    right: [],
-    top: [],
-    bottom: []
-  };
-  for (const port of pinout_ports) {
-    const edge = getClosestEdge({ x: port.x, y: port.y }, board_bounds);
-    ports_by_edge[edge].push(port);
+  const pinout_labels = [];
+  for (const pcb_port of pinout_ports) {
+    const label_info = getPortLabelInfo(pcb_port, soup);
+    if (!label_info) continue;
+    const edge = getClosestEdge({ x: pcb_port.x, y: pcb_port.y }, board_bounds);
+    pinout_labels.push({
+      pcb_port,
+      aliases: [label_info.text, ...label_info.aliases],
+      edge
+    });
+  }
+  const left_labels = pinout_labels.filter((p) => p.edge === "left");
+  const right_labels = pinout_labels.filter((p) => p.edge === "right");
+  const top_labels = pinout_labels.filter((p) => p.edge === "top");
+  const bottom_labels = pinout_labels.filter((p) => p.edge === "bottom");
+  const boardCenterX = (minX + maxX) / 2;
+  if (top_labels.length > 0) {
+    const top_left_count = top_labels.filter(
+      (p) => p.pcb_port.x < boardCenterX
+    ).length;
+    if (top_left_count > top_labels.length / 2) {
+      left_labels.push(...top_labels);
+    } else {
+      right_labels.push(...top_labels);
+    }
+  }
+  if (bottom_labels.length > 0) {
+    const bottom_left_count = bottom_labels.filter(
+      (p) => p.pcb_port.x < boardCenterX
+    ).length;
+    if (bottom_left_count > bottom_labels.length / 2) {
+      left_labels.push(...bottom_labels);
+    } else {
+      right_labels.push(...bottom_labels);
+    }
   }
   const label_positions = calculateLabelPositions({
-    ports_by_edge,
+    left_labels,
+    right_labels,
     transform,
     soup,
     board_bounds,
@@ -5576,7 +5734,7 @@ function getSchematicBoundsFromCircuitJson(soup, padding = 0.5) {
 }
 
 // lib/sch/svg-object-fns/create-svg-objects-from-sch-component-with-symbol.ts
-import { su as su8 } from "@tscircuit/circuit-json-util";
+import { su as su9 } from "@tscircuit/circuit-json-util";
 import { symbols } from "schematic-symbols";
 import "svgson";
 import {
@@ -5737,10 +5895,10 @@ var createSvgObjectsFromSchematicComponentWithSymbol = ({
       })
     ];
   }
-  const schPorts = su8(circuitJson).schematic_port.list({
+  const schPorts = su9(circuitJson).schematic_port.list({
     schematic_component_id: schComponent.schematic_component_id
   });
-  const srcComponent = su8(circuitJson).source_component.get(
+  const srcComponent = su9(circuitJson).source_component.get(
     schComponent.source_component_id
   );
   const schPortsWithSymbolPorts = matchSchPortsToSymbolPorts({
@@ -5948,7 +6106,7 @@ var createSvgObjectsFromSchematicComponentWithSymbol = ({
 };
 
 // lib/sch/svg-object-fns/create-svg-objects-from-sch-component-with-box.ts
-import { su as su11 } from "@tscircuit/circuit-json-util";
+import { su as su12 } from "@tscircuit/circuit-json-util";
 import "schematic-symbols";
 import "svgson";
 import { applyToPoint as applyToPoint45 } from "transformation-matrix";
@@ -5959,7 +6117,7 @@ import "@tscircuit/circuit-json-util";
 
 // lib/sch/svg-object-fns/create-svg-objects-for-sch-port-box-line.ts
 import { applyToPoint as applyToPoint40 } from "transformation-matrix";
-import { su as su9 } from "@tscircuit/circuit-json-util";
+import { su as su10 } from "@tscircuit/circuit-json-util";
 var PIN_CIRCLE_RADIUS_MM = 0.02;
 var createArrow = (tip, angle, size, color, strokeWidth) => {
   const arrowAngle = Math.PI / 6;
@@ -5991,7 +6149,7 @@ var createSvgObjectsForSchPortBoxLine = ({
   circuitJson
 }) => {
   const svgObjects = [];
-  const srcPort = su9(circuitJson).source_port.get(schPort.source_port_id);
+  const srcPort = su10(circuitJson).source_port.get(schPort.source_port_id);
   const realEdgePos = {
     x: schPort.center.x,
     y: schPort.center.y
@@ -6392,7 +6550,7 @@ var createSvgObjectsFromSchematicComponentWithBox = ({
     },
     children: []
   });
-  const schTexts = su11(circuitJson).schematic_text.list();
+  const schTexts = su12(circuitJson).schematic_text.list();
   for (const schText of schTexts) {
     if (schText.schematic_component_id === schComponent.schematic_component_id) {
       svgObjects.push(
@@ -6404,7 +6562,7 @@ var createSvgObjectsFromSchematicComponentWithBox = ({
       );
     }
   }
-  const schematicPorts = su11(circuitJson).schematic_port.list({
+  const schematicPorts = su12(circuitJson).schematic_port.list({
     schematic_component_id: schComponent.schematic_component_id
   });
   for (const schPort of schematicPorts) {
@@ -7417,7 +7575,7 @@ var createSvgObjectsFromSchematicTable = ({
 };
 
 // lib/sch/svg-object-fns/create-svg-objects-for-sch-port-hover.ts
-import { su as su12 } from "@tscircuit/circuit-json-util";
+import { su as su13 } from "@tscircuit/circuit-json-util";
 import { applyToPoint as applyToPoint53 } from "transformation-matrix";
 var PIN_CIRCLE_RADIUS_MM2 = 0.02;
 var createSvgObjectsForSchPortHover = ({
@@ -7458,7 +7616,7 @@ var createSvgObjectsForSchComponentPortHovers = ({
   transform,
   circuitJson
 }) => {
-  const schematicPorts = su12(circuitJson).schematic_port.list({
+  const schematicPorts = su13(circuitJson).schematic_port.list({
     schematic_component_id: component.schematic_component_id
   });
   const svgs = [];