@tscircuit/core 0.0.1843 → 0.0.1845

package/dist/index.js

@@ -16537,7 +16537,7 @@ import {
   runAllRoutingChecks as runAllRoutingChecks2,
   runAllSchematicChecks
 } from "@tscircuit/checks";
-import { getBoundsFromPoints as getBoundsFromPoints9 } from "@tscircuit/math-utils";
+import { getBoundsFromPoints as getBoundsFromPoints10 } from "@tscircuit/math-utils";
 import { boardProps } from "@tscircuit/props";
 import { compose as compose11, translate as translate11 } from "transformation-matrix";
 
@@ -18166,7 +18166,7 @@ import {
   getRerouteSimpleRouteJson,
   reconnectReroutedSimpleRouteJsonRegion
 } from "@tscircuit/capacity-autorouter";
-import { getBoundsFromPoints as getBoundsFromPoints8 } from "@tscircuit/math-utils";
+import { getBoundsFromPoints as getBoundsFromPoints9 } from "@tscircuit/math-utils";
 import {
   groupProps
 } from "@tscircuit/props";
@@ -34559,7 +34559,14 @@ import {
 } from "@tscircuit/solver-utils";
 
 // node_modules/@tscircuit/implicit-copper-pour-solver/lib/grid-solver.ts
-import { clamp as clamp2, grid } from "@tscircuit/math-utils";
+import {
+  clamp as clamp2,
+  distSq,
+  getBoundsFromPoints as getBoundsFromPoints4,
+  grid,
+  midpoint,
+  pointToSegmentClosestPoint as pointToSegmentClosestPoint2
+} from "@tscircuit/math-utils";
 import { applyToPoint as applyToPoint26, compose as compose8, scale as scale2, translate as translate6 } from "transformation-matrix";
 
 // node_modules/@tscircuit/implicit-copper-pour-solver/lib/geometry.ts
@@ -34680,13 +34687,19 @@ var getClosestPointOnPrimitive = (primitive, point6) => {
     y: clamp(localPoint.y, -primitive.halfHeight, primitive.halfHeight)
   });
 };
