@tscircuit/copper-pour-solver 0.0.32 → 0.0.34

package/README.md

@@ -1,37 +1,156 @@
 # @tscircuit/copper-pour-solver
 
-Solves for copper pour polygons
+Solves PCB copper pour regions from Circuit JSON or from a small geometry input
+format, returning `pcb_copper_pour`-ready B-Rep shapes.
 
-```tsx
-import { CopperPourPipelineSolver } from "@tscircuit/copper-pour-solver"
+## Install
 
-const solver = new CopperPourPipelineSolver({
-  // Circuit JSON including pcb_plated_hole, pcb_hole, pcb_smtpad, pcb_trace, pcb_keepout etc.
-  circuitJson
+```bash
+bun add @tscircuit/copper-pour-solver
+```
+
+This package expects TypeScript 5 as a peer dependency.
+
+## Basic Usage With Circuit JSON
+
+Initialize the geometry runtime once before solving. Then convert Circuit JSON
+into the solver input format, run the solver, and map the returned B-Rep shapes
+back into `pcb_copper_pour` elements.
+
+```ts
+import {
+  CopperPourPipelineSolver,
+  convertCircuitJsonToInputProblem,
+  initializeManifoldGeometry,
+} from "@tscircuit/copper-pour-solver"
+
+await initializeManifoldGeometry()
+
+const inputProblem = convertCircuitJsonToInputProblem(circuitJson, {
+  layer: "top",
+  source_net_name: "GND",
+  pad_margin: 0.4,
+  trace_margin: 0.2,
+  board_edge_margin: 0.1,
+  cutout_margin: 0.2,
 })
 
-solver.solve()
+const solver = new CopperPourPipelineSolver(inputProblem)
+const { brep_shapes } = solver.getOutput()
+```
+
+`convertCircuitJsonToInputProblem` reads board bounds or outline, SMT pads,
+plated holes, mechanical holes, vias, traces, and cutouts for the selected layer.
+Pads and traces connected to the selected source net are kept connected to the
+pour; unrelated geometry is subtracted using the configured margins.
+
+## Selecting The Pour Net
 
-solver.getOutput()
-// { brepShapes }
+Prefer selecting by source net name or id:
+
+```ts
+const inputProblem = convertCircuitJsonToInputProblem(circuitJson, {
+  layer: "top",
+  source_net_name: "GND",
+  pad_margin: 0.4,
+  trace_margin: 0.2,
+})
 ```
 
-## B-Rep Shapes
+You can also pass the source net's stable `subcircuit_connectivity_map_key`
+directly:
 
-We use the following representation for 2D b-rep shapes
+```ts
+const gnd = circuitJson.find(
+  (element) => element.type === "source_net" && element.name === "GND",
+)
 
-```tsx
-interface BRepShape {
-  outerRing: Ring // The outer boundary
-  innerRings: Ring // The inner cutouts
+const inputProblem = convertCircuitJsonToInputProblem(circuitJson, {
+  layer: "top",
+  subcircuit_connectivity_map_key: gnd.subcircuit_connectivity_map_key,
+  pad_margin: 0.4,
+  trace_margin: 0.2,
+})
+```
+
+Do not generate or pass ids from `circuit-json-to-connectivity-map`. The
+converter handles PCB connectivity internally and normalizes it to stable
+`subcircuit_connectivity_map_key` values.
+
+## Manual Input
+
+You can skip Circuit JSON conversion and provide the solver input directly.
+
+```ts
+import {
+  CopperPourPipelineSolver,
+  initializeManifoldGeometry,
+  type InputProblem,
+} from "@tscircuit/copper-pour-solver"
+
+await initializeManifoldGeometry()
+
+const input: InputProblem = {
+  regionsForPour: [
+    {
+      shape: "rect",
+      layer: "top",
+      bounds: { minX: -10, minY: -5, maxX: 10, maxY: 5 },
+      connectivityKey: "net:GND",
+      padMargin: 0.4,
+      traceMargin: 0.2,
+      board_edge_margin: 0.1,
+    },
+  ],
+  pads: [
+    {
+      shape: "circle",
+      padId: "via_1",
+      layer: "top",
+      connectivityKey: "net:VCC",
+      x: 0,
+      y: 0,
+      radius: 0.5,
+    },
+  ],
 }
 
-interface Ring {
-  cwVertices: PointWithBulge[]
+const output = new CopperPourPipelineSolver(input).getOutput()
+```
+
+Supported input pad shapes are `rect`, `circle`, `pill`, `trace`, and `polygon`.
+Use the same `connectivityKey` as the pour for pads/traces that should connect to
+the copper island; use a different key for blockers that should be cleared.
+
+## Output
+
+`getOutput()` returns:
+
+```ts
+interface PipelineOutput {
+  brep_shapes: BRepShape[]
 }
+```
+
+Each B-Rep shape is compatible with Circuit JSON copper pour data:
 
