@tscircuit/cli 0.1.1319 → 0.1.1321

package/dist/cli/main.js

@@ -100574,7 +100574,7 @@ var import_perfect_cli = __toESM2(require_dist2(), 1);
 // lib/getVersion.ts
 import { createRequire as createRequire2 } from "node:module";
 // package.json
-var version = "0.1.1318";
+var version = "0.1.1320";
 var package_default = {
   name: "@tscircuit/cli",
   version,
@@ -100588,7 +100588,7 @@ var package_default = {
     "@biomejs/biome": "^1.9.4",
     "@tscircuit/circuit-json-placement-analysis": "^0.0.6",
     "@tscircuit/circuit-json-routing-analysis": "^0.0.1",
-    "@tscircuit/circuit-json-schematic-placement-analysis": "github:tscircuit/circuit-json-schematic-placement-analysis#c7cfc20927dc5e24414a669e7bcfdecd83504f3e",
+    "@tscircuit/circuit-json-schematic-placement-analysis": "github:tscircuit/circuit-json-schematic-placement-analysis#a8b1e6a5357f8a5aea4881f84ffda7c76d5cfe8e",
     "@tscircuit/fake-snippets": "^0.0.182",
     "@tscircuit/file-server": "^0.0.32",
     "@tscircuit/image-utils": "^0.0.3",
@@ -241231,10 +241231,10 @@ var registerCheckRouting = (program2) => {
   });
 };
 
-// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/analyze-schematic-placement.ts
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/analyzers/analyze-schematic-placement.ts
 import { cju as cju7 } from "@tscircuit/circuit-json-util";
 
-// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/capacitor-orientation.ts
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/analyzers/capacitor-orientation.ts
 var HORIZONTAL_CAPACITOR_SYMBOL_NAMES = new Set([
   "capacitor_left",
   "capacitor_right"
@@ -241260,8 +241260,314 @@ var generateCapacitorOrientationIssues = (componentPlacements, circuitJson) => {
   });
 };
 
-// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/schematic-box-overlap.ts
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/analyzers/schematic-box-sizing/shared.ts
+var SCHEMATIC_BOX_TOO_WIDE_MESSAGE = "Shrink schematic box width";
+var SCHEMATIC_PIN_PADDING_TO_EDGE_TOO_LARGE_MESSAGE = "Move schematic pins closer to the box edge or change the schematic box";
+var PIN_HEADER_SCHEMATIC_BOX_SIZING_MAX_ALLOWED_GAP = 0.1;
+var CHIP_SCHEMATIC_BOX_SIZING_MAX_ALLOWED_GAP = 1;
+var PIN_LABEL_EDGE_PADDING = 0.1;
+var PIN_NAME_CHARACTER_WIDTH = 0.095;
+var FALLBACK_CHARACTER_WIDTH = 0.13;
+var GAP_COMPARISON_EPSILON = 0.000000001;
+var isSchematicPort = (element) => element.type === "schematic_port";
+var isSourcePort = (element) => element.type === "source_port";
+var isSchematicComponent2 = (element) => element.type === "schematic_component";
+var getSourceComponentWithFtype = (element) => {
+  if (element.type !== "source_component" || !("source_component_id" in element) || typeof element.source_component_id !== "string") {
+    return null;
+  }
+  return {
+    type: "source_component",
+    source_component_id: element.source_component_id,
+    ftype: "ftype" in element && typeof element.ftype === "string" ? element.ftype : undefined
+  };
+};
+var isHorizontalSide = (side) => side === "left" || side === "right";
+var isVerticalSide = (side) => side === "top" || side === "bottom";
 var getCenteredRectBounds = (box2) => {
+  const halfWidth = box2.width / 2;
+  const halfHeight = box2.height / 2;
+  return {
+    left: box2.schX - halfWidth,
+    right: box2.schX + halfWidth,
+    top: box2.schY + halfHeight,
+    bottom: box2.schY - halfHeight
+  };
+};
+var isPinNameLabel = (label, sourcePort) => {
+  if (!sourcePort)
+    return false;
+  return label === sourcePort.name || label === String(sourcePort.pin_number) || (sourcePort.port_hints ?? []).includes(label);
+};
+var estimateLabelWidth = (label, sourcePort) => {
+  const characterWidth = isPinNameLabel(label, sourcePort) ? PIN_NAME_CHARACTER_WIDTH : FALLBACK_CHARACTER_WIDTH;
+  return Array.from(label).length * characterWidth;
+};
+var exceedsMaxAllowedGap = (measuredInnerLabelEmptySpace, maxAllowedInnerLabelEmptySpace) => measuredInnerLabelEmptySpace - maxAllowedInnerLabelEmptySpace > GAP_COMPARISON_EPSILON;
+var getSourcePortById = (circuitJson) => new Map(circuitJson.filter(isSourcePort).map((sourcePort) => [sourcePort.source_port_id, sourcePort]));
+var getSourceComponentById = (circuitJson) => new Map(circuitJson.flatMap((element) => {
+  const sourceComponent = getSourceComponentWithFtype(element);
+  return sourceComponent ? [sourceComponent] : [];
+}).map((sourceComponent) => [
+  sourceComponent.source_component_id,
+  sourceComponent
+]));
+var getSchematicComponentById = (circuitJson) => new Map(circuitJson.filter(isSchematicComponent2).map((schematicComponent) => [
+  schematicComponent.schematic_component_id,
+  schematicComponent
+]));
+var getPlacementBySchematicComponentId = (componentPlacements) => new Map(componentPlacements.filter((placement) => placement.schematicComponentId).map((placement) => [placement.schematicComponentId, placement]));
+var getPortsBySchematicComponentId = (circuitJson, isRelevantSide) => {
+  const portsBySchematicComponentId = new Map;
+  for (const port of circuitJson.filter(isSchematicPort)) {
+    if (!port.schematic_component_id)
+      continue;
+    if (!isRelevantSide(port.side_of_component))
+      continue;
+    const ports = portsBySchematicComponentId.get(port.schematic_component_id);
+    if (ports) {
+      ports.push(port);
+    } else {
+      portsBySchematicComponentId.set(port.schematic_component_id, [port]);
+    }
+  }
+  return portsBySchematicComponentId;
+};
+var getSourceComponentFtype = (schematicBox, sourceComponentById) => schematicBox.sourceComponentId ? sourceComponentById.get(schematicBox.sourceComponentId)?.ftype : undefined;
+
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/analyzers/schematic-box-sizing/pin-padding-to-edge.ts
+var isSchematicSide = (side) => isHorizontalSide(side) || isVerticalSide(side);
+var getPinSpacing = (schematicBox, schematicComponentById) => {
+  if (!schematicBox.schematicComponentId)
+    return null;
+  const schematicComponent = schematicComponentById.get(schematicBox.schematicComponentId);
+  return typeof schematicComponent?.pin_spacing === "number" ? schematicComponent.pin_spacing : null;
+};
+var getPinName = (port, sourcePortById) => {
+  const sourcePort = sourcePortById.get(port.source_port_id);
+  if (sourcePort?.name)
+    return sourcePort.name;
+  if (port.display_pin_label)
+    return port.display_pin_label;
+  if (sourcePort?.pin_number !== undefined)
+    return String(sourcePort.pin_number);
+  return;
+};
+var getMaxLabelLengthBySide = (ports, sourcePortById) => {
+  const maxLabelLengthBySide = {
+    left: 0,
+    right: 0,
+    top: 0,
+    bottom: 0
+  };
+  for (const port of ports) {
+    if (!isSchematicSide(port.side_of_component))
+      continue;
+    if (!port.display_pin_label)
+      continue;
+    maxLabelLengthBySide[port.side_of_component] = Math.max(maxLabelLengthBySide[port.side_of_component], estimateLabelWidth(port.display_pin_label, sourcePortById.get(port.source_port_id)));
+  }
+  return maxLabelLengthBySide;
+};
+var getOuterPinBySide = (edgeSide, ports) => {
+  if (ports.length === 0)
+    return null;
+  switch (edgeSide) {
+    case "top":
+      return ports.reduce((topPort, port) => port.center.y > topPort.center.y ? port : topPort);
+    case "bottom":
+      return ports.reduce((bottomPort, port) => port.center.y < bottomPort.center.y ? port : bottomPort);
+    case "left":
+      return ports.reduce((leftPort, port) => port.center.x < leftPort.center.x ? port : leftPort);
+    case "right":
+      return ports.reduce((rightPort, port) => port.center.x > rightPort.center.x ? port : rightPort);
+  }
+};
+var getPinPaddingToEdge = (input) => {
+  const bounds = getCenteredRectBounds(input.schematicBox);
+  switch (input.edgeSide) {
+    case "top":
+      return Math.max(0, bounds.top - input.port.center.y);
+    case "bottom":
+      return Math.max(0, input.port.center.y - bounds.bottom);
+    case "left":
+      return Math.max(0, input.port.center.x - bounds.left);
+    case "right":
+      return Math.max(0, bounds.right - input.port.center.x);
+  }
+};
+var getBoxEdgeSidesForPinSide = (pinSide) => isHorizontalSide(pinSide) ? ["top", "bottom"] : ["left", "right"];
+var hasPinsOnAllSides = (portsBySide) => portsBySide.has("left") && portsBySide.has("right") && portsBySide.has("top") && portsBySide.has("bottom");
+var getMaxAllowedPinPadding = (input) => {
+  const edgeAxisSides = isHorizontalSide(input.edgeSide) ? ["left", "right"] : ["top", "bottom"];
+  return (input.maxLabelLengthBySide[edgeAxisSides[0]] + input.maxLabelLengthBySide[edgeAxisSides[1]] + input.spacing) / 2;
+};
+var createPinPaddingToEdgeIssue = (candidate) => ({
+  lineItemType: "SchematicPinPaddingToEdgeTooLarge",
+  pinSide: candidate.pinSide,
+  edgeSide: candidate.edgeSide,
+  pinName: candidate.pinName,
+  schematicBox: candidate.schematicBox,
+  measuredPadding: candidate.measuredPadding,
+  maxAllowedPadding: candidate.maxAllowedPadding,
+  message: isHorizontalSide(candidate.pinSide) ? `${SCHEMATIC_PIN_PADDING_TO_EDGE_TOO_LARGE_MESSAGE} height` : `${SCHEMATIC_PIN_PADDING_TO_EDGE_TOO_LARGE_MESSAGE} width`
+});
+var generateSchematicPinPaddingToEdgeCandidates = (componentPlacements, circuitJson) => {
+  const placementBySchematicComponentId = getPlacementBySchematicComponentId(componentPlacements);
+  const schematicComponentById = getSchematicComponentById(circuitJson);
+  const sourcePortById = getSourcePortById(circuitJson);
+  const portsBySchematicComponentId = getPortsBySchematicComponentId(circuitJson, isSchematicSide);
+  const candidates = [];
+  for (const [schematicComponentId, ports] of portsBySchematicComponentId) {
+    const schematicBox = placementBySchematicComponentId.get(schematicComponentId);
+    if (!schematicBox)
+      continue;
+    const pinSpacing = getPinSpacing(schematicBox, schematicComponentById);
+    if (pinSpacing === null)
+      continue;
+    const maxLabelLengthBySide = getMaxLabelLengthBySide(ports, sourcePortById);
+    const portsBySide = new Map;
+    for (const port of ports) {
+      if (!isSchematicSide(port.side_of_component))
+        continue;
+      const sidePorts = portsBySide.get(port.side_of_component) ?? [];
+      sidePorts.push(port);
+      portsBySide.set(port.side_of_component, sidePorts);
+    }
+    const useLabelAwareMaxPadding = hasPinsOnAllSides(portsBySide);
+    for (const [pinSide, sidePorts] of portsBySide) {
+      for (const edgeSide of getBoxEdgeSidesForPinSide(pinSide)) {
+        const outerPin = getOuterPinBySide(edgeSide, sidePorts);
+        if (!outerPin)
+          continue;
+        const measuredPinPadding = {
+          pinName: getPinName(outerPin, sourcePortById),
+          measuredPadding: getPinPaddingToEdge({
+            schematicBox,
+            port: outerPin,
+            edgeSide
+          })
+        };
+        candidates.push({
+          schematicBox,
+          pinSide,
+          edgeSide,
+          pinName: measuredPinPadding.pinName,
+          measuredPadding: measuredPinPadding.measuredPadding,
+          maxAllowedPadding: useLabelAwareMaxPadding ? getMaxAllowedPinPadding({
+            spacing: pinSpacing,
+            edgeSide,
+            maxLabelLengthBySide
+          }) : pinSpacing
+        });
+      }
+    }
+  }
+  return candidates;
+};
+var getSchematicPinPaddingToEdgeTooLargeIssues = (candidates) => candidates.filter((candidate) => exceedsMaxAllowedGap(candidate.measuredPadding, candidate.maxAllowedPadding)).map(createPinPaddingToEdgeIssue);
+var generateSchematicPinPaddingToEdgeTooLargeIssues = (componentPlacements, circuitJson) => getSchematicPinPaddingToEdgeTooLargeIssues(generateSchematicPinPaddingToEdgeCandidates(componentPlacements, circuitJson));
+
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/analyzers/schematic-box-sizing/too-wide.ts
+var getLabelColumn = (side, ports, sourcePortById) => {
+  const labelWidths = ports.filter((port) => port.side_of_component === side).flatMap((port) => port.display_pin_label ? [
+    estimateLabelWidth(port.display_pin_label, sourcePortById.get(port.source_port_id))
+  ] : []);
+  if (labelWidths.length === 0)
+    return null;
+  return {
+    side,
+    labelCount: labelWidths.length,
+    maxLabelWidth: Math.max(...labelWidths)
+  };
+};
+var getInnerLabelEdge = (bounds, labelColumn) => {
+  if (labelColumn.side === "left") {
+    return bounds.left + PIN_LABEL_EDGE_PADDING + labelColumn.maxLabelWidth;
+  }
+  return bounds.right - PIN_LABEL_EDGE_PADDING - labelColumn.maxLabelWidth;
+};
+var getSuggestedWidth = (input) => input.currentWidth - input.measuredInnerLabelHorizontalEmptySpace + input.maxAllowedInnerLabelHorizontalEmptySpace;
+var createPinHeaderIssue = (input) => ({
+  lineItemType: "SchematicBoxTooWideForPinHeader",
+  schematicBox: input.schematicBox,
+  measuredInnerLabelHorizontalEmptySpace: input.measuredInnerLabelHorizontalEmptySpace,
+  maxAllowedInnerLabelHorizontalEmptySpace: PIN_HEADER_SCHEMATIC_BOX_SIZING_MAX_ALLOWED_GAP,
+  suggestedSchWidth: input.suggestedSchWidth,
+  message: SCHEMATIC_BOX_TOO_WIDE_MESSAGE
+});
+var createChipIssue = (input) => ({
+  lineItemType: "SchematicBoxTooWideForChip",
+  schematicBox: input.schematicBox,
+  measuredInnerLabelHorizontalEmptySpace: input.measuredInnerLabelHorizontalEmptySpace,
+  maxAllowedInnerLabelHorizontalEmptySpace: CHIP_SCHEMATIC_BOX_SIZING_MAX_ALLOWED_GAP,
+  suggestedSchWidth: input.suggestedSchWidth,
+  message: SCHEMATIC_BOX_TOO_WIDE_MESSAGE
+});
+var generateSchematicBoxWidthSizingCandidates = (componentPlacements, circuitJson) => {
+  const placementBySchematicComponentId = getPlacementBySchematicComponentId(componentPlacements);
+  const sourcePortById = getSourcePortById(circuitJson);
+  const sourceComponentById = getSourceComponentById(circuitJson);
+  const portsBySchematicComponentId = getPortsBySchematicComponentId(circuitJson, isHorizontalSide);
+  const candidates = [];
+  for (const [schematicComponentId, ports] of portsBySchematicComponentId) {
+    const schematicBox = placementBySchematicComponentId.get(schematicComponentId);
+    if (!schematicBox)
+      continue;
+    const bounds = getCenteredRectBounds(schematicBox);
+    const leftLabelColumn = getLabelColumn("left", ports, sourcePortById);
+    const rightLabelColumn = getLabelColumn("right", ports, sourcePortById);
+    const sourceComponentFtype = getSourceComponentFtype(schematicBox, sourceComponentById);
+    if (leftLabelColumn && rightLabelColumn) {
+      const measuredInnerLabelHorizontalEmptySpace = getInnerLabelEdge(bounds, rightLabelColumn) - getInnerLabelEdge(bounds, leftLabelColumn);
+      candidates.push({
+        schematicBox,
+        sourceComponentFtype,
+        measuredInnerLabelHorizontalEmptySpace
+      });
+      continue;
+    }
+    if (leftLabelColumn && leftLabelColumn.labelCount >= 4) {
+      const measuredInnerLabelHorizontalEmptySpace = bounds.right - getInnerLabelEdge(bounds, leftLabelColumn);
+      candidates.push({
+        schematicBox,
+        sourceComponentFtype,
+        measuredInnerLabelHorizontalEmptySpace
+      });
+    }
+    if (rightLabelColumn && rightLabelColumn.labelCount >= 4) {
+      const measuredInnerLabelHorizontalEmptySpace = getInnerLabelEdge(bounds, rightLabelColumn) - bounds.left;
+      candidates.push({
+        schematicBox,
+        sourceComponentFtype,
+        measuredInnerLabelHorizontalEmptySpace
+      });
+    }
+  }
+  return candidates;
+};
+var getSchematicBoxTooWideForPinHeaderIssues = (candidates) => candidates.filter((candidate) => candidate.sourceComponentFtype === "simple_pin_header").filter((candidate) => exceedsMaxAllowedGap(candidate.measuredInnerLabelHorizontalEmptySpace, PIN_HEADER_SCHEMATIC_BOX_SIZING_MAX_ALLOWED_GAP)).map((candidate) => createPinHeaderIssue({
+  schematicBox: candidate.schematicBox,
+  measuredInnerLabelHorizontalEmptySpace: candidate.measuredInnerLabelHorizontalEmptySpace,
+  suggestedSchWidth: getSuggestedWidth({
+    measuredInnerLabelHorizontalEmptySpace: candidate.measuredInnerLabelHorizontalEmptySpace,
+    maxAllowedInnerLabelHorizontalEmptySpace: PIN_HEADER_SCHEMATIC_BOX_SIZING_MAX_ALLOWED_GAP,
+    currentWidth: candidate.schematicBox.width
+  })
+}));
+var getSchematicBoxTooWideForChipIssues = (candidates) => candidates.filter((candidate) => candidate.sourceComponentFtype === "simple_chip").filter((candidate) => exceedsMaxAllowedGap(candidate.measuredInnerLabelHorizontalEmptySpace, CHIP_SCHEMATIC_BOX_SIZING_MAX_ALLOWED_GAP)).map((candidate) => createChipIssue({
+  schematicBox: candidate.schematicBox,
+  measuredInnerLabelHorizontalEmptySpace: candidate.measuredInnerLabelHorizontalEmptySpace,
+  suggestedSchWidth: getSuggestedWidth({
+    measuredInnerLabelHorizontalEmptySpace: candidate.measuredInnerLabelHorizontalEmptySpace,
+    maxAllowedInnerLabelHorizontalEmptySpace: CHIP_SCHEMATIC_BOX_SIZING_MAX_ALLOWED_GAP,
+    currentWidth: candidate.schematicBox.width
+  })
+}));
+var generateSchematicBoxTooWideForPinHeaderIssues = (componentPlacements, circuitJson) => getSchematicBoxTooWideForPinHeaderIssues(generateSchematicBoxWidthSizingCandidates(componentPlacements, circuitJson));
+var generateSchematicBoxTooWideForChipIssues = (componentPlacements, circuitJson) => getSchematicBoxTooWideForChipIssues(generateSchematicBoxWidthSizingCandidates(componentPlacements, circuitJson));
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/analyzers/schematic-box-overlap.ts
+var getCenteredRectBounds2 = (box2) => {
   const halfWidth = box2.width / 2;
   const halfHeight = box2.height / 2;
   return {
@@ -241272,8 +241578,8 @@ var getCenteredRectBounds = (box2) => {
   };
 };
 var getComponentOverlap = (firstComponent, secondComponent) => {
-  const firstBounds = getCenteredRectBounds(firstComponent);
-  const secondBounds = getCenteredRectBounds(secondComponent);
+  const firstBounds = getCenteredRectBounds2(firstComponent);
+  const secondBounds = getCenteredRectBounds2(secondComponent);
   const left = Math.max(firstBounds.left, secondBounds.left);
   const right = Math.min(firstBounds.right, secondBounds.right);
   const top = Math.max(firstBounds.top, secondBounds.top);
@@ -241339,10 +241645,10 @@ var generateSchematicPlacementIssues = (componentPlacements) => {
   return issues;
 };
 
-// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/verbose-net-label.ts
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/analyzers/verbose-net-label.ts
 var VERBOSE_NET_LABEL_MESSAGE = "Create trace with schDisplayLabel";
 var isSchematicNetLabel = (element) => element.type === "schematic_net_label";
-var isSourcePort = (element) => element.type === "source_port";
+var isSourcePort2 = (element) => element.type === "source_port";
 var getSourceComponentWithName = (element) => {
   if (element.type !== "source_component" || !("source_component_id" in element) || !("name" in element) || typeof element.source_component_id !== "string" || typeof element.name !== "string") {
     return null;
@@ -241369,7 +241675,7 @@ var getLabelTokenToInvolvedPinMap = (circuitJson) => {
     sourceComponent
   ]));
   const tokenToInvolvedPin = new Map;
-  for (const sourcePort of circuitJson.filter(isSourcePort)) {
+  for (const sourcePort of circuitJson.filter(isSourcePort2)) {
     if (!sourcePort.source_component_id)
       continue;
     const sourceComponent = sourceComponentById.get(sourcePort.source_component_id);
@@ -241413,7 +241719,7 @@ var generateVerboseNetLabelIssues = (circuitJson) => {
   return Array.from(issuesByText.values());
 };
 
-// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/analyze-schematic-placement.ts
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/analyzers/analyze-schematic-placement.ts
 var fmtNumber5 = (value) => {
   if (Number.isInteger(value))
     return String(value);
@@ -241424,7 +241730,7 @@ var fmtDelta = (value) => {
   return value > 0 ? `+${formattedValue}` : formattedValue;
 };
 var isSchematicBox = (element) => element.type === "schematic_box";
-var isSchematicComponent2 = (element) => element.type === "schematic_component";
+var isSchematicComponent3 = (element) => element.type === "schematic_component";
 var getSourceComponentName = (circuitJson, sourceComponentId) => {
   if (!sourceComponentId)
     return;
@@ -241519,6 +241825,27 @@ var verboseSchematicNetLabelIssueToString = (issue) => {
   addAttr(attrs, "schY", issue.schY);
   return `<VerboseSchematicNetLabel ${attrs.join(" ")} />`;
 };
+var schematicBoxTooWideIssueToString = (issue) => {
+  const attrs = [];
+  addAttr(attrs, "message", issue.message, { escape: false });
+  addAttr(attrs, "componentName", issue.schematicBox.sourceComponentName);
+  addAttr(attrs, "currentSchWidth", issue.schematicBox.width);
+  addAttr(attrs, "measuredInnerLabelHorizontalEmptySpace", issue.measuredInnerLabelHorizontalEmptySpace);
+  addAttr(attrs, "maxAllowedInnerLabelHorizontalEmptySpace", issue.maxAllowedInnerLabelHorizontalEmptySpace);
+  addAttr(attrs, "suggestedSchWidth", issue.suggestedSchWidth);
+  return `<${issue.lineItemType} ${attrs.join(" ")} />`;
+};
+var schematicPinPaddingToEdgeTooLargeIssueToString = (issue) => {
+  const attrs = [];
+  addAttr(attrs, "message", issue.message, { escape: false });
+  addAttr(attrs, "componentName", issue.schematicBox.sourceComponentName);
+  addAttr(attrs, "pinSide", issue.pinSide);
+  addAttr(attrs, "edgeSide", issue.edgeSide);
+  addAttr(attrs, "pinName", issue.pinName);
+  addAttr(attrs, "measuredPadding", issue.measuredPadding);
+  addAttr(attrs, "maxAllowedPadding", issue.maxAllowedPadding);
+  return `<SchematicPinPaddingToEdgeTooLarge ${attrs.join(" ")} />`;
+};
 var correctionSuggestionToString = (suggestion) => {
   const attrs = [];
   addAttr(attrs, "target", suggestion.targetComponentName);
@@ -241562,6 +241889,11 @@ class SchematicPlacementAnalysis {
               return capacitorSymbolHorizontalIssueToString(issue);
             case "VerboseSchematicNetLabel":
               return verboseSchematicNetLabelIssueToString(issue);
+            case "SchematicBoxTooWideForPinHeader":
+            case "SchematicBoxTooWideForChip":
+              return schematicBoxTooWideIssueToString(issue);
+            case "SchematicPinPaddingToEdgeTooLarge":
+              return schematicPinPaddingToEdgeTooLargeIssueToString(issue);
             default:
               return "";
           }
@@ -241574,15 +241906,18 @@ class SchematicPlacementAnalysis {
 }
 var analyzeSchematicPlacement = (circuitJson) => {
   const schematicBoxes = circuitJson.filter(isSchematicBox);
-  const schematicComponentIds = new Set(circuitJson.filter(isSchematicComponent2).map((schematicComponent) => schematicComponent.schematic_component_id));
+  const schematicComponentIds = new Set(circuitJson.filter(isSchematicComponent3).map((schematicComponent) => schematicComponent.schematic_component_id));
   const lineItems = [
-    ...circuitJson.filter(isSchematicComponent2).map((schematicComponent) => schematicComponentToLineItem(schematicComponent, circuitJson, schematicBoxes.find((schematicBox) => schematicBox.schematic_component_id === schematicComponent.schematic_component_id))),
+    ...circuitJson.filter(isSchematicComponent3).map((schematicComponent) => schematicComponentToLineItem(schematicComponent, circuitJson, schematicBoxes.find((schematicBox) => schematicBox.schematic_component_id === schematicComponent.schematic_component_id))),
     ...schematicBoxes.filter((schematicBox) => !schematicBox.schematic_component_id || !schematicComponentIds.has(schematicBox.schematic_component_id)).map((schematicBox) => schematicBoxToLineItem(schematicBox, circuitJson))
   ];
   const issues = [
     ...generateSchematicPlacementIssues(lineItems),
     ...generateCapacitorOrientationIssues(lineItems, circuitJson),
-    ...generateVerboseNetLabelIssues(circuitJson)
+    ...generateVerboseNetLabelIssues(circuitJson),
+    ...generateSchematicBoxTooWideForPinHeaderIssues(lineItems, circuitJson),
+    ...generateSchematicBoxTooWideForChipIssues(lineItems, circuitJson),
+    ...generateSchematicPinPaddingToEdgeTooLargeIssues(lineItems, circuitJson)
   ];
   return new SchematicPlacementAnalysis([
     ...lineItems,

package/dist/lib/index.js

@@ -65661,7 +65661,7 @@ var getNodeHandler = (winterSpec, { port, middleware = [] }) => {
   }));
 };
 // package.json
-var version = "0.1.1318";
+var version = "0.1.1320";
 var package_default = {
   name: "@tscircuit/cli",
   version,
@@ -65675,7 +65675,7 @@ var package_default = {
     "@biomejs/biome": "^1.9.4",
     "@tscircuit/circuit-json-placement-analysis": "^0.0.6",
     "@tscircuit/circuit-json-routing-analysis": "^0.0.1",
-    "@tscircuit/circuit-json-schematic-placement-analysis": "github:tscircuit/circuit-json-schematic-placement-analysis#c7cfc20927dc5e24414a669e7bcfdecd83504f3e",
+    "@tscircuit/circuit-json-schematic-placement-analysis": "github:tscircuit/circuit-json-schematic-placement-analysis#a8b1e6a5357f8a5aea4881f84ffda7c76d5cfe8e",
     "@tscircuit/fake-snippets": "^0.0.182",
     "@tscircuit/file-server": "^0.0.32",
     "@tscircuit/image-utils": "^0.0.3",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/cli",
-  "version": "0.1.1319",
+  "version": "0.1.1321",
   "main": "dist/cli/main.js",
   "exports": {
     ".": "./dist/cli/main.js",
@@ -11,7 +11,7 @@
     "@biomejs/biome": "^1.9.4",
     "@tscircuit/circuit-json-placement-analysis": "^0.0.6",
     "@tscircuit/circuit-json-routing-analysis": "^0.0.1",
-    "@tscircuit/circuit-json-schematic-placement-analysis": "github:tscircuit/circuit-json-schematic-placement-analysis#c7cfc20927dc5e24414a669e7bcfdecd83504f3e",
+    "@tscircuit/circuit-json-schematic-placement-analysis": "github:tscircuit/circuit-json-schematic-placement-analysis#a8b1e6a5357f8a5aea4881f84ffda7c76d5cfe8e",
     "@tscircuit/fake-snippets": "^0.0.182",
     "@tscircuit/file-server": "^0.0.32",
     "@tscircuit/image-utils": "^0.0.3",