@tscircuit/core 0.0.1858 → 0.0.1859

package/dist/index.d.ts

@@ -18,6 +18,7 @@ import { FanoutSolver } from '@tscircuit/fanout-solver';
 import { ImplicitCopperPourPipelineSolver } from '@tscircuit/implicit-copper-pour-solver/lib/index';
 import { LayoutPipelineSolver } from '@tscircuit/matchpack';
 import { SchematicTracePipelineSolver } from '@tscircuit/schematic-trace-solver';
+import { ViaStitchSolver } from '@tscircuit/via-stitch-solver';
 import { PackSolver2 } from 'calculate-packing';
 import { Box, Bounds } from '@tscircuit/math-utils';
 import { ConnectivityMap } from 'circuit-json-to-connectivity-map';
@@ -42,6 +43,7 @@ declare const SOLVERS: {
     FanoutSolver: typeof FanoutSolver;
     ImplicitCopperPourPipelineSolver: typeof ImplicitCopperPourPipelineSolver;
     SchematicTracePipelineSolver: typeof SchematicTracePipelineSolver;
+    ViaStitchSolver: typeof ViaStitchSolver;
 };
 type SolverName = keyof typeof SOLVERS;
 
@@ -358,9 +360,9 @@ interface IIsolatedCircuit {
 interface IRootCircuit extends IIsolatedCircuit {
 }
 
-declare const orderedRenderPhases: readonly ["ReactSubtreesRender", "RenderIsolatedSubcircuits", "InflateSubcircuitCircuitJson", "SourceNameDuplicateComponentRemoval", "PcbFootprintStringRender", "FetchPartFootprint", "ResolveFootprintPinLabels", "InitializePortsFromChildren", "CreateNetsFromProps", "AssignFallbackProps", "CreateTracesFromProps", "CreateTracesFromNetLabels", "CreateTraceHintsFromProps", "CreateAutoplacedBreakoutPoints", "SourceGroupRender", "AssignNameToUnnamedComponents", "SourceRender", "CheckRefDesConvention", "SourceComponentPropertyValidation", "SourceParentAttachment", "PortMatching", "OptimizeSelectorCache", "SourceTraceRender", "SourceAddConnectivityMapKey", "SourceDesignRuleChecks", "SimulationRender", "SchematicComponentRender", "SchematicPortRender", "SymbolContainerRender", "SchematicPrimitiveRender", "SchematicSymbolResize", "SchematicComponentSizeCalculation", "SchematicLayout", "SchematicSectionRender", "SchematicTraceRender", "SchematicSheetRender", "SchematicReplaceNetLabelsWithSymbols", "SchematicLabelNetsWithConflictingNames", "PanelBoardLayout", "ValidatePcbCoordinates", "PcbComponentRender", "PcbPrimitiveRender", "PcbFootprintLayout", "PcbPortRender", "PcbPortAttachment", "PcbComponentSizeCalculation", "PcbComponentAnchorAlignment", "PcbCalcPlacementResolution", "PcbLayout", "PcbBoardAutoSize", "PanelLayout", "PcbAutoplaceBreakoutPoints", "PcbTraceHintRender", "PcbManualTraceRender", "PcbPlacementDesignRuleChecks", "PcbTraceRender", "PcbRouteNetIslands", "PcbImplicitCopperPourRender", "PcbCopperPourRender", "PcbDesignRuleChecks", "SilkscreenOverlapAdjustment", "CadModelRender", "PartsEngineRender", "PartOrientationAnalysis", "SupplierFootprintMismatchWarning", "SimulationSpiceEngineRender"];
+declare const orderedRenderPhases: readonly ["ReactSubtreesRender", "RenderIsolatedSubcircuits", "InflateSubcircuitCircuitJson", "SourceNameDuplicateComponentRemoval", "PcbFootprintStringRender", "FetchPartFootprint", "ResolveFootprintPinLabels", "InitializePortsFromChildren", "CreateNetsFromProps", "AssignFallbackProps", "CreateTracesFromProps", "CreateTracesFromNetLabels", "CreateTraceHintsFromProps", "CreateAutoplacedBreakoutPoints", "SourceGroupRender", "AssignNameToUnnamedComponents", "SourceRender", "CheckRefDesConvention", "SourceComponentPropertyValidation", "SourceParentAttachment", "PortMatching", "OptimizeSelectorCache", "SourceTraceRender", "SourceAddConnectivityMapKey", "SourceDesignRuleChecks", "SimulationRender", "SchematicComponentRender", "SchematicPortRender", "SymbolContainerRender", "SchematicPrimitiveRender", "SchematicSymbolResize", "SchematicComponentSizeCalculation", "SchematicLayout", "SchematicSectionRender", "SchematicTraceRender", "SchematicSheetRender", "SchematicReplaceNetLabelsWithSymbols", "SchematicLabelNetsWithConflictingNames", "PanelBoardLayout", "ValidatePcbCoordinates", "PcbComponentRender", "PcbPrimitiveRender", "PcbFootprintLayout", "PcbPortRender", "PcbPortAttachment", "PcbComponentSizeCalculation", "PcbComponentAnchorAlignment", "PcbCalcPlacementResolution", "PcbLayout", "PcbBoardAutoSize", "PanelLayout", "PcbAutoplaceBreakoutPoints", "PcbTraceHintRender", "PcbManualTraceRender", "PcbPlacementDesignRuleChecks", "PcbTraceRender", "PcbRouteNetIslands", "PcbImplicitCopperPourRender", "PcbCopperPourRender", "PcbViaStitchRender", "PcbDesignRuleChecks", "SilkscreenOverlapAdjustment", "CadModelRender", "PartsEngineRender", "PartOrientationAnalysis", "SupplierFootprintMismatchWarning", "SimulationSpiceEngineRender"];
 type RenderPhase = (typeof orderedRenderPhases)[number];
-declare const renderPhaseIndexMap: Map<"ReactSubtreesRender" | "RenderIsolatedSubcircuits" | "InflateSubcircuitCircuitJson" | "SourceNameDuplicateComponentRemoval" | "PcbFootprintStringRender" | "FetchPartFootprint" | "ResolveFootprintPinLabels" | "InitializePortsFromChildren" | "CreateNetsFromProps" | "AssignFallbackProps" | "CreateTracesFromProps" | "CreateTracesFromNetLabels" | "CreateTraceHintsFromProps" | "CreateAutoplacedBreakoutPoints" | "SourceGroupRender" | "AssignNameToUnnamedComponents" | "SourceRender" | "CheckRefDesConvention" | "SourceComponentPropertyValidation" | "SourceParentAttachment" | "PortMatching" | "OptimizeSelectorCache" | "SourceTraceRender" | "SourceAddConnectivityMapKey" | "SourceDesignRuleChecks" | "SimulationRender" | "SchematicComponentRender" | "SchematicPortRender" | "SymbolContainerRender" | "SchematicPrimitiveRender" | "SchematicSymbolResize" | "SchematicComponentSizeCalculation" | "SchematicLayout" | "SchematicSectionRender" | "SchematicTraceRender" | "SchematicSheetRender" | "SchematicReplaceNetLabelsWithSymbols" | "SchematicLabelNetsWithConflictingNames" | "PanelBoardLayout" | "ValidatePcbCoordinates" | "PcbComponentRender" | "PcbPrimitiveRender" | "PcbFootprintLayout" | "PcbPortRender" | "PcbPortAttachment" | "PcbComponentSizeCalculation" | "PcbComponentAnchorAlignment" | "PcbCalcPlacementResolution" | "PcbLayout" | "PcbBoardAutoSize" | "PanelLayout" | "PcbAutoplaceBreakoutPoints" | "PcbTraceHintRender" | "PcbManualTraceRender" | "PcbPlacementDesignRuleChecks" | "PcbTraceRender" | "PcbRouteNetIslands" | "PcbImplicitCopperPourRender" | "PcbCopperPourRender" | "PcbDesignRuleChecks" | "SilkscreenOverlapAdjustment" | "CadModelRender" | "PartsEngineRender" | "PartOrientationAnalysis" | "SupplierFootprintMismatchWarning" | "SimulationSpiceEngineRender", number>;
+declare const renderPhaseIndexMap: Map<"ReactSubtreesRender" | "RenderIsolatedSubcircuits" | "InflateSubcircuitCircuitJson" | "SourceNameDuplicateComponentRemoval" | "PcbFootprintStringRender" | "FetchPartFootprint" | "ResolveFootprintPinLabels" | "InitializePortsFromChildren" | "CreateNetsFromProps" | "AssignFallbackProps" | "CreateTracesFromProps" | "CreateTracesFromNetLabels" | "CreateTraceHintsFromProps" | "CreateAutoplacedBreakoutPoints" | "SourceGroupRender" | "AssignNameToUnnamedComponents" | "SourceRender" | "CheckRefDesConvention" | "SourceComponentPropertyValidation" | "SourceParentAttachment" | "PortMatching" | "OptimizeSelectorCache" | "SourceTraceRender" | "SourceAddConnectivityMapKey" | "SourceDesignRuleChecks" | "SimulationRender" | "SchematicComponentRender" | "SchematicPortRender" | "SymbolContainerRender" | "SchematicPrimitiveRender" | "SchematicSymbolResize" | "SchematicComponentSizeCalculation" | "SchematicLayout" | "SchematicSectionRender" | "SchematicTraceRender" | "SchematicSheetRender" | "SchematicReplaceNetLabelsWithSymbols" | "SchematicLabelNetsWithConflictingNames" | "PanelBoardLayout" | "ValidatePcbCoordinates" | "PcbComponentRender" | "PcbPrimitiveRender" | "PcbFootprintLayout" | "PcbPortRender" | "PcbPortAttachment" | "PcbComponentSizeCalculation" | "PcbComponentAnchorAlignment" | "PcbCalcPlacementResolution" | "PcbLayout" | "PcbBoardAutoSize" | "PanelLayout" | "PcbAutoplaceBreakoutPoints" | "PcbTraceHintRender" | "PcbManualTraceRender" | "PcbPlacementDesignRuleChecks" | "PcbTraceRender" | "PcbRouteNetIslands" | "PcbImplicitCopperPourRender" | "PcbCopperPourRender" | "PcbViaStitchRender" | "PcbDesignRuleChecks" | "SilkscreenOverlapAdjustment" | "CadModelRender" | "PartsEngineRender" | "PartOrientationAnalysis" | "SupplierFootprintMismatchWarning" | "SimulationSpiceEngineRender", number>;
 type RenderPhaseFn<K extends RenderPhase = RenderPhase> = `doInitial${K}` | `update${K}` | `remove${K}`;
 type RenderPhaseStates = Record<RenderPhase, {
     initialized: boolean;
@@ -522,6 +524,8 @@ declare class IsolatedCircuit {
     pcbDisabled: boolean;
     pcbRoutingDisabled: boolean;
     _featureMspSchematicTraceRouting: boolean;
+    /** Experimental automatic via stitching; opt in before rendering. */
+    _featurePcbViaStitching: boolean;
     /**
      * The IsolatedCircuit name is usually set by the platform, it's not required but
      * if supplied can identify the circuit in certain effects, e.g. it is passed
@@ -107902,6 +107906,7 @@ declare class CopperPour extends PrimitiveComponent<typeof copperPourProps> {
     };
     doInitialCreateNetsFromProps(): void;
     doInitialPcbCopperPourRender(): void;
+    doInitialPcbViaStitchRender(): void;
 }
 
 declare class CopperText extends PrimitiveComponent<typeof copperTextProps> {

package/dist/index.js

@@ -452,6 +452,7 @@ var orderedRenderPhases = [
   "PcbRouteNetIslands",
   "PcbImplicitCopperPourRender",
   "PcbCopperPourRender",
+  "PcbViaStitchRender",
   "PcbDesignRuleChecks",
   "SilkscreenOverlapAdjustment",
   "CadModelRender",
@@ -513,6 +514,15 @@ var asyncPhaseDependencies = {
     "PcbTraceRender",
     "PcbRouteNetIslands"
   ],
+  PcbViaStitchRender: [
+    "PcbFootprintStringRender",
+    "FetchPartFootprint",
+    "PcbPlacementDesignRuleChecks",
+    "PcbTraceRender",
+    "PcbRouteNetIslands",
+    "PcbImplicitCopperPourRender",
+    "PcbCopperPourRender"
+  ],
   PcbPlacementDesignRuleChecks: [
     "PcbFootprintStringRender",
     "FetchPartFootprint"
@@ -529,7 +539,8 @@ var asyncPhaseDependencies = {
     "PcbPlacementDesignRuleChecks",
     "PcbTraceRender",
     "PcbImplicitCopperPourRender",
-    "PcbCopperPourRender"
+    "PcbCopperPourRender",
+    "PcbViaStitchRender"
   ],
   SilkscreenOverlapAdjustment: [
     "PcbFootprintStringRender",
@@ -40819,6 +40830,480 @@ var ImplicitCopperPourPipelineSolver = class extends BasePipelineSolver {
 // lib/solvers.ts
 import { LayoutPipelineSolver } from "@tscircuit/matchpack";
 import { SchematicTracePipelineSolver } from "@tscircuit/schematic-trace-solver";
+
+// node_modules/@tscircuit/via-stitch-solver/lib/solvers/ViaStitchSolver.ts
+import { BaseSolver as BaseSolver3 } from "@tscircuit/solver-utils";
+
+// node_modules/@tscircuit/via-stitch-solver/lib/geometry/brep-point-containment.ts
+var POINT_EPSILON = 1e-8;
+var isPointOnSegment = (point6, start, end) => {
+  const cross3 = (point6.y - start.y) * (end.x - start.x) - (point6.x - start.x) * (end.y - start.y);
+  if (Math.abs(cross3) > POINT_EPSILON) return false;
+  const dot = (point6.x - start.x) * (end.x - start.x) + (point6.y - start.y) * (end.y - start.y);
+  if (dot < -POINT_EPSILON) return false;
+  const squaredLength = (end.x - start.x) ** 2 + (end.y - start.y) ** 2;
+  return dot <= squaredLength + POINT_EPSILON;
+};
+var isPointInRing = (point6, ring) => {
+  let isInside = false;
+  for (let currentIndex = 0, previousIndex = ring.vertices.length - 1; currentIndex < ring.vertices.length; previousIndex = currentIndex++) {
+    const current = ring.vertices[currentIndex];
+    const previous = ring.vertices[previousIndex];
+    if (isPointOnSegment(point6, previous, current)) return true;
+    const crossesRay = current.y > point6.y !== previous.y > point6.y && point6.x < (previous.x - current.x) * (point6.y - current.y) / (previous.y - current.y) + current.x;
+    if (crossesRay) isInside = !isInside;
+  }
+  return isInside;
+};
+var isPointInShape = (point6, shape) => isPointInRing(point6, shape.outer_ring) && !shape.inner_rings.some((innerRing) => isPointInRing(point6, innerRing));
+var isPointInShapeUnion = (point6, shapes) => shapes.some((shape) => isPointInShape(point6, shape));
+var getShapeUnionBounds = (shapes) => {
+  const vertices = shapes.flatMap((shape) => shape.outer_ring.vertices);
+  if (vertices.length === 0) return void 0;
+  return {
+    minX: Math.min(...vertices.map((vertex) => vertex.x)),
+    maxX: Math.max(...vertices.map((vertex) => vertex.x)),
+    minY: Math.min(...vertices.map((vertex) => vertex.y)),
+    maxY: Math.max(...vertices.map((vertex) => vertex.y))
+  };
+};
+var isViaAnnulusInsideShapeUnion = ({
+  center,
+  radius,
+  shapes
+}) => {
+  const samplePoints = [center];
+  for (let sampleIndex = 0; sampleIndex < 32; sampleIndex++) {
+    const angle = sampleIndex / 32 * Math.PI * 2;
+    samplePoints.push({
+      x: center.x + Math.cos(angle) * radius,
+      y: center.y + Math.sin(angle) * radius
+    });
+  }
+  return samplePoints.every(
+    (samplePoint) => isPointInShapeUnion(samplePoint, shapes)
+  );
+};
+
+// node_modules/@tscircuit/via-stitch-solver/lib/geometry/circuit-element-obstacles.ts
+var layerMatches = (layer, layers) => layers.some((candidateLayer) => String(candidateLayer) === String(layer));
+var componentToObstacle = (component) => {
+  if (component.do_not_place || !component.obstructs_within_bounds) {
+    return void 0;
+  }
+  return {
+    kind: "rect",
+    center: component.center,
+    width: component.width,
+    height: component.height,
+    ccwRotation: component.rotation
+  };
+};
+var smtPadToObstacle = (smtPad) => {
+  if (smtPad.shape === "circle") {
+    return {
+      kind: "circle",
+      center: { x: smtPad.x, y: smtPad.y },
+      radius: smtPad.radius
+    };
+  }
+  if (smtPad.shape === "polygon") {
+    return { kind: "polygon", points: smtPad.points };
+  }
+  return {
+    kind: "rect",
+    center: { x: smtPad.x, y: smtPad.y },
+    width: smtPad.width,
+    height: smtPad.height,
+    ccwRotation: smtPad.shape === "rotated_rect" || smtPad.shape === "rotated_pill" ? smtPad.ccw_rotation : 0
+  };
+};
+var platedHoleToObstacle = (platedHole) => {
+  if (platedHole.shape === "circle") {
+    return {
+      kind: "circle",
+      center: { x: platedHole.x, y: platedHole.y },
+      radius: platedHole.outer_diameter / 2
+    };
+  }
+  if ("outer_width" in platedHole) {
+    return {
+      kind: "rect",
+      center: { x: platedHole.x, y: platedHole.y },
+      width: platedHole.outer_width,
+      height: platedHole.outer_height,
+      ccwRotation: platedHole.ccw_rotation
+    };
+  }
+  if (platedHole.shape === "hole_with_polygon_pad") {
+    const rotationRadians = (platedHole.ccw_rotation ?? 0) * Math.PI / 180;
+    const cosine = Math.cos(rotationRadians);
+    const sine = Math.sin(rotationRadians);
+    return {
+      kind: "polygon",
+      points: platedHole.pad_outline.map((point6) => ({
+        x: platedHole.x + point6.x * cosine - point6.y * sine,
+        y: platedHole.y + point6.x * sine + point6.y * cosine
+      }))
+    };
+  }
+  return {
+    kind: "rect",
+    center: { x: platedHole.x, y: platedHole.y },
+    width: platedHole.rect_pad_width,
+    height: platedHole.rect_pad_height,
+    ccwRotation: "rect_ccw_rotation" in platedHole ? platedHole.rect_ccw_rotation ?? 0 : 0
+  };
+};
+var holeToObstacle = (hole) => {
+  if ("hole_diameter" in hole) {
+    if (hole.hole_shape === "circle") {
+      return {
+        kind: "circle",
+        center: { x: hole.x, y: hole.y },
+        radius: hole.hole_diameter / 2
+      };
+    }
+    return {
+      kind: "rect",
+      center: { x: hole.x, y: hole.y },
+      width: hole.hole_diameter,
+      height: hole.hole_diameter,
+      ccwRotation: 0
+    };
+  }
+  return {
+    kind: "rect",
+    center: { x: hole.x, y: hole.y },
+    width: hole.hole_width,
+    height: hole.hole_height,
+    ccwRotation: hole.hole_shape === "rotated_pill" ? hole.ccw_rotation : 0
+  };
+};
+var getDistanceToSegment = (point6, start, end) => {
+  const segmentX = end.x - start.x;
+  const segmentY = end.y - start.y;
+  const squaredLength = segmentX ** 2 + segmentY ** 2;
+  if (squaredLength === 0)
+    return Math.hypot(point6.x - start.x, point6.y - start.y);
+  const projection = Math.max(
+    0,
+    Math.min(
+      1,
+      ((point6.x - start.x) * segmentX + (point6.y - start.y) * segmentY) / squaredLength
+    )
+  );
+  return Math.hypot(
+    point6.x - (start.x + projection * segmentX),
+    point6.y - (start.y + projection * segmentY)
+  );
+};
+var isPointInPolygon = (point6, polygon) => {
+  let isInside = false;
+  for (let currentIndex = 0, previousIndex = polygon.length - 1; currentIndex < polygon.length; previousIndex = currentIndex++) {
+    const current = polygon[currentIndex];
+    const previous = polygon[previousIndex];
+    const crossesRay = current.y > point6.y !== previous.y > point6.y && point6.x < (previous.x - current.x) * (point6.y - current.y) / (previous.y - current.y) + current.x;
+    if (crossesRay) isInside = !isInside;
+  }
+  return isInside;
+};
+var doesCircleIntersectObstacle = (center, radius, obstacle) => {
+  if (obstacle.kind === "circle") {
+    return Math.hypot(center.x - obstacle.center.x, center.y - obstacle.center.y) < radius + obstacle.radius;
+  }
+  if (obstacle.kind === "polygon") {
+    if (isPointInPolygon(center, obstacle.points)) return true;
+    return obstacle.points.some(
+      (point6, pointIndex) => Boolean(
+        getDistanceToSegment(
+          center,
+          point6,
+          obstacle.points[(pointIndex + 1) % obstacle.points.length]
+        ) < radius
+      )
+    );
+  }
+  const rotationRadians = -obstacle.ccwRotation * Math.PI / 180;
+  const deltaX = center.x - obstacle.center.x;
+  const deltaY = center.y - obstacle.center.y;
+  const localX = deltaX * Math.cos(rotationRadians) - deltaY * Math.sin(rotationRadians);
+  const localY = deltaX * Math.sin(rotationRadians) + deltaY * Math.cos(rotationRadians);
+  const outsideX = Math.max(Math.abs(localX) - obstacle.width / 2, 0);
+  const outsideY = Math.max(Math.abs(localY) - obstacle.height / 2, 0);
+  return Math.hypot(outsideX, outsideY) < radius;
+};
+var getStitchingObstacles = (circuitJson, layers) => circuitJson.flatMap((element) => {
+  if (element.type === "pcb_component" && layerMatches(element.layer, layers)) {
+    const obstacle = componentToObstacle(element);
+    return obstacle ? [obstacle] : [];
+  }
+  if (element.type === "pcb_smtpad" && layerMatches(element.layer, layers)) {
+    return [smtPadToObstacle(element)];
+  }
+  if (element.type === "pcb_plated_hole" && element.layers.some((layer) => layerMatches(layer, layers))) {
+    return [platedHoleToObstacle(element)];
+  }
+  if (element.type === "pcb_hole") return [holeToObstacle(element)];
+  return [];
+});
+var doesViaIntersectStitchingObstacle = ({
+  center,
+  radius,
+  obstacles
+}) => obstacles.some(
+  (obstacle) => doesCircleIntersectObstacle(center, radius, obstacle)
+);
+
+// node_modules/@tscircuit/via-stitch-solver/lib/solvers/ViaStitchSolver.ts
+var resolveOptions = (options = {}) => {
+  const resolvedOptions = {
+    sourceNetIds: options.sourceNetIds ? new Set(options.sourceNetIds) : void 0,
+    layers: options.layers ?? ["top", "bottom"],
+    viaPitch: options.viaPitch ?? 1,
+    viaHoleDiameter: options.viaHoleDiameter ?? 0.3,
+    viaOuterDiameter: options.viaOuterDiameter ?? 0.6,
+    pourEdgeClearance: options.pourEdgeClearance ?? 0.2,
+    obstacleClearance: options.obstacleClearance ?? 0.2,
+    minimumViaSeparation: options.minimumViaSeparation ?? Math.max(options.viaOuterDiameter ?? 0.6, 0.8),
+    gridOrigin: options.gridOrigin ?? { x: 0, y: 0 },
+    isTented: options.isTented ?? true
+  };
+  for (const [optionName, optionValue] of [
+    ["viaPitch", resolvedOptions.viaPitch],
+    ["viaHoleDiameter", resolvedOptions.viaHoleDiameter],
+    ["viaOuterDiameter", resolvedOptions.viaOuterDiameter],
+    ["minimumViaSeparation", resolvedOptions.minimumViaSeparation]
+  ]) {
+    if (!Number.isFinite(optionValue) || optionValue <= 0) {
+      throw new Error(`${optionName} must be a finite number greater than zero`);
+    }
+  }
+  if (!Number.isFinite(resolvedOptions.pourEdgeClearance) || resolvedOptions.pourEdgeClearance < 0) {
+    throw new Error("pourEdgeClearance must be a finite non-negative number");
+  }
+  if (!Number.isFinite(resolvedOptions.obstacleClearance) || resolvedOptions.obstacleClearance < 0) {
+    throw new Error("obstacleClearance must be a finite non-negative number");
+  }
+  if (!Number.isFinite(resolvedOptions.gridOrigin.x) || !Number.isFinite(resolvedOptions.gridOrigin.y)) {
+    throw new Error("gridOrigin coordinates must be finite numbers");
+  }
+  if (resolvedOptions.viaHoleDiameter >= resolvedOptions.viaOuterDiameter) {
+    throw new Error("viaHoleDiameter must be smaller than viaOuterDiameter");
+  }
+  if (String(resolvedOptions.layers[0]) === String(resolvedOptions.layers[1])) {
+    throw new Error("layers must contain two distinct PCB layers");
+  }
+  return resolvedOptions;
+};
+var isBrepCopperPour = (element) => element.type === "pcb_copper_pour" && element.shape === "brep";
+var getCopperPourPairContexts = (input, options) => {
+  const sourceNetsById = new Map(
+    input.circuitJson.filter((element) => element.type === "source_net").map((sourceNet) => [sourceNet.source_net_id, sourceNet])
+  );
+  const poursBySourceNetId = /* @__PURE__ */ new Map();
+  for (const element of input.circuitJson) {
+    if (!isBrepCopperPour(element) || !element.source_net_id) continue;
+    if (options.sourceNetIds && !options.sourceNetIds.has(element.source_net_id)) {
+      continue;
+    }
+    const sourceNetPours = poursBySourceNetId.get(element.source_net_id) ?? [];
+    sourceNetPours.push(element);
+    poursBySourceNetId.set(element.source_net_id, sourceNetPours);
+  }
+  const [fromLayer, toLayer] = options.layers;
+  const contexts = [];
+  for (const [sourceNetId, sourceNetPours] of poursBySourceNetId) {
+    const fromLayerPours = sourceNetPours.filter(
+      (copperPour) => String(copperPour.layer) === String(fromLayer)
+    );
+    const toLayerPours = sourceNetPours.filter(
+      (copperPour) => String(copperPour.layer) === String(toLayer)
+    );
+    if (fromLayerPours.length === 0 || toLayerPours.length === 0) continue;
+    contexts.push({
+      sourceNetId,
+      sourceNet: sourceNetsById.get(sourceNetId),
+      fromLayerPours,
+      toLayerPours
+    });
+  }
+  return contexts;
+};
+var getPcbTraceViaRadius = (routePoint, fallbackRadius) => {
+  const routePointWithDiameter = routePoint;
+  return (routePointWithDiameter.outer_diameter ?? fallbackRadius * 2) / 2;
+};
+var isTooCloseToOccupiedVia = ({
+  center,
+  radius,
+  occupiedVias,
+  minimumViaSeparation
+}) => occupiedVias.some(
+  (occupiedVia) => Math.hypot(
+    center.x - occupiedVia.center.x,
+    center.y - occupiedVia.center.y
+  ) < Math.max(minimumViaSeparation, radius + occupiedVia.radius)
+);
+var getGridCoordinates = ({
+  minimum,
+  maximum,
+  origin,
+  pitch
+}) => {
+  const coordinates = [];
+  const firstGridIndex = Math.ceil((minimum - origin) / pitch);
+  const lastGridIndex = Math.floor((maximum - origin) / pitch);
+  for (let gridIndex = firstGridIndex; gridIndex <= lastGridIndex; gridIndex++) {
+    coordinates.push(origin + gridIndex * pitch);
+  }
+  return coordinates;
+};
+var ViaStitchSolver = class extends BaseSolver3 {
+  constructor(input) {
+    super();
+    this.input = input;
+    this.options = resolveOptions(input.options);
+    this.copperPourPairContexts = getCopperPourPairContexts(input, this.options);
+    this.stitchingObstacles = getStitchingObstacles(
+      input.circuitJson,
+      this.options.layers
+    );
+    const fallbackViaRadius = this.options.viaOuterDiameter / 2;
+    for (const element of input.circuitJson) {
+      if (element.type === "pcb_via") {
+        const pcbVia = element;
+        this.existingPcbViaIds.add(pcbVia.pcb_via_id);
+        this.occupiedVias.push({
+          center: { x: pcbVia.x, y: pcbVia.y },
+          radius: pcbVia.outer_diameter / 2
+        });
+      } else if (element.type === "pcb_trace") {
+        for (const routePoint of element.route) {
+          if (routePoint.route_type !== "via") continue;
+          this.occupiedVias.push({
+            center: { x: routePoint.x, y: routePoint.y },
+            radius: getPcbTraceViaRadius(routePoint, fallbackViaRadius)
+          });
+        }
+      }
+    }
+  }
+  input;
+  options;
+  copperPourPairContexts;
+  pcbVias = [];
+  occupiedVias = [];
+  existingPcbViaIds = /* @__PURE__ */ new Set();
+  stitchingObstacles;
+  nextCopperPourPairIndex = 0;
+  nextViaId = 0;
+  _step() {
+    const copperPourPairContext = this.copperPourPairContexts[this.nextCopperPourPairIndex];
+    if (!copperPourPairContext) {
+      this.solved = true;
+      this.progress = 1;
+      return;
+    }
+    this.processCopperPourPair(copperPourPairContext);
+    this.nextCopperPourPairIndex += 1;
+    this.progress = this.copperPourPairContexts.length === 0 ? 1 : this.nextCopperPourPairIndex / this.copperPourPairContexts.length;
+    this.solved = this.nextCopperPourPairIndex === this.copperPourPairContexts.length;
+  }
+  processCopperPourPair(context) {
+    const [fromLayer, toLayer] = this.options.layers;
+    const fromLayerShapes = context.fromLayerPours.map(
+      (copperPour) => copperPour.brep_shape
+    );
+    const toLayerShapes = context.toLayerPours.map(
+      (copperPour) => copperPour.brep_shape
+    );
+    const fromBounds = getShapeUnionBounds(fromLayerShapes);
+    const toBounds = getShapeUnionBounds(toLayerShapes);
+    if (!fromBounds || !toBounds) return;
+    const overlapBounds = {
+      minX: Math.max(fromBounds.minX, toBounds.minX),
+      maxX: Math.min(fromBounds.maxX, toBounds.maxX),
+      minY: Math.max(fromBounds.minY, toBounds.minY),
+      maxY: Math.min(fromBounds.maxY, toBounds.maxY)
+    };
+    if (overlapBounds.minX > overlapBounds.maxX || overlapBounds.minY > overlapBounds.maxY) {
+      return;
+    }
+    const viaRadius = this.options.viaOuterDiameter / 2;
+    const requiredCopperRadius = viaRadius + this.options.pourEdgeClearance;
+    const requiredObstacleRadius = viaRadius + this.options.obstacleClearance;
+    const xCoordinates = getGridCoordinates({
+      minimum: overlapBounds.minX + requiredCopperRadius,
+      maximum: overlapBounds.maxX - requiredCopperRadius,
+      origin: this.options.gridOrigin.x,
+      pitch: this.options.viaPitch
+    });
+    const yCoordinates = getGridCoordinates({
+      minimum: overlapBounds.minY + requiredCopperRadius,
+      maximum: overlapBounds.maxY - requiredCopperRadius,
+      origin: this.options.gridOrigin.y,
+      pitch: this.options.viaPitch
+    });
+    for (const y of yCoordinates) {
+      for (const x of xCoordinates) {
+        const center = { x, y };
+        if (isTooCloseToOccupiedVia({
+          center,
+          radius: viaRadius,
+          occupiedVias: this.occupiedVias,
+          minimumViaSeparation: this.options.minimumViaSeparation
+        }) || doesViaIntersectStitchingObstacle({
+          center,
+          radius: requiredObstacleRadius,
+          obstacles: this.stitchingObstacles
+        }) || !isViaAnnulusInsideShapeUnion({
+          center,
+          radius: requiredCopperRadius,
+          shapes: fromLayerShapes
+        }) || !isViaAnnulusInsideShapeUnion({
+          center,
+          radius: requiredCopperRadius,
+          shapes: toLayerShapes
+        })) {
+          continue;
+        }
+        let pcbViaId = `via_stitch_via_${this.nextViaId++}`;
+        while (this.existingPcbViaIds.has(pcbViaId)) {
+          pcbViaId = `via_stitch_via_${this.nextViaId++}`;
+        }
+        const referencePour = context.fromLayerPours[0];
+        const pcbVia = {
+          type: "pcb_via",
+          pcb_via_id: pcbViaId,
+          x,
+          y,
+          hole_diameter: this.options.viaHoleDiameter,
+          outer_diameter: this.options.viaOuterDiameter,
+          layers: [fromLayer, toLayer],
+          from_layer: fromLayer,
+          to_layer: toLayer,
+          source_net_id: context.sourceNetId,
+          subcircuit_id: referencePour.subcircuit_id,
+          pcb_group_id: referencePour.pcb_group_id,
+          subcircuit_connectivity_map_key: context.sourceNet?.subcircuit_connectivity_map_key,
+          is_tented: this.options.isTented
+        };
+        this.pcbVias.push(pcbVia);
+        this.existingPcbViaIds.add(pcbViaId);
+        this.occupiedVias.push({ center, radius: viaRadius });
+      }
+    }
+  }
+  getOutput() {
+    return {
+      processedCopperPourPairCount: this.copperPourPairContexts.length,
+      pcbVias: this.pcbVias
+    };
+  }
+};
+
+// lib/solvers.ts
 import { PackSolver2 } from "calculate-packing";
 var SOLVERS = {
   PackSolver2,
@@ -40838,7 +41323,8 @@ var SOLVERS = {
   CreateFdmEnclosureSolver,
   FanoutSolver,
   ImplicitCopperPourPipelineSolver,
-  SchematicTracePipelineSolver
+  SchematicTracePipelineSolver,
+  ViaStitchSolver
 };
 
 // lib/utils/autorouting/LocalCacheEngineCacheProvider.ts
@@ -50925,7 +51411,7 @@ function Group_getRoutingPhasePlans(group) {
 var package_default = {
   name: "@tscircuit/core",
   type: "module",
-  version: "0.0.1857",
+  version: "0.0.1858",
   types: "dist/index.d.ts",
   main: "dist/index.js",
   module: "dist/index.js",
@@ -50983,6 +51469,7 @@ var package_default = {
     "@tscircuit/schematic-trace-solver": "^0.0.186",
     "@tscircuit/solver-utils": "^0.0.16",
     "@tscircuit/soup-util": "^0.0.41",
+    "@tscircuit/via-stitch-solver": "github:tscircuit/via-stitch-solver#75653b6440e75584b052f03595afd34283ae7558",
     "@tscircuit/winding-breakout-point-solver": "github:tscircuit/winding-breakout-point-solver#202dbe9eb0088633b6fa094120dba6f2f41f8803",
     "@types/bun": "^1.2.16",
     "@types/debug": "^4.1.12",
@@ -51654,7 +52141,7 @@ function getAccumulatedPcbTracesWithStageOutputReplacements({
 // lib/components/primitive-components/Group/get-source-trace-id-for-routed-trace.ts
 import { distance as distance14, pointToSegmentDistance as pointToSegmentDistance3 } from "@tscircuit/math-utils";
 import { ConnectivityMap as ConnectivityMap5 } from "circuit-json-to-connectivity-map";
-var POINT_EPSILON = 1e-6;
+var POINT_EPSILON2 = 1e-6;
 function isPointOnWireSegment({
   point: point6,
   segmentStart,
@@ -51663,7 +52150,7 @@ function isPointOnWireSegment({
   if (point6.layer && (segmentStart.layer !== point6.layer || segmentEnd.layer !== point6.layer)) {
     return false;
   }
-  return pointToSegmentDistance3(point6, segmentStart, segmentEnd) <= POINT_EPSILON;
+  return pointToSegmentDistance3(point6, segmentStart, segmentEnd) <= POINT_EPSILON2;
 }
 function isPointInSmtPad({
   point: point6,
@@ -55449,6 +55936,8 @@ var IsolatedCircuit = class {
   pcbDisabled = false;
   pcbRoutingDisabled = false;
   _featureMspSchematicTraceRouting = true;
+  /** Experimental automatic via stitching; opt in before rendering. */
+  _featurePcbViaStitching = false;
   /**
    * The IsolatedCircuit name is usually set by the platform, it's not required but
    * if supplied can identify the circuit in certain effects, e.g. it is passed
@@ -55873,7 +56362,7 @@ import {
 // lib/components/primitive-components/CopperPour/utils/mark-trace-segments-inside-copper-pour.ts
 var EPSILON14 = 1e-9;
 var isWireRoutePoint = (routePoint) => routePoint.route_type === "wire";
-var isPointOnSegment = (p, a, b) => {
+var isPointOnSegment2 = (p, a, b) => {
   const cross3 = (p.y - a.y) * (b.x - a.x) - (p.x - a.x) * (b.y - a.y);
   if (Math.abs(cross3) > EPSILON14) return false;
   const dot = (p.x - a.x) * (b.x - a.x) + (p.y - a.y) * (b.y - a.y);
@@ -55882,12 +56371,12 @@ var isPointOnSegment = (p, a, b) => {
   if (dot - squaredLength > EPSILON14) return false;
   return true;
 };
-var isPointInRing = (point6, ring) => {
+var isPointInRing2 = (point6, ring) => {
   if (ring.length < 3) return false;
   let inside = false;
   let previous = ring[ring.length - 1];
   for (const current of ring) {
-    if (isPointOnSegment(point6, previous, current)) return true;
+    if (isPointOnSegment2(point6, previous, current)) return true;
     const intersects = current.y > point6.y !== previous.y > point6.y && point6.x < (previous.x - current.x) * (point6.y - current.y) / (previous.y - current.y) + current.x;
     if (intersects) inside = !inside;
     previous = current;
@@ -55910,10 +56399,10 @@ var isPointInBrepPour = (p, pour) => {
     x: v.x,
     y: v.y
   }));
-  if (!isPointInRing(p, outerRing)) return false;
+  if (!isPointInRing2(p, outerRing)) return false;
   for (const innerRing of pour.brep_shape.inner_rings) {
     const points = innerRing.vertices.map((v) => ({ x: v.x, y: v.y }));
-    if (isPointInRing(p, points)) return false;
+    if (isPointInRing2(p, points)) return false;
   }
   return true;
 };
@@ -56100,6 +56589,59 @@ function CopperPour_doInitialPcbCopperPourRender(copperPour) {
   });
 }
 
+// lib/components/primitive-components/CopperPour/CopperPour_doInitialPcbViaStitchRender.ts
+var renderViaStitchingForCopperPours = (copperPour) => {
+  const subcircuit = copperPour.getSubcircuit();
+  if (!subcircuit.root) return;
+  const copperPours = subcircuit.selectAll("copperpour").filter(
+    (candidateCopperPour) => candidateCopperPour.getSubcircuit() === subcircuit
+  );
+  if (copperPours[0] !== copperPour) return;
+  const sourceNetIds = copperPours.flatMap((candidateCopperPour) => {
+    const net = subcircuit.selectOne(
+      candidateCopperPour._parsedProps.connectsTo
+    );
+    return net?.source_net_id ? [net.source_net_id] : [];
+  });
+  if (sourceNetIds.length === 0) return;
+  const { db } = subcircuit.root;
+  const pcbStyle = copperPour.getInheritedMergedProperty("pcbStyle");
+  const { holeDiameter, padDiameter } = getViaDiameterDefaults(pcbStyle);
+  const boardComponent = copperPour._getBoard();
+  const pcbBoard = boardComponent?.pcb_board_id ? db.pcb_board.get(boardComponent.pcb_board_id) : void 0;
+  const solverInput = {
+    circuitJson: db.toArray(),
+    options: {
+      sourceNetIds: [...new Set(sourceNetIds)],
+      viaHoleDiameter: pcbBoard?.min_via_hole_diameter ?? holeDiameter,
+      viaOuterDiameter: pcbBoard?.min_via_pad_diameter ?? padDiameter
+    }
+  };
+  const solver = new ViaStitchSolver(solverInput);
+  subcircuit.root.emit("solver:started", {
+    type: "solver:started",
+    solverName: "ViaStitchSolver",
+    solverParams: solverInput,
+    solverConstructorArgs: [solverInput],
+    componentName: subcircuit.getString()
+  });
+  solver.solve();
+  if (solver.failed) {
+    throw new Error(solver.error ?? "Via stitching solver failed");
+  }
+  for (const pcbVia of solver.getOutput().pcbVias) {
+    const { pcb_via_id: _solverViaId, ...pcbViaInput } = pcbVia;
+    db.pcb_via.insert(pcbViaInput);
+  }
+};
+function CopperPour_doInitialPcbViaStitchRender(copperPour) {
+  if (copperPour.root?.pcbDisabled || !copperPour.root?._featurePcbViaStitching)
+    return;
+  copperPour._queueAsyncEffect("PcbViaStitchRender", async () => {
+    renderViaStitchingForCopperPours(copperPour);
+  });
+}
+
 // lib/components/primitive-components/CopperPour/CopperPour.ts
 var CopperPour = class extends PrimitiveComponent2 {
   isPcbPrimitive = true;
@@ -56120,6 +56662,9 @@ var CopperPour = class extends PrimitiveComponent2 {
   doInitialPcbCopperPourRender() {
     CopperPour_doInitialPcbCopperPourRender(this);
   }
+  doInitialPcbViaStitchRender() {
+    CopperPour_doInitialPcbViaStitchRender(this);
+  }
 };
 
 // lib/components/normal-components/Board_doInitialPcbImplicitCopperPourRender.ts
@@ -60225,7 +60770,7 @@ var validateWindingBreakoutInput = (input) => {
 };
 
 // node_modules/@tscircuit/winding-breakout-point-solver/lib/solvers/GatePlacementSolver.ts
-import { BaseSolver as BaseSolver3 } from "@tscircuit/solver-utils";
+import { BaseSolver as BaseSolver4 } from "@tscircuit/solver-utils";
 
 // node_modules/@tscircuit/winding-breakout-point-solver/lib/gate-placement/place-breakout-gates.ts
 var GEOMETRY_EPSILON = 1e-9;
@@ -60755,7 +61300,7 @@ var getSharedGateSlotCount = (points) => new Set(
     (point6) => `${point6.regionId}:${point6.x.toFixed(9)}:${point6.y.toFixed(9)}`
   )
 ).size;
-var GatePlacementSolver = class extends BaseSolver3 {
+var GatePlacementSolver = class extends BaseSolver4 {
   constructor(params) {
     super();
     this.params = params;
@@ -60894,7 +61439,7 @@ var GatePlacementSolver = class extends BaseSolver3 {
 };
 
 // node_modules/@tscircuit/winding-breakout-point-solver/lib/solvers/ReferenceOrderingSolver.ts
-import { BaseSolver as BaseSolver4 } from "@tscircuit/solver-utils";
+import { BaseSolver as BaseSolver5 } from "@tscircuit/solver-utils";
 
 // node_modules/@tscircuit/winding-breakout-point-solver/lib/ordering/get-natural-winding-order.ts
 var getNaturalWindingOrder = (region, connections) => connections.map((connection) => {
@@ -60961,7 +61506,7 @@ var getReferenceWindingOrder = (naturalOrder, atomicGroups, buses) => {
 };
 
 // node_modules/@tscircuit/winding-breakout-point-solver/lib/solvers/ReferenceOrderingSolver.ts
-var ReferenceOrderingSolver = class extends BaseSolver4 {
+var ReferenceOrderingSolver = class extends BaseSolver5 {
   constructor(params) {
     super();
     this.params = params;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/core",
   "type": "module",
-  "version": "0.0.1858",
+  "version": "0.0.1859",
   "types": "dist/index.d.ts",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -59,6 +59,7 @@
     "@tscircuit/schematic-trace-solver": "^0.0.186",
     "@tscircuit/solver-utils": "^0.0.16",
     "@tscircuit/soup-util": "^0.0.41",
+    "@tscircuit/via-stitch-solver": "github:tscircuit/via-stitch-solver#75653b6440e75584b052f03595afd34283ae7558",
     "@tscircuit/winding-breakout-point-solver": "github:tscircuit/winding-breakout-point-solver#202dbe9eb0088633b6fa094120dba6f2f41f8803",
     "@types/bun": "^1.2.16",
     "@types/debug": "^4.1.12",