-interface PointWithBulge {
-  x: number
-  y: number
+```ts
+interface BRepShape {
+  outer_ring: {
+    vertices: Array<{ x: number; y: number; bulge?: number }>
+  }
+  inner_rings: Array<{
+    vertices: Array<{ x: number; y: number; bulge?: number }>
+  }>
 }
 ```
+
+## Development
+
+```bash
+bun install
+bun run build
+bun test
+bun start
+bun run build:site
+```

package/cosmos.config.json

@@ -1,5 +1,6 @@
 {
   "$schema": "http://json.schemastore.org/cosmos-config",
   "plugins": ["react-cosmos-plugin-vite"],
-  "fixtureFileSuffix": "page"
+  "fixtureFileSuffix": "page",
+  "exportPath": "cosmos-export"
 }

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { BasePipelineSolver } from '@tscircuit/solver-utils';
 import { Bounds, Point } from '@tscircuit/math-utils';
-import { BRepShape, AnyCircuitElement, LayerRef, Point as Point$1 } from 'circuit-json';
+import { BRepShape, LayerRef, Point as Point$1, AnyCircuitElement } from 'circuit-json';
 
 interface InputPourRegion {
     shape: "rect";
@@ -28,6 +28,15 @@ interface InputCircularPad extends BaseInputPad {
     y: number;
     radius: number;
 }
+interface InputPillPad extends BaseInputPad {
+    shape: "pill";
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    radius: number;
+    ccwRotation: number;
+}
 interface InputTracePad extends BaseInputPad {
     shape: "trace";
     width: number;
@@ -37,7 +46,7 @@ interface InputPolygonPad extends BaseInputPad {
     shape: "polygon";
     points: Point[];
 }
-type InputPad = InputRectPad | InputCircularPad | InputTracePad | InputPolygonPad;
+type InputPad = InputRectPad | InputCircularPad | InputPillPad | InputTracePad | InputPolygonPad;
 interface InputProblem {
     regionsForPour: InputPourRegion[];
     pads: InputPad[];
@@ -56,14 +65,23 @@ declare class CopperPourPipelineSolver extends BasePipelineSolver<InputProblem>
 
 declare const initializeManifoldGeometry: () => Promise<void>;
 
-declare const convertCircuitJsonToInputProblem: (circuitJson: AnyCircuitElement[], options: {
+interface ConvertCircuitJsonToInputProblemOptions {
     layer: LayerRef;
-    pour_connectivity_key: string;
+    source_net_id?: string;
+    source_net_name?: string;
+    subcircuit_connectivity_map_key?: string;
+    /**
+     * @deprecated Use subcircuit_connectivity_map_key, source_net_id, or
+     * source_net_name. Generated connectivity-map ids are intentionally rejected.
+     */
+    pour_connectivity_key?: string;
     pad_margin: number;
     trace_margin: number;
     board_edge_margin?: number;
     cutout_margin?: number;
     outline?: Point$1[];
-}) => InputProblem;
+}
+
+declare const convertCircuitJsonToInputProblem: (circuitJson: AnyCircuitElement[], options: ConvertCircuitJsonToInputProblemOptions) => InputProblem;
 
-export { type BaseInputPad, CopperPourPipelineSolver, type InputCircularPad, type InputPad, type InputPolygonPad, type InputPourRegion, type InputProblem, type InputRectPad, type InputTracePad, type PipelineOutput, convertCircuitJsonToInputProblem, initializeManifoldGeometry };
+export { type BaseInputPad, type ConvertCircuitJsonToInputProblemOptions, CopperPourPipelineSolver, type InputCircularPad, type InputPad, type InputPillPad, type InputPolygonPad, type InputPourRegion, type InputProblem, type InputRectPad, type InputTracePad, type PipelineOutput, convertCircuitJsonToInputProblem, initializeManifoldGeometry };

package/dist/index.js

@@ -321,11 +321,50 @@ var segmentToPolygon = (start, end, width) => {
     y: centerY + point.x * sinAngle + point.y * cosAngle
   }));
 };
+var pillToPolygon = (center, width, height, radius, ccwRotation = 0, numSegments = 32) => {
+  if (radius <= 0) return [];
+  const isVertical = height >= width;
+  const centerlineLength = Math.max(width, height) - 2 * radius;
+  const halfCenterline = Math.max(0, centerlineLength / 2);
+  const baseAngle = isVertical ? Math.PI / 2 : 0;
+  const rotation = baseAngle + ccwRotation * Math.PI / 180;
+  const cosAngle = Math.cos(rotation);
+  const sinAngle = Math.sin(rotation);
+  const start = {
+    x: center.x - halfCenterline * cosAngle,
+    y: center.y - halfCenterline * sinAngle
+  };
+  const end = {
+    x: center.x + halfCenterline * cosAngle,
+    y: center.y + halfCenterline * sinAngle
+  };
+  if (halfCenterline === 0) {
+    return circleToPolygon(center, radius, numSegments);
+  }
+  const points = [];
+  const halfSegments = Math.max(4, Math.floor(numSegments / 2));
+  for (let i = 0; i <= halfSegments; i++) {
+    const angle = rotation - Math.PI / 2 + i / halfSegments * Math.PI;
+    points.push({
+      x: end.x + radius * Math.cos(angle),
+      y: end.y + radius * Math.sin(angle)
+    });
+  }
+  for (let i = 0; i <= halfSegments; i++) {
+    const angle = rotation + Math.PI / 2 + i / halfSegments * Math.PI;
+    points.push({
+      x: start.x + radius * Math.cos(angle),
+      y: start.y + radius * Math.sin(angle)
+    });
+  }
+  return points;
+};
 
 // lib/solvers/copper-pour/process-obstacles.ts
 var isRectPad = (pad) => pad.shape === "rect";
 var isTracePad = (pad) => pad.shape === "trace";
 var isCircularPad = (pad) => pad.shape === "circle";
+var isPillPad = (pad) => pad.shape === "pill";
 var isPolygonPad = (pad) => pad.shape === "polygon";
 var processObstaclesForPour = (pads, pourConnectivityKey, margins, boardOutline) => {
   const polygonsToSubtract = [];
@@ -378,6 +417,19 @@ var processObstaclesForPour = (pads, pourConnectivityKey, margins, boardOutline)
       );
       continue;
     }
