@tscircuit/core 0.0.1281 → 0.0.1282

package/dist/index.js

@@ -3843,7 +3843,7 @@ var Trace_doInitialSchematicTraceRender = (trace) => {
         elbowEdges.push({ from: path[j], to: path[j + 1] });
       }
     }
-    const doesSegmentIntersectRect = (edge, rect) => {
+    const doesSegmentIntersectRect2 = (edge, rect) => {
       const halfW = rect.width / 2;
       const halfH = rect.height / 2;
       const left = rect.center.x - halfW;
@@ -3876,7 +3876,7 @@ var Trace_doInitialSchematicTraceRender = (trace) => {
     };
     for (const edge of elbowEdges) {
       for (const obstacle of obstacles) {
-        if (doesSegmentIntersectRect(edge, obstacle)) {
+        if (doesSegmentIntersectRect2(edge, obstacle)) {
           return null;
         }
       }
@@ -21867,7 +21867,7 @@ import { identity as identity5 } from "transformation-matrix";
 var package_default = {
   name: "@tscircuit/core",
   type: "module",
-  version: "0.0.1280",
+  version: "0.0.1281",
   types: "dist/index.d.ts",
   main: "dist/index.js",
   module: "dist/index.js",
@@ -24866,7 +24866,733 @@ var PcbNoteDimension = class extends PrimitiveComponent2 {
 
 // lib/components/primitive-components/Breakout/Breakout.ts
 import "@tscircuit/props";
-import { BreakoutPointSolver } from "@tscircuit/breakout-point-solver";
+
+// node_modules/@tscircuit/breakout-point-solver/lib/BreakoutPointSolver.ts
+import { BaseSolver } from "@tscircuit/solver-utils";
+
+// node_modules/@tscircuit/breakout-point-solver/lib/boundary/get-breakout-boundary-intersection.ts
+import {
+  distance as distance14,
+  getSegmentIntersection
+} from "@tscircuit/math-utils";
+var getBreakoutBoundaryIntersection = ({
+  from,
+  to,
+  bounds
+}) => {
+  if (from.x === to.x && from.y === to.y) return null;
+  const boundarySegments = [
+    [
+      { x: bounds.minX, y: bounds.minY },
+      { x: bounds.maxX, y: bounds.minY }
+    ],
+    [
+      { x: bounds.maxX, y: bounds.minY },
+      { x: bounds.maxX, y: bounds.maxY }
+    ],
+    [
+      { x: bounds.maxX, y: bounds.maxY },
+      { x: bounds.minX, y: bounds.maxY }
+    ],
+    [
+      { x: bounds.minX, y: bounds.maxY },
+      { x: bounds.minX, y: bounds.minY }
+    ]
+  ];
+  const candidates = boundarySegments.map(([start, end]) => getSegmentIntersection(from, to, start, end)).filter((point6) => point6 !== null);
+  candidates.sort((a, b) => distance14(from, a) - distance14(from, b));
+  return candidates[0] ?? null;
+};
+
+// node_modules/@tscircuit/breakout-point-solver/lib/boundary/get-available-breakout-boundary-point.ts
+import { distance as distance15 } from "@tscircuit/math-utils";
+
+// node_modules/@tscircuit/breakout-point-solver/lib/pad/breakout-pad-collisions.ts
+import {
+  doesSegmentIntersectRect,
+  getBoundFromCenteredRect
+} from "@tscircuit/math-utils";
+var degreesToRadians = (degrees) => degrees * Math.PI / 180;
+var rotatePoint = (point6, radians) => {
+  const cos = Math.cos(radians);
+  const sin = Math.sin(radians);
+  return {
+    x: point6.x * cos - point6.y * sin,
+    y: point6.x * sin + point6.y * cos
+  };
+};
+var getLocalPadPoint = (point6, pad) => {
+  const translatedPoint = {
+    x: point6.x - pad.center.x,
+    y: point6.y - pad.center.y
+  };
+  return rotatePoint(
+    translatedPoint,
+    -degreesToRadians(pad.ccwRotationDegrees ?? 0)
+  );
+};
+var getInflatedPadRect = (pad) => {
+  const clearance = pad.clearance ?? 0;
+  return getBoundFromCenteredRect({
+    center: { x: 0, y: 0 },
+    width: pad.width + clearance * 2,
+    height: pad.height + clearance * 2
+  });
+};
+var isBreakoutPadIgnoredForSourcePort = ({
+  pad,
+  sourcePortId
+}) => {
+  if (!pad.sourcePortIds) return false;
+  return pad.sourcePortIds.includes(sourcePortId);
+};
+var isBreakoutPadIgnoredForLayer = ({
+  pad,
+  layer
+}) => {
+  if (!pad.layer || !layer) return false;
+  return pad.layer !== layer;
+};
+var doesBreakoutSegmentIntersectPad = ({
+  from,
+  to,
+  pad
+}) => doesSegmentIntersectRect(
+  getLocalPadPoint(from, pad),
+  getLocalPadPoint(to, pad),
+  getInflatedPadRect(pad)
+);
+var doesBreakoutSegmentIntersectNonIgnoredPads = ({
+  from,
+  to,
+  pads,
+  ignoredSourcePortIds,
+  layer
+}) => {
+  for (const pad of pads) {
+    if (ignoredSourcePortIds.some(
+      (sourcePortId) => isBreakoutPadIgnoredForSourcePort({
+        pad,
+        sourcePortId
+      })
+    ) || isBreakoutPadIgnoredForLayer({
+      pad,
+      layer
+    })) {
+      continue;
+    }
+    if (doesBreakoutSegmentIntersectPad({ from, to, pad })) {
+      return true;
+    }
+  }
+  return false;
+};
+var doesBreakoutSegmentIntersectPads = ({
+  from,
+  to,
+  pads,
+  sourcePortId,
+  layer
+}) => doesBreakoutSegmentIntersectNonIgnoredPads({
+  from,
+  to,
+  pads,
+  ignoredSourcePortIds: [sourcePortId],
+  layer
+});
+
+// node_modules/@tscircuit/breakout-point-solver/lib/boundary/get-available-breakout-boundary-point.ts
+var BOUNDARY_POINT_DISTANCE_TOLERANCE = 1e-6;
+var isInsideRequiredSpacing = ({
+  candidate,
+  usedPoint,
+  boundaryPointSpacing
+}) => distance15(usedPoint, candidate) < boundaryPointSpacing - BOUNDARY_POINT_DISTANCE_TOLERANCE;
+var getBoundsEdge = (point6, bounds) => {
+  if (Math.abs(point6.x - bounds.minX) < BOUNDARY_POINT_DISTANCE_TOLERANCE)
+    return "left";
+  if (Math.abs(point6.x - bounds.maxX) < BOUNDARY_POINT_DISTANCE_TOLERANCE)
+    return "right";
+  if (Math.abs(point6.y - bounds.minY) < BOUNDARY_POINT_DISTANCE_TOLERANCE)
+    return "bottom";
+  if (Math.abs(point6.y - bounds.maxY) < BOUNDARY_POINT_DISTANCE_TOLERANCE)
+    return "top";
+  return null;
+};
+var getBoundsEdgeCandidates = ({
+  edge,
+  bounds,
+  step
+}) => {
+  const candidates = [];
+  if (edge === "left" || edge === "right") {
+    const x = edge === "left" ? bounds.minX : bounds.maxX;
+    for (let y = bounds.minY; y <= bounds.maxY + step / 2; y += step) {
+      candidates.push({ x, y: Math.min(y, bounds.maxY) });
+    }
+  } else {
+    const y = edge === "bottom" ? bounds.minY : bounds.maxY;
+    for (let x = bounds.minX; x <= bounds.maxX + step / 2; x += step) {
+      candidates.push({ x: Math.min(x, bounds.maxX), y });
+    }
+  }
+  return candidates;
+};
+var getAllBoundsCandidates = ({
+  bounds,
+  step
+}) => {
+  const candidatesByCoordinate = /* @__PURE__ */ new Map();
+  for (const edge of ["left", "right", "bottom", "top"]) {
+    for (const candidate of getBoundsEdgeCandidates({ edge, bounds, step })) {
+      candidatesByCoordinate.set(`${candidate.x}:${candidate.y}`, candidate);
+    }
+  }
+  return [...candidatesByCoordinate.values()];
+};
+var getBoundaryCandidateSearchStep = ({
+  bounds,
+  boundaryPointSpacing
+}) => {
+  if (boundaryPointSpacing > 0) return boundaryPointSpacing;
+  return Math.min(bounds.maxX - bounds.minX, bounds.maxY - bounds.minY) / 40;
+};
+var hasBoundarySpacingConflict = ({
+  candidate,
+  usedBoundaryPoints,
+  boundaryPointSpacing
+}) => {
+  for (const usedPoint of usedBoundaryPoints) {
+    if (isInsideRequiredSpacing({
+      candidate,
+      usedPoint,
+      boundaryPointSpacing
+    })) {
+      return true;
+    }
+  }
+  return false;
+};
+var isBoundaryCandidateBlocked = ({
+  candidate,
+  routeFrom,
+  pads,
+  sourcePortId,
+  layer
+}) => {
+  if (!routeFrom || !pads || !sourcePortId) return false;
+  return doesBreakoutSegmentIntersectPads({
+    from: routeFrom,
+    to: candidate,
+    pads,
+    sourcePortId,
+    layer
+  });
+};
+var isCandidateAvailable = ({
+  candidate,
+  usedBoundaryPoints,
+  boundaryPointSpacing,
+  routeFrom,
+  pads,
+  sourcePortId,
+  layer
+}) => {
+  if (hasBoundarySpacingConflict({
+    candidate,
+    usedBoundaryPoints,
+    boundaryPointSpacing
+  })) {
+    return false;
+  }
+  return !isBoundaryCandidateBlocked({
+    candidate,
+    routeFrom,
+    pads,
+    sourcePortId,
+    layer
+  });
+};
+var hasOutsideAccessConflict = ({
+  candidate,
+  outsidePorts,
+  pads,
+  sourcePortId,
+  layer
+}) => {
+  if (!outsidePorts || !pads || !sourcePortId) return false;
+  for (const outsidePort of outsidePorts) {
+    if (doesBreakoutSegmentIntersectNonIgnoredPads({
+      from: candidate,
+      to: outsidePort.position,
+      pads,
+      ignoredSourcePortIds: [sourcePortId, outsidePort.sourcePortId],
+      layer
+    })) {
+      return true;
+    }
+  }
+  return false;
+};
+var isCandidateAvailableForOutsidePorts = ({
+  candidate,
+  bounds,
+  usedBoundaryPoints,
+  boundaryPointSpacing,
+  routeFrom,
+  pads,
+  sourcePortId,
+  outsidePorts,
+  layer
+}) => {
+  if (!isCandidateAvailable({
+    candidate,
+    usedBoundaryPoints,
+    boundaryPointSpacing,
+    routeFrom,
+    pads,
+    sourcePortId,
+    layer
+  })) {
+    return false;
+  }
+  return !hasOutsideAccessConflict({
+    candidate,
+    outsidePorts,
+    pads,
+    sourcePortId,
+    layer
+  });
+};
+var getAvailableBreakoutBoundaryPoint = ({
+  idealPoint,
+  bounds,
+  usedBoundaryPoints,
+  boundaryPointSpacing,
+  routeFrom,
+  pads,
+  sourcePortId,
+  layer
+}) => {
+  if (isCandidateAvailable({
+    candidate: idealPoint,
+    usedBoundaryPoints,
+    boundaryPointSpacing,
+    routeFrom,
+    pads,
+    sourcePortId,
+    layer
+  })) {
+    return idealPoint;
+  }
+  const edge = getBoundsEdge(idealPoint, bounds);
+  if (!edge) return null;
+  const step = getBoundaryCandidateSearchStep({
+    bounds,
+    boundaryPointSpacing
+  });
+  if (step <= 0) return null;
+  const edgeCandidates = getBoundsEdgeCandidates({
+    edge,
+    bounds,
+    step
+  });
+  edgeCandidates.sort(
+    (a, b) => distance15(a, idealPoint) - distance15(b, idealPoint)
+  );
+  for (const candidate of edgeCandidates) {
+    if (isCandidateAvailable({
+      candidate,
+      usedBoundaryPoints,
+      boundaryPointSpacing,
+      routeFrom,
+      pads,
+      sourcePortId,
+      layer
+    })) {
+      return candidate;
+    }
+  }
+  const candidates = getAllBoundsCandidates({ bounds, step });
+  candidates.sort((a, b) => distance15(a, idealPoint) - distance15(b, idealPoint));
+  for (const candidate of candidates) {
+    if (isCandidateAvailable({
+      candidate,
+      usedBoundaryPoints,
+      boundaryPointSpacing,
+      routeFrom,
+      pads,
+      sourcePortId,
+      layer
+    })) {
+      return candidate;
+    }
+  }
+  return null;
+};
+var getAvailableBreakoutBoundaryPointForOutsidePorts = ({
+  idealPoints,
+  bounds,
+  usedBoundaryPoints,
+  boundaryPointSpacing,
+  routeFrom,
+  pads,
+  sourcePortId,
+  outsidePorts,
+  layer
+}) => {
+  const step = getBoundaryCandidateSearchStep({
+    bounds,
+    boundaryPointSpacing
+  });
+  if (step <= 0) return null;
+  for (const idealPoint of idealPoints) {
+    if (isCandidateAvailableForOutsidePorts({
+      candidate: idealPoint,
+      bounds,
+      usedBoundaryPoints,
+      boundaryPointSpacing,
+      routeFrom,
+      pads,
+      sourcePortId,
+      outsidePorts,
+      layer
+    })) {
+      return idealPoint;
+    }
+    const edge = getBoundsEdge(idealPoint, bounds);
+    if (!edge) continue;
+    const edgeCandidates = getBoundsEdgeCandidates({ edge, bounds, step });
+    edgeCandidates.sort(
+      (a, b) => distance15(a, idealPoint) - distance15(b, idealPoint)
+    );
+    for (const candidate of edgeCandidates) {
+      if (isCandidateAvailableForOutsidePorts({
+        candidate,
+        bounds,
+        usedBoundaryPoints,
+        boundaryPointSpacing,
+        routeFrom,
+        pads,
+        sourcePortId,
+        outsidePorts,
+        layer
+      })) {
+        return candidate;
+      }
+    }
+  }
+  for (const idealPoint of idealPoints) {
+    const candidates = getAllBoundsCandidates({ bounds, step });
+    candidates.sort((a, b) => distance15(a, idealPoint) - distance15(b, idealPoint));
+    for (const candidate of candidates) {
+      if (isCandidateAvailableForOutsidePorts({
+        candidate,
+        bounds,
+        usedBoundaryPoints,
+        boundaryPointSpacing,
+        routeFrom,
+        pads,
+        sourcePortId,
+        outsidePorts,
+        layer
+      })) {
+        return candidate;
+      }
+    }
+  }
+  return null;
+};
+
+// node_modules/@tscircuit/breakout-point-solver/lib/BreakoutPointSolver.ts
+var getLayerVisualStyle = (layer) => {
+  if (layer === "bottom") {
+    return {
+      insidePadFill: "rgba(2, 132, 199, 0.28)",
+      insidePadStroke: "#0369a1",
+      insidePointColor: "#0369a1",
+      outsidePadFill: "rgba(30, 64, 175, 0.2)",
+      outsidePadStroke: "#1e40af",
+      outsidePointColor: "#1e40af",
+      padFill: "rgba(37, 99, 235, 0.18)",
+      padStroke: "#1d4ed8",
+      componentFill: "rgba(245, 158, 11, 0.1)",
+      componentStroke: "#b45309",
+      traceStroke: "#2563eb",
+      breakoutPointColor: "#0f766e"
+    };
+  }
+  return {
+    insidePadFill: "rgba(46, 125, 50, 0.28)",
+    insidePadStroke: "#1b5e20",
+    insidePointColor: "#1b5e20",
+    outsidePadFill: "rgba(106, 27, 154, 0.2)",
+    outsidePadStroke: "#6a1b9a",
+    outsidePointColor: "#6a1b9a",
+    padFill: "rgba(220, 38, 38, 0.22)",
+    padStroke: "#b91c1c",
+    componentFill: "rgba(245, 158, 11, 0.1)",
+    componentStroke: "#b45309",
+    traceStroke: "#7e8794",
+    breakoutPointColor: "#0d47a1"
+  };
+};
+var getPortPadRect = ({
+  port,
+  fill,
+  stroke,
+  fallbackLabel
+}) => {
+  if (port.width === void 0 || port.height === void 0) return null;
+  return {
+    center: port.position,
+    width: port.width,
+    height: port.height,
+    ccwRotationDegrees: port.ccwRotationDegrees,
+    fill,
+    stroke,
+    label: port.label ?? fallbackLabel
+  };
+};
+var getAveragePortPosition = (ports) => {
+  if (ports.length === 0) return null;
+  const total = ports.reduce(
+    (sum, port) => ({
+      x: sum.x + port.position.x,
+      y: sum.y + port.position.y
+    }),
+    { x: 0, y: 0 }
+  );
+  return {
+    x: total.x / ports.length,
+    y: total.y / ports.length
+  };
+};
+var getOutsideTarget = (trace) => getAveragePortPosition(trace.outsidePorts);
+var getInsidePortKey = (port) => `${port.sourcePortId}:${port.layer ?? "top"}`;
+var getOutsidePortsForInsidePort = ({
+  traces,
+  insidePort
+}) => {
+  const outsidePorts = [];
+  const insidePortKey = getInsidePortKey(insidePort);
+  for (const trace of traces) {
+    const hasMatchingInsidePort = trace.insidePorts.some(
+      (port) => getInsidePortKey(port) === insidePortKey
+    );
+    if (!hasMatchingInsidePort) continue;
+    outsidePorts.push(...trace.outsidePorts);
+  }
+  return outsidePorts;
+};
+var getIdealBoundaryPoints = ({
+  insidePort,
+  outsidePorts,
+  bounds
+}) => {
+  const idealBoundaryPoints = [];
+  for (const outsidePort of outsidePorts) {
+    const idealBoundaryPoint = getBreakoutBoundaryIntersection({
+      from: insidePort.position,
+      to: outsidePort.position,
+      bounds
+    });
+    if (idealBoundaryPoint) idealBoundaryPoints.push(idealBoundaryPoint);
+  }
+  return idealBoundaryPoints;
+};
+var BreakoutPointSolver = class extends BaseSolver {
+  input;
+  output = { breakoutPoints: [] };
+  constructor(input) {
+    super();
+    this.input = input;
+  }
+  _step() {
+    const breakoutPoints = [];
+    const boundaryPointsByInsidePort = /* @__PURE__ */ new Map();
+    for (const trace of this.input.traces) {
+      for (const insidePort of trace.insidePorts) {
+        const insidePortKey = getInsidePortKey(insidePort);
+        let boundaryPoint = boundaryPointsByInsidePort.get(insidePortKey) ?? null;
+        if (!boundaryPoint) {
+          const outsidePorts = getOutsidePortsForInsidePort({
+            traces: this.input.traces,
+            insidePort
+          });
+          const idealBoundaryPoints = getIdealBoundaryPoints({
+            insidePort,
+            outsidePorts,
+            bounds: this.input.bounds
+          });
+          if (idealBoundaryPoints.length === 0) continue;
+          const usedBoundaryPoints = [
+            ...this.input.usedBoundaryPoints ?? [],
+            ...boundaryPointsByInsidePort.values()
+          ];
+          if (outsidePorts.length > 1) {
+            boundaryPoint = getAvailableBreakoutBoundaryPointForOutsidePorts({
+              idealPoints: idealBoundaryPoints,
+              bounds: this.input.bounds,
+              usedBoundaryPoints,
+              boundaryPointSpacing: this.input.boundaryPointSpacing ?? 0,
+              routeFrom: insidePort.position,
+              pads: this.input.pads,
+              sourcePortId: insidePort.sourcePortId,
+              outsidePorts,
+              layer: insidePort.layer
+            });
+          }
+          boundaryPoint ??= getAvailableBreakoutBoundaryPoint({
+            idealPoint: idealBoundaryPoints[0],
+            bounds: this.input.bounds,
+            usedBoundaryPoints,
+            boundaryPointSpacing: this.input.boundaryPointSpacing ?? 0,
+            routeFrom: insidePort.position,
+            pads: this.input.pads,
+            sourcePortId: insidePort.sourcePortId,
+            layer: insidePort.layer
+          });
+          if (!boundaryPoint) continue;
+          boundaryPointsByInsidePort.set(insidePortKey, boundaryPoint);
+        }
+        breakoutPoints.push({
+          sourcePortId: insidePort.sourcePortId,
+          sourceTraceId: trace.sourceTraceId,
+          x: boundaryPoint.x,
+          y: boundaryPoint.y,
+          ...insidePort.layer ? { layer: insidePort.layer } : {}
+        });
+      }
+    }
+    this.output = { breakoutPoints };
+    this.solved = true;
+  }
+  getConstructorParams() {
+    return [this.input];
+  }
+  getOutput() {
+    return this.output;
+  }
+  visualize() {
+    const { bounds } = this.input;
+    const width = bounds.maxX - bounds.minX;
+    const height = bounds.maxY - bounds.minY;
+    const center = {
+      x: bounds.minX + width / 2,
+      y: bounds.minY + height / 2
+    };
+    return {
+      title: "BreakoutPointSolver - generated breakout points",
+      rects: [
+        {
+          center,
+          width,
+          height,
+          fill: "rgba(210, 225, 255, 0.25)",
+          stroke: "#315fba",
+          label: "breakout bounds"
+        },
+        ...(this.input.components ?? []).map((component) => ({
+          center: component.center,
+          width: component.width,
+          height: component.height,
+          ccwRotationDegrees: component.ccwRotationDegrees,
+          fill: getLayerVisualStyle(component.layer).componentFill,
+          stroke: getLayerVisualStyle(component.layer).componentStroke,
+          label: component.label ?? "component"
+        })),
+        ...(this.input.pads ?? []).map((pad) => ({
+          center: pad.center,
+          width: pad.width + (pad.clearance ?? 0) * 2,
+          height: pad.height + (pad.clearance ?? 0) * 2,
+          ccwRotationDegrees: pad.ccwRotationDegrees,
+          fill: getLayerVisualStyle(pad.layer).padFill,
+          stroke: getLayerVisualStyle(pad.layer).padStroke,
+          label: pad.label ?? "pad"
+        })),
+        ...this.input.traces.flatMap(
+          (trace) => trace.insidePorts.flatMap((port) => {
+            const rect = getPortPadRect({
+              port,
+              fill: getLayerVisualStyle(port.layer).insidePadFill,
+              stroke: getLayerVisualStyle(port.layer).insidePadStroke,
+              fallbackLabel: `inside pad ${port.sourcePortId}`
+            });
+            return rect ? [rect] : [];
+          })
+        ),
+        ...this.input.traces.flatMap(
+          (trace) => trace.outsidePorts.flatMap((port) => {
+            const rect = getPortPadRect({
+              port,
+              fill: getLayerVisualStyle(port.layer).outsidePadFill,
+              stroke: getLayerVisualStyle(port.layer).outsidePadStroke,
+              fallbackLabel: `outside pad ${port.sourcePortId}`
+            });
+            return rect ? [rect] : [];
+          })
+        )
+      ],
+      lines: this.input.traces.flatMap(
+        (trace) => trace.insidePorts.flatMap((insidePort) => {
+          const outsideTarget = getOutsideTarget(trace);
+          if (!outsideTarget) return [];
+          const breakoutPoint = this.output.breakoutPoints.find(
+            (point6) => point6.sourceTraceId === trace.sourceTraceId && point6.sourcePortId === insidePort.sourcePortId
+          );
+          if (!breakoutPoint) return [];
+          return [
+            {
+              points: [
+                insidePort.position,
+                { x: breakoutPoint.x, y: breakoutPoint.y }
+              ],
+              strokeColor: getLayerVisualStyle(insidePort.layer).traceStroke,
+              label: `breakout segment ${trace.sourceTraceId}`
+            },
+            {
+              points: [
+                { x: breakoutPoint.x, y: breakoutPoint.y },
+                outsideTarget
+              ],
+              strokeColor: getLayerVisualStyle(insidePort.layer).traceStroke,
+              strokeDash: "0.15 0.15",
+              label: `target guide ${trace.sourceTraceId}`
+            }
+          ];
+        })
+      ),
+      points: [
+        ...this.input.traces.flatMap(
+          (trace) => trace.insidePorts.map((port) => ({
+            ...port.position,
+            color: getLayerVisualStyle(port.layer).insidePointColor,
+            label: `inside pad ${port.sourcePortId}`
+          }))
+        ),
+        ...this.input.traces.flatMap(
+          (trace) => trace.outsidePorts.map((port) => ({
+            ...port.position,
+            color: getLayerVisualStyle(port.layer).outsidePointColor,
+            label: `outside target ${port.sourcePortId}`
+          }))
+        ),
+        ...this.output.breakoutPoints.map((point6) => ({
+          x: point6.x,
+          y: point6.y,
+          color: getLayerVisualStyle(point6.layer).breakoutPointColor,
+          label: `selected breakout ${point6.sourcePortId}`
+        })),
+        ...(this.input.usedBoundaryPoints ?? []).map((point6) => ({
+          ...point6,
+          color: "#ef6c00",
+          label: "pre-existing breakout point"
+        }))
+      ]
+    };
+  }
+};
 
 // lib/components/primitive-components/BaseBreakoutPoint.ts
 import { pcbLayoutProps } from "@tscircuit/props";
@@ -25380,7 +26106,7 @@ var NetLabel = class extends PrimitiveComponent2 {
 
 // lib/components/primitive-components/Fiducial.ts
 import "zod";
-import { distance as distance14 } from "circuit-json";
+import { distance as distance16 } from "circuit-json";
 import { fiducialProps } from "@tscircuit/props";
 var Fiducial = class extends PrimitiveComponent2 {
   pcb_smtpad_id = null;
@@ -25405,15 +26131,15 @@ var Fiducial = class extends PrimitiveComponent2 {
       shape: "circle",
       x: position.x,
       y: position.y,
-      radius: distance14.parse(props.padDiameter) / 2,
-      soldermask_margin: props.soldermaskPullback ? distance14.parse(props.soldermaskPullback) : distance14.parse(props.padDiameter) / 2,
+      radius: distance16.parse(props.padDiameter) / 2,
+      soldermask_margin: props.soldermaskPullback ? distance16.parse(props.soldermaskPullback) : distance16.parse(props.padDiameter) / 2,
       is_covered_with_solder_mask: true
     });
     this.pcb_smtpad_id = pcb_smtpad.pcb_smtpad_id;
   }
   getPcbSize() {
     const { _parsedProps: props } = this;
-    const d = distance14.parse(props.padDiameter);
+    const d = distance16.parse(props.padDiameter);
     return { width: d, height: d };
   }
   _setPositionFromLayout(newCenter) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/core",
   "type": "module",
-  "version": "0.0.1281",
+  "version": "0.0.1282",
   "types": "dist/index.d.ts",
   "main": "dist/index.js",
   "module": "dist/index.js",