-var doesSegmentCrossTrace = (start, end, trace) => {
+var doesSegmentCrossTrace = ({
+  start,
+  end,
+  trace,
+  clearance = 0
+}) => {
+  const blockingRadius = trace.halfWidth + clearance;
   const pathBounds = getBoundsFromPoints3([start, end]);
   const expandedPathBounds = {
-    minX: pathBounds.minX - trace.halfWidth,
-    minY: pathBounds.minY - trace.halfWidth,
-    maxX: pathBounds.maxX + trace.halfWidth,
-    maxY: pathBounds.maxY + trace.halfWidth
+    minX: pathBounds.minX - blockingRadius,
+    minY: pathBounds.minY - blockingRadius,
+    maxX: pathBounds.maxX + blockingRadius,
+    maxY: pathBounds.maxY + blockingRadius
   };
   const traceStart = { x: trace.x1, y: trace.y1 };
   const traceEnd = { x: trace.x2, y: trace.y2 };
@@ -34694,7 +34707,7 @@ var doesSegmentCrossTrace = (start, end, trace) => {
   if (!doBoundsOverlap2(traceBounds, expandedPathBounds)) {
     return false;
   }
-  return segmentToSegmentMinDistance(start, end, traceStart, traceEnd) <= trace.halfWidth;
+  return segmentToSegmentMinDistance(start, end, traceStart, traceEnd) <= blockingRadius;
 };
 var traceLoops = (cells, nx) => {
   const inSet = new Set(cells);
@@ -34742,7 +34755,197 @@ var traceLoops = (cells, nx) => {
 
 // node_modules/@tscircuit/implicit-copper-pour-solver/lib/grid-solver.ts
 var BLOCKED_CELL_LOCAL_REPAIR_RADIUS = 2;
-var normalizeBlockedCellBoundaries = (labeledLayer, insideCells, visibleCells, traceBarriers, gridCells) => {
+var CELL_BOUNDARY_SAMPLE_COUNT = 9;
+var getGridNeighbors = (cell, { nx, ny }) => {
+  const i = cell % nx;
+  const j = Math.floor(cell / nx);
+  const neighbors = [];
+  if (i > 0) neighbors.push(cell - 1);
+  if (i < nx - 1) neighbors.push(cell + 1);
+  if (j > 0) neighbors.push(cell - nx);
+  if (j < ny - 1) neighbors.push(cell + nx);
+  return neighbors;
+};
+var createCanCrossGridEdgeForNet = (netIndex, ctx) => {
+  const crossingCache = new Uint8Array(ctx.labels.length * 2);
+  return (startCell, endCell) => {
+    const edgeIndex = Math.min(startCell, endCell) * 2 + (Math.abs(startCell - endCell) === ctx.nx ? 1 : 0);
+    const cachedCrossing = crossingCache[edgeIndex];
+    if (cachedCrossing !== 0) return cachedCrossing === 1;
+    const start = ctx.gridCells[startCell].center;
+    const end = ctx.gridCells[endCell].center;
+    const boundaryMidpoint = midpoint(start, end);
+    const isHorizontalNeighbor = start.y === end.y;
+    const boundary = isHorizontalNeighbor ? {
+      minX: boundaryMidpoint.x,
+      minY: boundaryMidpoint.y - ctx.gridPitch / 2,
+      maxX: boundaryMidpoint.x,
+      maxY: boundaryMidpoint.y + ctx.gridPitch / 2
+    } : {
+      minX: boundaryMidpoint.x - ctx.gridPitch / 2,
+      minY: boundaryMidpoint.y,
+      maxX: boundaryMidpoint.x + ctx.gridPitch / 2,
+      maxY: boundaryMidpoint.y
+    };
+    let blockedSamples = 0;
+    const allSamplesBlocked = (1 << CELL_BOUNDARY_SAMPLE_COUNT) - 1;
+    for (const trace of ctx.traceBarriers) {
+      if (trace.netIndex === netIndex || trace.maxX < boundary.minX || trace.minX > boundary.maxX || trace.maxY < boundary.minY || trace.minY > boundary.maxY) {
+        continue;
+      }
+      for (let sampleIndex = 0; sampleIndex < CELL_BOUNDARY_SAMPLE_COUNT; sampleIndex++) {
+        const sampleBit = 1 << sampleIndex;
+        if ((blockedSamples & sampleBit) !== 0) continue;
+        const offset = -ctx.gridPitch / 2 + ctx.gridPitch * sampleIndex / (CELL_BOUNDARY_SAMPLE_COUNT - 1);
+        const point6 = isHorizontalNeighbor ? { x: boundaryMidpoint.x, y: boundaryMidpoint.y + offset } : { x: boundaryMidpoint.x + offset, y: boundaryMidpoint.y };
+        const closestTracePoint = pointToSegmentClosestPoint2(
+          point6,
+          trace.start,
+          trace.end
+        );
+        if (distSq(point6, closestTracePoint) <= trace.radiusSquared) {
+          blockedSamples |= sampleBit;
+        }
+      }
+      if (blockedSamples === allSamplesBlocked) {
+        crossingCache[edgeIndex] = 2;
+        return false;
+      }
+    }
+    crossingCache[edgeIndex] = 1;
+    return true;
+  };
+};
+var getCanCrossGridEdgeForNet = (netIndex, ctx) => {
+  let canCrossGridEdge = ctx.canCrossGridEdgeByNetIndex.get(netIndex);
+  if (!canCrossGridEdge) {
+    canCrossGridEdge = createCanCrossGridEdgeForNet(netIndex, ctx);
+    ctx.canCrossGridEdgeByNetIndex.set(netIndex, canCrossGridEdge);
+  }
+  return canCrossGridEdge;
+};
+var normalizeClearanceSeparatedRegions = ({
+  labeledLayer,
+  insideCells,
+  connectivitySeedNetIndices,
+  traceBarriers,
+  gridCells,
+  traceClearance,
+  gridPitch
+}) => {
+  if (traceClearance === 0) return;
+  const { labels, nx, ny } = labeledLayer;
+  const clearanceTraceBarriers = traceBarriers.map(
+    (trace) => {
+      const radius = trace.halfWidth + traceClearance;
+      const start = { x: trace.x1, y: trace.y1 };
+      const end = { x: trace.x2, y: trace.y2 };
+      const centerlineBounds = getBoundsFromPoints4([start, end]);
+      return {
+        netIndex: trace.netIndex,
+        start,
+        end,
+        radiusSquared: radius ** 2,
+        minX: centerlineBounds.minX - radius,
+        minY: centerlineBounds.minY - radius,
+        maxX: centerlineBounds.maxX + radius,
+        maxY: centerlineBounds.maxY + radius
+      };
+    }
+  );
+  const clearanceConnectivityContext = {
+    labels,
+    nx,
+    traceBarriers: clearanceTraceBarriers,
+    gridCells,
+    gridPitch,
+    canCrossGridEdgeByNetIndex: /* @__PURE__ */ new Map()
+  };
+  const reachableCells = new Uint8Array(labels.length);
+  const queue = [];
+  for (let cell = 0; cell < labels.length; cell++) {
+    if (insideCells[cell] !== 1 || connectivitySeedNetIndices[cell] !== labels[cell]) {
+      continue;
+    }
+    reachableCells[cell] = 1;
+    queue.push(cell);
+  }
+  let queueIndex = 0;
+  while (queueIndex < queue.length) {
+    const cell = queue[queueIndex++];
+    const netIndex = labels[cell];
+    for (const neighbor of getGridNeighbors(cell, labeledLayer)) {
+      if (insideCells[neighbor] !== 1 || reachableCells[neighbor] === 1 || labels[neighbor] !== netIndex || !getCanCrossGridEdgeForNet(netIndex, clearanceConnectivityContext)(
+        cell,
+        neighbor
+      )) {
+        continue;
+      }
+      reachableCells[neighbor] = 1;
+      queue.push(neighbor);
+    }
+  }
+  const visitedCells = new Uint8Array(labels.length);
+  const relabels = [];
+  for (let start = 0; start < labels.length; start++) {
+    if (insideCells[start] !== 1 || labels[start] < 0 || reachableCells[start] === 1 || visitedCells[start] === 1) {
+      continue;
+    }
+    const netIndex = labels[start];
+    const component = [];
+    const componentQueue = [start];
+    visitedCells[start] = 1;
+    while (componentQueue.length > 0) {
+      const cell = componentQueue.pop();
+      component.push(cell);
+      for (const neighbor of getGridNeighbors(cell, labeledLayer)) {
+        if (insideCells[neighbor] !== 1 || visitedCells[neighbor] === 1 || reachableCells[neighbor] === 1 || labels[neighbor] !== netIndex || !getCanCrossGridEdgeForNet(netIndex, clearanceConnectivityContext)(
+          cell,
+          neighbor
+        )) {
+          continue;
+        }
+        visitedCells[neighbor] = 1;
+        componentQueue.push(neighbor);
+      }
+    }
+    const sharedEdgesByNetIndex = /* @__PURE__ */ new Map();
+    for (const cell of component) {
+      for (const neighbor of getGridNeighbors(cell, labeledLayer)) {
+        const neighborNetIndex = labels[neighbor];
+        if (reachableCells[neighbor] !== 1 || neighborNetIndex < 0 || neighborNetIndex === netIndex || !getCanCrossGridEdgeForNet(
+          neighborNetIndex,
+          clearanceConnectivityContext
+        )(cell, neighbor)) {
+          continue;
+        }
+        sharedEdgesByNetIndex.set(
+          neighborNetIndex,
+          (sharedEdgesByNetIndex.get(neighborNetIndex) ?? 0) + 1
+        );
+      }
+    }
+    const targetNetIndex = [...sharedEdgesByNetIndex.entries()].sort(
+      (a, b) => b[1] - a[1]
+    )[0]?.[0];
+    if (targetNetIndex !== void 0) {
+      relabels.push({ cells: component, netIndex: targetNetIndex });
+    } else {
+      relabels.push({ cells: component, netIndex: -1 });
+    }
+  }
+  for (const relabel of relabels) {
+    for (const cell of relabel.cells) labels[cell] = relabel.netIndex;
+  }
+};
+var normalizeBlockedCellBoundaries = ({
+  labeledLayer,
+  insideCells,
+  visibleCells,
+  traceBarriers,
+  gridCells,
+  traceClearance
+}) => {
   const { labels, nx, ny } = labeledLayer;
   const netIndices = /* @__PURE__ */ new Set();
   for (let cell = 0; cell < labels.length; cell++) {
@@ -34777,7 +34980,12 @@ var normalizeBlockedCellBoundaries = (labeledLayer, insideCells, visibleCells, t
         }
         const end = gridCells[neighbor].center;
         const isBlocked = traceBarriers.some(
-          (trace) => trace.netIndex !== netIndex && doesSegmentCrossTrace(start, end, trace)
+          (trace) => trace.netIndex !== netIndex && doesSegmentCrossTrace({
+            start,
+            end,
+            trace,
+            clearance: traceClearance
+          })
         );
         if (isBlocked) continue;
         distances[neighbor] = distances[cell] + 1;
@@ -34805,7 +35013,13 @@ var normalizeBlockedCellBoundaries = (labeledLayer, insideCells, visibleCells, t
   }
 };
 var assignGridCells = (problem) => {
-  const { bounds, boardOutline, gridPitch, regionNormalizationArea } = problem;
+  const {
+    bounds,
+    boardOutline,
+    gridPitch,
+    regionNormalizationArea,
+    traceClearance
+  } = problem;
   const nx = Math.max(1, Math.round((bounds.maxX - bounds.minX) / gridPitch));
   const ny = Math.max(1, Math.round((bounds.maxY - bounds.minY) / gridPitch));
   const normalizationMinCells = Math.max(
@@ -34834,6 +35048,8 @@ var assignGridCells = (problem) => {
     const anchoredCells = new Uint8Array(nx * ny);
     const insideCells = new Uint8Array(nx * ny);
     const visibleCells = new Uint8Array(nx * ny);
+    const connectivitySeedNetIndices = new Int32Array(nx * ny).fill(-1);
+    const gridCellHalfDiagonal = gridPitch * Math.SQRT2 / 2;
     for (const { index: cell, center: point6 } of gridCells) {
       if (!isPointInsidePolygon(point6, boardOutline)) continue;
       insideCells[cell] = 1;
@@ -34842,11 +35058,13 @@ var assignGridCells = (problem) => {
         distance: distanceToPrimitive(primitive, point6.x, point6.y)
       })).sort((a, b) => a.distance - b.distance);
       let bestNetIndex = candidates[0]?.primitive.netIndex ?? -1;
+      let bestDistance = candidates[0]?.distance ?? Number.POSITIVE_INFINITY;
       let isAnchored = false;
       let hasVisibleCandidate = false;
       for (const candidate of candidates) {
         if (candidate.distance === 0) {
           bestNetIndex = candidate.primitive.netIndex;
+          bestDistance = candidate.distance;
           isAnchored = true;
           hasVisibleCandidate = true;
           break;
@@ -34856,10 +35074,16 @@ var assignGridCells = (problem) => {
           point6
         );
         const isBlocked = traceBarriers.some(
-          (trace) => trace.netIndex !== candidate.primitive.netIndex && doesSegmentCrossTrace(point6, closestPoint, trace)
+          (trace) => trace.netIndex !== candidate.primitive.netIndex && doesSegmentCrossTrace({
+            start: point6,
+            end: closestPoint,
+            trace,
+            clearance: traceClearance
+          })
         );
         if (!isBlocked) {
           bestNetIndex = candidate.primitive.netIndex;
+          bestDistance = candidate.distance;
           hasVisibleCandidate = true;
           break;
         }
@@ -34867,15 +35091,28 @@ var assignGridCells = (problem) => {
       labels[cell] = bestNetIndex;
       if (isAnchored) anchoredCells[cell] = 1;
       if (hasVisibleCandidate) visibleCells[cell] = 1;
+      if (hasVisibleCandidate && bestDistance <= gridCellHalfDiagonal) {
+        connectivitySeedNetIndices[cell] = bestNetIndex;
+      }
     }
     const labeledLayer = { layer, labels, nx, ny };
-    normalizeBlockedCellBoundaries(
+    normalizeBlockedCellBoundaries({
       labeledLayer,
       insideCells,
       visibleCells,
       traceBarriers,
-      gridCells
-    );
+      gridCells,
+      traceClearance
+    });
+    normalizeClearanceSeparatedRegions({
+      labeledLayer,
+      insideCells,
+      connectivitySeedNetIndices,
+      traceBarriers,
+      gridCells,
+      traceClearance,
+      gridPitch
+    });
     normalizeLabeledLayerRegions(
       labeledLayer,
       anchoredCells,
@@ -35083,7 +35320,7 @@ var getLayerColor = (layer) => layer === "top" ? "#c2453a" : layer === "bottom"
 import { getElementId } from "@tscircuit/circuit-json-util";
 import {
   getBoundFromCenteredRect,
-  getBoundsFromPoints as getBoundsFromPoints4
+  getBoundsFromPoints as getBoundsFromPoints5
 } from "@tscircuit/math-utils";
 import {
   ConnectivityMap as ConnectivityMap2,
@@ -35097,6 +35334,7 @@ import {
   translate as translate7
 } from "transformation-matrix";
 var DEFAULT_GRID_PITCH = 0.25;
+var DEFAULT_TRACE_CLEARANCE = 0.2;
 var DEFAULT_MIN_REGION_AREA = 0;
 var DEFAULT_REGION_NORMALIZATION_AREA = 0.5;
 var getBoardOutline = (board) => {
@@ -35258,10 +35496,14 @@ var addTrace = (primitives, trace, netIndex) => {
 };
 var prepareCircuitJson = (input) => {
   const gridPitch = input.gridPitch ?? DEFAULT_GRID_PITCH;
+  const traceClearance = input.traceClearance ?? DEFAULT_TRACE_CLEARANCE;
   const edgeSimplificationTolerance = input.edgeSimplificationTolerance ?? gridPitch;
   const minRegionArea = input.minRegionArea ?? DEFAULT_MIN_REGION_AREA;
   const regionNormalizationArea = input.regionNormalizationArea ?? DEFAULT_REGION_NORMALIZATION_AREA;
   if (!(gridPitch > 0)) throw new Error("gridPitch must be greater than zero");
+  if (!Number.isFinite(traceClearance) || traceClearance < 0) {
+    throw new Error("traceClearance must be zero or greater");
+  }
   if (!Number.isFinite(edgeSimplificationTolerance) || edgeSimplificationTolerance < 0) {
     throw new Error("edgeSimplificationTolerance must be zero or greater");
   }
@@ -35276,7 +35518,7 @@ var prepareCircuitJson = (input) => {
   );
   if (!board) throw new Error("No pcb_board found in Circuit JSON");
   const boardOutline = getBoardOutline(board);
-  const bounds = getBoundsFromPoints4(boardOutline);
+  const bounds = getBoundsFromPoints5(boardOutline);
   const sourceNets = input.circuitJson.filter(
     (element) => element.type === "source_net"
   );
@@ -35477,6 +35719,7 @@ var prepareCircuitJson = (input) => {
     nets,
     primitives,
     gridPitch,
+    traceClearance,
     minRegionArea,
     regionNormalizationArea,
     coveredWithSolderMask: input.coveredWithSolderMask ?? true
@@ -39069,7 +39312,7 @@ function collectPadElementsByReference(component) {
 }
 
 // lib/components/primitive-components/Group/Group_doInitialPcbComponentAnchorAlignment.ts
-import { getBoundsFromPoints as getBoundsFromPoints5 } from "@tscircuit/math-utils";
+import { getBoundsFromPoints as getBoundsFromPoints6 } from "@tscircuit/math-utils";
 function Group_doInitialPcbComponentAnchorAlignment(group) {
   if (group.root?.pcbDisabled) return;
   if (!group.pcb_group_id) return;
@@ -39085,7 +39328,7 @@ function Group_doInitialPcbComponentAnchorAlignment(group) {
   let height = pcbGroup.height;
   const { center } = pcbGroup;
   if (pcbGroup.outline && pcbGroup.outline.length > 0) {
-    const bounds2 = getBoundsFromPoints5(pcbGroup.outline);
+    const bounds2 = getBoundsFromPoints6(pcbGroup.outline);
     if (bounds2) {
       width = bounds2.maxX - bounds2.minX;
       height = bounds2.maxY - bounds2.minY;
@@ -43849,7 +44092,7 @@ import {
 } from "@tscircuit/math-utils";
 
 // lib/components/primitive-components/Group/Group_doInitialSchematicTraceRender/getSchematicTextBounds.ts
-import { getBoundsFromPoints as getBoundsFromPoints6 } from "@tscircuit/math-utils";
+import { getBoundsFromPoints as getBoundsFromPoints7 } from "@tscircuit/math-utils";
 var DEFAULT_SCHEMATIC_TEXT_FONT_SIZE = 0.18;
 function getSchematicTextBounds(text) {
   const fontSize = text.font_size ?? DEFAULT_SCHEMATIC_TEXT_FONT_SIZE;
@@ -43895,7 +44138,7 @@ function getSchematicTextBounds(text) {
     x: text.position.x + corner.x * cos - corner.y * sin,
     y: text.position.y + corner.x * sin + corner.y * cos
   }));
-  return getBoundsFromPoints6(corners);
+  return getBoundsFromPoints7(corners);
 }
 
 // lib/components/primitive-components/Group/Group_doInitialSchematicTraceRender/schematicTextToTextBounds.ts
@@ -45805,7 +46048,7 @@ var Group_getFanoutPourNetMap = (group, routingPhasePlans) => {
 };
 
 // lib/components/primitive-components/Group/Group_getRoutingPhasePlans.ts
-import { getBoundsFromPoints as getBoundsFromPoints7 } from "@tscircuit/math-utils";
+import { getBoundsFromPoints as getBoundsFromPoints8 } from "@tscircuit/math-utils";
 
 // lib/components/primitive-components/BreakoutPoint.ts
 import { breakoutPointProps } from "@tscircuit/props";
@@ -46177,7 +46420,7 @@ function Group_getRoutingPhasePlans(group) {
       (trace) => !trace.pcb_trace_id
     );
     const pcbGroup = breakout.pcb_group_id ? breakout.root?.db.pcb_group.get(breakout.pcb_group_id) : null;
-    const outlineBounds = pcbGroup?.outline ? getBoundsFromPoints7(pcbGroup.outline) : null;
+    const outlineBounds = pcbGroup?.outline ? getBoundsFromPoints8(pcbGroup.outline) : null;
     const routingWidth = pcbGroup?.width ?? (outlineBounds ? outlineBounds.maxX - outlineBounds.minX : void 0);
     const routingHeight = pcbGroup?.height ?? (outlineBounds ? outlineBounds.maxY - outlineBounds.minY : void 0);
     const routingBounds = pcbGroup && routingWidth && routingHeight ? {
@@ -46263,7 +46506,7 @@ function Group_getRoutingPhasePlans(group) {
 var package_default = {
   name: "@tscircuit/core",
   type: "module",
-  version: "0.0.1842",
+  version: "0.0.1844",
   types: "dist/index.d.ts",
   main: "dist/index.js",
   module: "dist/index.js",
@@ -46298,7 +46541,7 @@ var package_default = {
     "@tscircuit/alphabet": "0.0.25",
     "@tscircuit/bga-fanout-solver": "github:tscircuit/bga-fanout-solver#247c835cb8d69b65e53891dcf869731079415b39",
     "@tscircuit/capacity-autorouter": "^0.0.874",
-    "@tscircuit/checks": "^0.0.182",
+    "@tscircuit/checks": "^0.0.183",
     "@tscircuit/circuit-json-util": "^0.0.106",
     "@tscircuit/common": "^0.0.20",
     "@tscircuit/copper-pour-solver": "^0.0.52",
@@ -46306,7 +46549,7 @@ var package_default = {
     "@tscircuit/fanout-solver": "0.0.57",
     "@tscircuit/footprinter": "^0.0.426",
     "@tscircuit/image-utils": "^0.0.8",
-    "@tscircuit/implicit-copper-pour-solver": "github:tscircuit/implicit-copper-pour-solver#d880f80e4eb7a34d5da5a521f10a63c810d4728b",
+    "@tscircuit/implicit-copper-pour-solver": "github:tscircuit/implicit-copper-pour-solver#a5cbbda0cd65fd4707c5c1af25779837c25aba92",
     "@tscircuit/infer-cable-insertion-point": "^0.0.4",
     "@tscircuit/infgrid-ijump-astar": "^0.0.35",
     "@tscircuit/jlcpcb-manufacturing-specs": "git+https://github.com/tscircuit/jlcpcb-manufacturing-specs#e08af159db01a37db007e33f0a7268d0e4a279a5",
@@ -47760,7 +48003,7 @@ var Group5 = class extends NormalComponent3 {
         x: distance14.parse(point6.x),
         y: distance14.parse(point6.y)
       }));
-      const outlineBounds = getBoundsFromPoints8(numericOutline);
+      const outlineBounds = getBoundsFromPoints9(numericOutline);
       if (!outlineBounds) return;
       const centerX2 = (outlineBounds.minX + outlineBounds.maxX) / 2;
       const centerY2 = (outlineBounds.minY + outlineBounds.maxY) / 2;
@@ -51803,7 +52046,7 @@ var Board = class extends Group5 {
     let width = dbBoard?.width ?? props.width;
     let height = dbBoard?.height ?? props.height;
     if ((width == null || height == null) && props.outline?.length) {
-      const outlineBounds = getBoundsFromPoints9(props.outline);
+      const outlineBounds = getBoundsFromPoints10(props.outline);
       if (outlineBounds) {
         width ??= outlineBounds.maxX - outlineBounds.minX;
         height ??= outlineBounds.maxY - outlineBounds.minY;
@@ -51860,7 +52103,7 @@ var Board = class extends Group5 {
       let width = pcbGroup.width ?? 0;
       let height = pcbGroup.height ?? 0;
       if (pcbGroup.outline && pcbGroup.outline.length > 0) {
-        const bounds = getBoundsFromPoints9(pcbGroup.outline);
+        const bounds = getBoundsFromPoints10(pcbGroup.outline);
         if (bounds) {
           width = bounds.maxX - bounds.minX;
           height = bounds.maxY - bounds.minY;
@@ -52035,7 +52278,7 @@ var Board = class extends Group5 {
     }
     let outlineTranslation = { x: 0, y: 0 };
     if (outline && outline.length > 0 && (this.parent?.lowercaseComponentName === "panel" || this.parent?.lowercaseComponentName === "subpanel")) {
-      const outlineBounds = getBoundsFromPoints9(outline);
+      const outlineBounds = getBoundsFromPoints10(outline);
       if (outlineBounds) {
         const outlineCenterX = (outlineBounds.minX + outlineBounds.maxX) / 2;
         const outlineCenterY = (outlineBounds.minY + outlineBounds.maxY) / 2;
@@ -52212,7 +52455,7 @@ var Board = class extends Group5 {
     if (this.pcb_board_id) {
       db.pcb_board.update(this.pcb_board_id, { center: position });
       if (pcbBoard?.outline) {
-        const outlineBounds = getBoundsFromPoints9(pcbBoard.outline);
+        const outlineBounds = getBoundsFromPoints10(pcbBoard.outline);
         if (outlineBounds) {
           const oldOutlineCenter = {
             x: (outlineBounds.minX + outlineBounds.maxX) / 2,
@@ -52673,14 +52916,14 @@ function generatePanelOutlineRoutingCutouts(boards, options) {
 import { distance as distance17 } from "circuit-json";
 
 // lib/utils/panels/get-board-dimensions-from-props.ts
-import { getBoundsFromPoints as getBoundsFromPoints10 } from "@tscircuit/math-utils";
+import { getBoundsFromPoints as getBoundsFromPoints11 } from "@tscircuit/math-utils";
 import { distance as distance16 } from "circuit-json";
 var getBoardDimensionsFromProps = (board) => {
   const props = board._parsedProps;
   let width = props.width != null ? distance16.parse(props.width) : void 0;
   let height = props.height != null ? distance16.parse(props.height) : void 0;
   if ((width === void 0 || height === void 0) && props.outline?.length) {
-    const outlineBounds = getBoundsFromPoints10(props.outline);
+    const outlineBounds = getBoundsFromPoints11(props.outline);
     if (outlineBounds) {
       width ??= outlineBounds.maxX - outlineBounds.minX;
       height ??= outlineBounds.maxY - outlineBounds.minY;
@@ -54313,7 +54556,7 @@ var getConnectedSchematicPort = ({
   }
   return null;
 };
-var midpoint = (ports) => ({
+var midpoint2 = (ports) => ({
   x: ports.reduce((sum, port) => sum + port.center.x, 0) / ports.length,
   y: ports.reduce((sum, port) => sum + port.center.y, 0) / ports.length
 });
@@ -54388,7 +54631,7 @@ var Ammeter_doInitialSchematicLayout = (ammeter) => {
     })
   ).filter((port) => port !== null);
   if (connectedSchematicPorts.length === 0) return;
-  const baseCenter = midpoint(connectedSchematicPorts);
+  const baseCenter = midpoint2(connectedSchematicPorts);
   const obstacles = db.schematic_component.list().filter(
     (component) => component.schematic_component_id !== schematicComponent.schematic_component_id && !component.is_schematic_group && component.schematic_sheet_id === schematicComponent.schematic_sheet_id
   ).map((component) => rectForComponent(component, PLACEMENT_MARGIN));
@@ -56625,9 +56868,9 @@ var defaultImplicitBreakoutPointSolverFn = (input) => {
 };
 
 // lib/components/primitive-components/Breakout/Breakout_doInitialPcbPlacementDesignRuleChecks.ts
-import { getBoundsFromPoints as getBoundsFromPoints11 } from "@tscircuit/math-utils";
+import { getBoundsFromPoints as getBoundsFromPoints12 } from "@tscircuit/math-utils";
 var getFanoutBounds = (pcbGroup) => {
-  const outlineBounds = pcbGroup.outline ? getBoundsFromPoints11(pcbGroup.outline) : null;
+  const outlineBounds = pcbGroup.outline ? getBoundsFromPoints12(pcbGroup.outline) : null;
   const width = pcbGroup.width ?? (outlineBounds ? outlineBounds.maxX - outlineBounds.minX : void 0);
   const height = pcbGroup.height ?? (outlineBounds ? outlineBounds.maxY - outlineBounds.minY : void 0);
   if (width === void 0 || height === void 0) return null;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/core",
   "type": "module",
-  "version": "0.0.1843",
+  "version": "0.0.1845",
   "types": "dist/index.d.ts",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -36,7 +36,7 @@
     "@tscircuit/alphabet": "0.0.25",
     "@tscircuit/bga-fanout-solver": "github:tscircuit/bga-fanout-solver#247c835cb8d69b65e53891dcf869731079415b39",
     "@tscircuit/capacity-autorouter": "^0.0.874",
-    "@tscircuit/checks": "^0.0.182",
+    "@tscircuit/checks": "^0.0.183",
     "@tscircuit/circuit-json-util": "^0.0.106",
     "@tscircuit/common": "^0.0.20",
     "@tscircuit/copper-pour-solver": "^0.0.52",
@@ -44,7 +44,7 @@
     "@tscircuit/fanout-solver": "0.0.57",
     "@tscircuit/footprinter": "^0.0.426",
     "@tscircuit/image-utils": "^0.0.8",
-    "@tscircuit/implicit-copper-pour-solver": "github:tscircuit/implicit-copper-pour-solver#d880f80e4eb7a34d5da5a521f10a63c810d4728b",
+    "@tscircuit/implicit-copper-pour-solver": "github:tscircuit/implicit-copper-pour-solver#a5cbbda0cd65fd4707c5c1af25779837c25aba92",
     "@tscircuit/infer-cable-insertion-point": "^0.0.4",
     "@tscircuit/infgrid-ijump-astar": "^0.0.35",
     "@tscircuit/jlcpcb-manufacturing-specs": "git+https://github.com/tscircuit/jlcpcb-manufacturing-specs#e08af159db01a37db007e33f0a7268d0e4a279a5",