+    if (isPillPad(pad)) {
+      const margin = isHoleOrCutout ? cutoutMargin ?? 0 : padMargin;
+      polygonsToSubtract.push(
+        pillToPolygon(
+          { x: pad.x, y: pad.y },
+          pad.width + margin * 2,
+          pad.height + margin * 2,
+          pad.radius + margin,
+          pad.ccwRotation
+        )
+      );
+      continue;
+    }
     if (isRectPad(pad)) {
       const margin = isHoleOrCutout ? cutoutMargin ?? 0 : padMargin;
       const { bounds } = pad;
@@ -485,19 +537,123 @@ var CopperPourPipelineSolver = class extends BasePipelineSolver {
 
 // lib/circuit-json/convert-circuit-json-to-input-problem.ts
 import { getFullConnectivityMapFromCircuitJson } from "circuit-json-to-connectivity-map";
+
+// lib/circuit-json/buildSubcircuitConnectivityLookup.ts
+import { getElementId } from "@tscircuit/circuit-json-util";
+
+// lib/circuit-json/getElementSubcircuitConnectivityKey.ts
+var getElementSubcircuitConnectivityKey = (element) => {
+  const key = element.subcircuit_connectivity_map_key;
+  return typeof key === "string" && key.length > 0 ? key : void 0;
+};
+
+// lib/circuit-json/buildSubcircuitConnectivityLookup.ts
+var buildSubcircuitConnectivityLookup = (circuitJson, connectivityMap) => {
+  const idToSubcircuitConnectivityKey = {};
+  for (const element of circuitJson) {
+    const id = getElementId(element);
+    const key = getElementSubcircuitConnectivityKey(element);
+    if (id && key) {
+      idToSubcircuitConnectivityKey[id] = key;
+    }
+  }
+  const generatedNetIdToSubcircuitConnectivityKey = {};
+  for (const [generatedNetId, connectedIds] of Object.entries(
+    connectivityMap.netMap
+  )) {
+    const connectedSubcircuitKeys = new Set(
+      connectedIds.map((id) => idToSubcircuitConnectivityKey[id]).filter((key) => Boolean(key))
+    );
+    if (connectedSubcircuitKeys.size > 1) {
+      throw new Error(
+        `Multiple subcircuit connectivity keys found for generated connectivity map net "${generatedNetId}": ${Array.from(connectedSubcircuitKeys).join(", ")}`
+      );
+    }
+    const subcircuitKey = connectedSubcircuitKeys.values().next().value;
+    if (subcircuitKey) {
+      generatedNetIdToSubcircuitConnectivityKey[generatedNetId] = subcircuitKey;
+    }
+  }
+  return {
+    knownSubcircuitConnectivityKeys: new Set(
+      Object.values(idToSubcircuitConnectivityKey)
+    ),
+    getSubcircuitConnectivityKeyForId(id) {
+      const directKey = idToSubcircuitConnectivityKey[id];
+      if (directKey) return directKey;
+      const generatedNetId = connectivityMap.getNetConnectedToId(id);
+      if (!generatedNetId) return void 0;
+      return generatedNetIdToSubcircuitConnectivityKey[generatedNetId];
+    }
+  };
+};
+
+// lib/circuit-json/resolvePourConnectivityKey.ts
+var resolvePourConnectivityKey = (circuitJson, options, knownSubcircuitConnectivityKeys) => {
+  if (options.subcircuit_connectivity_map_key) {
+    return options.subcircuit_connectivity_map_key;
+  }
+  if (options.source_net_id) {
+    const sourceNet = circuitJson.find(
+      (element) => element.type === "source_net" && element.source_net_id === options.source_net_id
+    );
+    if (!sourceNet) {
+      throw new Error(`No source_net found with id "${options.source_net_id}"`);
+    }
+    if (!sourceNet.subcircuit_connectivity_map_key) {
+      throw new Error(
+        `source_net "${options.source_net_id}" has no subcircuit_connectivity_map_key`
+      );
+    }
+    return sourceNet.subcircuit_connectivity_map_key;
+  }
+  if (options.source_net_name) {
+    const sourceNet = circuitJson.find(
+      (element) => element.type === "source_net" && element.name === options.source_net_name
+    );
+    if (!sourceNet) {
+      throw new Error(
+        `No source_net found with name "${options.source_net_name}"`
+      );
+    }
+    if (!sourceNet.subcircuit_connectivity_map_key) {
+      throw new Error(
+        `source_net "${options.source_net_name}" has no subcircuit_connectivity_map_key`
+      );
+    }
+    return sourceNet.subcircuit_connectivity_map_key;
+  }
+  if (options.pour_connectivity_key) {
+    if (!knownSubcircuitConnectivityKeys.has(options.pour_connectivity_key)) {
+      throw new Error(
+        `pour_connectivity_key must be a subcircuit_connectivity_map_key. Use subcircuit_connectivity_map_key, source_net_id, or source_net_name instead of a generated connectivity-map id.`
+      );
+    }
+    return options.pour_connectivity_key;
+  }
+  throw new Error(
+    "Copper pour requires source_net_id, source_net_name, or subcircuit_connectivity_map_key"
+  );
+};
+
+// lib/circuit-json/convert-circuit-json-to-input-problem.ts
 var convertCircuitJsonToInputProblem = (circuitJson, options) => {
   const pcb_board = circuitJson.find((e) => e.type === "pcb_board");
   if (!pcb_board) throw new Error("No pcb_board found in circuit json");
   const connectivityMap = getFullConnectivityMapFromCircuitJson(circuitJson);
+  const { knownSubcircuitConnectivityKeys, getSubcircuitConnectivityKeyForId } = buildSubcircuitConnectivityLookup(circuitJson, connectivityMap);
+  const pourConnectivityKey = resolvePourConnectivityKey(
+    circuitJson,
+    options,
+    knownSubcircuitConnectivityKeys
+  );
   const pads = [];
   for (const elm of circuitJson) {
     if (elm.type === "pcb_smtpad") {
       const smtpad = elm;
       if (smtpad.layer !== options.layer) continue;
       let connectivityKey;
-      connectivityKey = connectivityMap.getNetConnectedToId(
-        smtpad.pcb_smtpad_id
-      );
+      connectivityKey = getSubcircuitConnectivityKeyForId(smtpad.pcb_smtpad_id);
       if (!connectivityKey) {
         connectivityKey = `unconnected:${smtpad.pcb_smtpad_id}`;
       }
@@ -524,11 +680,24 @@ var convertCircuitJsonToInputProblem = (circuitJson, options) => {
           y: smtpad.y,
           radius: smtpad.radius
         });
+      } else if (smtpad.shape === "pill" || smtpad.shape === "rotated_pill") {
+        pads.push({
+          shape: "pill",
+          padId: smtpad.pcb_smtpad_id,
+          layer: smtpad.layer,
+          connectivityKey,
+          x: smtpad.x,
+          y: smtpad.y,
+          width: smtpad.width,
+          height: smtpad.height,
+          radius: smtpad.radius,
+          ccwRotation: smtpad.shape === "rotated_pill" ? smtpad.ccw_rotation : 0
+        });
       }
     } else if (elm.type === "pcb_plated_hole") {
       const platedHole = elm;
       if (!platedHole.layers.includes(options.layer)) continue;
-      let connectivityKey = connectivityMap.getNetConnectedToId(
+      let connectivityKey = getSubcircuitConnectivityKeyForId(
         platedHole.pcb_plated_hole_id
       );
       if (!connectivityKey) {
@@ -616,7 +785,7 @@ var convertCircuitJsonToInputProblem = (circuitJson, options) => {
     } else if (elm.type === "pcb_via") {
       const via = elm;
       if (!via.layers.includes(options.layer)) continue;
-      const connectivityKey = connectivityMap.getNetConnectedToId(via.pcb_via_id) ?? `unconnected-via:${via.pcb_via_id}`;
+      const connectivityKey = getSubcircuitConnectivityKeyForId(via.pcb_via_id) ?? `unconnected-via:${via.pcb_via_id}`;
       pads.push({
         shape: "circle",
         padId: via.pcb_via_id,
@@ -628,7 +797,7 @@ var convertCircuitJsonToInputProblem = (circuitJson, options) => {
       });
     } else if (elm.type === "pcb_trace") {
       const trace = elm;
-      const connectivityKey = connectivityMap.getNetConnectedToId(
+      const connectivityKey = getSubcircuitConnectivityKeyForId(
         trace.pcb_trace_id
       );
       if (!connectivityKey) continue;
@@ -687,7 +856,7 @@ var convertCircuitJsonToInputProblem = (circuitJson, options) => {
       layer: options.layer,
       bounds,
       outline,
-      connectivityKey: options.pour_connectivity_key,
+      connectivityKey: pourConnectivityKey,
       padMargin: options.pad_margin,
       traceMargin: options.trace_margin,
       board_edge_margin: options.board_edge_margin ?? 0,

package/lib/circuit-json/ConvertCircuitJsonToInputProblemOptions.ts

@@ -0,0 +1,18 @@
+import type { LayerRef, Point } from "circuit-json"
+
+export interface ConvertCircuitJsonToInputProblemOptions {
+  layer: LayerRef
+  source_net_id?: string
+  source_net_name?: string
+  subcircuit_connectivity_map_key?: string
+  /**
+   * @deprecated Use subcircuit_connectivity_map_key, source_net_id, or
+   * source_net_name. Generated connectivity-map ids are intentionally rejected.
+   */
+  pour_connectivity_key?: string
+  pad_margin: number
+  trace_margin: number
+  board_edge_margin?: number
+  cutout_margin?: number
+  outline?: Point[]
+}

package/lib/circuit-json/buildSubcircuitConnectivityLookup.ts

@@ -0,0 +1,54 @@
+import type { AnyCircuitElement } from "circuit-json"
+import type { getFullConnectivityMapFromCircuitJson } from "circuit-json-to-connectivity-map"
+import { getElementId } from "@tscircuit/circuit-json-util"
+import { getElementSubcircuitConnectivityKey } from "./getElementSubcircuitConnectivityKey"
+
+export const buildSubcircuitConnectivityLookup = (
+  circuitJson: AnyCircuitElement[],
+  connectivityMap: ReturnType<typeof getFullConnectivityMapFromCircuitJson>,
+) => {
+  const idToSubcircuitConnectivityKey: Record<string, string> = {}
+
+  for (const element of circuitJson) {
+    const id = getElementId(element)
+    const key = getElementSubcircuitConnectivityKey(element)
+    if (id && key) {
+      idToSubcircuitConnectivityKey[id] = key
+    }
+  }
+
+  const generatedNetIdToSubcircuitConnectivityKey: Record<string, string> = {}
+  for (const [generatedNetId, connectedIds] of Object.entries(
+    connectivityMap.netMap,
+  )) {
+    const connectedSubcircuitKeys = new Set(
+      connectedIds
+        .map((id) => idToSubcircuitConnectivityKey[id])
+        .filter((key): key is string => Boolean(key)),
+    )
+    if (connectedSubcircuitKeys.size > 1) {
+      throw new Error(
+        `Multiple subcircuit connectivity keys found for generated connectivity map net "${generatedNetId}": ${Array.from(connectedSubcircuitKeys).join(", ")}`,
+      )
+    }
+    const subcircuitKey = connectedSubcircuitKeys.values().next().value
+    if (subcircuitKey) {
+      generatedNetIdToSubcircuitConnectivityKey[generatedNetId] = subcircuitKey
+    }
+  }
+
+  return {
+    knownSubcircuitConnectivityKeys: new Set(
+      Object.values(idToSubcircuitConnectivityKey),
+    ),
+    getSubcircuitConnectivityKeyForId(id: string): string | undefined {
+      const directKey = idToSubcircuitConnectivityKey[id]
+      if (directKey) return directKey
+
+      const generatedNetId = connectivityMap.getNetConnectedToId(id)
+      if (!generatedNetId) return undefined
+
+      return generatedNetIdToSubcircuitConnectivityKey[generatedNetId]
+    },
+  }
+}

package/lib/circuit-json/convert-circuit-json-to-input-problem.ts

@@ -1,39 +1,30 @@
 import type {
   AnyCircuitElement,
-  LayerRef,
   PcbBoard,
   PcbHole,
   PcbPlatedHole,
-  PcbPort,
   PcbSmtPad,
   PcbTrace,
   PcbVia,
   Point,
-  SourceNet,
-  SourcePort,
-  SourceTrace,
 } from "circuit-json"
 import { getFullConnectivityMapFromCircuitJson } from "circuit-json-to-connectivity-map"
 import type {
   InputCircularPad,
   InputPad,
+  InputPillPad,
   InputPolygonPad,
   InputProblem,
   InputRectPad,
   InputTracePad,
 } from "lib/types"
+import type { ConvertCircuitJsonToInputProblemOptions } from "./ConvertCircuitJsonToInputProblemOptions"
+import { buildSubcircuitConnectivityLookup } from "./buildSubcircuitConnectivityLookup"
+import { resolvePourConnectivityKey } from "./resolvePourConnectivityKey"
 
 export const convertCircuitJsonToInputProblem = (
   circuitJson: AnyCircuitElement[],
-  options: {
-    layer: LayerRef
-    pour_connectivity_key: string
-    pad_margin: number
-    trace_margin: number
-    board_edge_margin?: number
-    cutout_margin?: number
-    outline?: Point[]
-  },
+  options: ConvertCircuitJsonToInputProblemOptions,
 ): InputProblem => {
   const pcb_board = circuitJson.find((e) => e.type === "pcb_board") as
     | PcbBoard
@@ -42,6 +33,13 @@ export const convertCircuitJsonToInputProblem = (
   if (!pcb_board) throw new Error("No pcb_board found in circuit json")
 
   const connectivityMap = getFullConnectivityMapFromCircuitJson(circuitJson)
+  const { knownSubcircuitConnectivityKeys, getSubcircuitConnectivityKeyForId } =
+    buildSubcircuitConnectivityLookup(circuitJson, connectivityMap)
+  const pourConnectivityKey = resolvePourConnectivityKey(
+    circuitJson,
+    options,
+    knownSubcircuitConnectivityKeys,
+  )
 
   const pads: InputPad[] = []
 
@@ -51,9 +49,7 @@ export const convertCircuitJsonToInputProblem = (
       if (smtpad.layer !== options.layer) continue
 
       let connectivityKey: string | undefined
-      connectivityKey = connectivityMap.getNetConnectedToId(
-        smtpad.pcb_smtpad_id,
-      )
+      connectivityKey = getSubcircuitConnectivityKeyForId(smtpad.pcb_smtpad_id)
       if (!connectivityKey) {
         connectivityKey = `unconnected:${smtpad.pcb_smtpad_id}`
       }
@@ -81,12 +77,26 @@ export const convertCircuitJsonToInputProblem = (
           y: smtpad.y,
           radius: smtpad.radius!,
         } as InputCircularPad)
+      } else if (smtpad.shape === "pill" || smtpad.shape === "rotated_pill") {
+        pads.push({
+          shape: "pill",
+          padId: smtpad.pcb_smtpad_id,
+          layer: smtpad.layer,
+          connectivityKey,
+          x: smtpad.x,
+          y: smtpad.y,
+          width: smtpad.width!,
+          height: smtpad.height!,
+          radius: smtpad.radius!,
+          ccwRotation:
+            smtpad.shape === "rotated_pill" ? smtpad.ccw_rotation : 0,
+        } as InputPillPad)
       }
     } else if (elm.type === "pcb_plated_hole") {
       const platedHole = elm as PcbPlatedHole
       if (!platedHole.layers.includes(options.layer)) continue
 
-      let connectivityKey = connectivityMap.getNetConnectedToId(
+      let connectivityKey = getSubcircuitConnectivityKeyForId(
         platedHole.pcb_plated_hole_id,
       )
       if (!connectivityKey) {
@@ -174,7 +184,7 @@ export const convertCircuitJsonToInputProblem = (
       if (!via.layers.includes(options.layer)) continue
 
       const connectivityKey: string =
-        connectivityMap.getNetConnectedToId(via.pcb_via_id) ??
+        getSubcircuitConnectivityKeyForId(via.pcb_via_id) ??
         `unconnected-via:${via.pcb_via_id}`
 
       pads.push({
@@ -188,7 +198,7 @@ export const convertCircuitJsonToInputProblem = (
       } as InputCircularPad)
     } else if (elm.type === "pcb_trace") {
       const trace = elm as PcbTrace
-      const connectivityKey = connectivityMap.getNetConnectedToId(
+      const connectivityKey = getSubcircuitConnectivityKeyForId(
         trace.pcb_trace_id,
       )
       if (!connectivityKey) continue
@@ -256,7 +266,7 @@ export const convertCircuitJsonToInputProblem = (
       layer: options.layer,
       bounds,
       outline,
-      connectivityKey: options.pour_connectivity_key,
+      connectivityKey: pourConnectivityKey,
       padMargin: options.pad_margin,
       traceMargin: options.trace_margin,
       board_edge_margin: options.board_edge_margin ?? 0,