@tscircuit/schematic-trace-solver 0.0.35 → 0.0.37

package/dist/index.d.ts

@@ -79,6 +79,7 @@ interface InputDirectConnection {
 interface InputNetConnection {
     netId: string;
     pinIds: Array<PinId>;
+    netLabelWidth?: number;
 }
 interface InputProblem {
     chips: Array<InputChip>;
@@ -279,6 +280,7 @@ declare class SingleNetLabelPlacementSolver extends BaseSolver {
     overlappingSameNetTraceGroup: OverlappingSameNetTraceGroup;
     availableOrientations: Array<FacingDirection>;
     chipObstacleSpatialIndex: ChipObstacleSpatialIndex;
+    netLabelWidth?: number;
     netLabelPlacement: NetLabelPlacement | null;
     testedCandidates: Array<{
         center: {
@@ -306,6 +308,7 @@ declare class SingleNetLabelPlacementSolver extends BaseSolver {
         inputTraceMap: Record<MspConnectionPairId, SolvedTracePath>;
         overlappingSameNetTraceGroup: OverlappingSameNetTraceGroup;
         availableOrientations: FacingDirection[];
+        netLabelWidth?: number;
     });
     getConstructorParams(): ConstructorParameters<typeof SingleNetLabelPlacementSolver>[0];
     _step(): void;

package/dist/index.js

@@ -776,10 +776,17 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
       return;
     }
     const { path, collisionChipIds } = state;
+    const [PA, PB] = this.pins;
     const collision = findFirstCollision(path, this.obstacles);
     if (!collision) {
-      this.solvedTracePath = path;
-      this.solved = true;
+      const first = path[0];
+      const last = path[path.length - 1];
+      const EPS4 = 1e-9;
+      const samePoint = (p, q) => Math.abs(p.x - q.x) < EPS4 && Math.abs(p.y - q.y) < EPS4;
+      if (samePoint(first, { x: PA.x, y: PA.y }) && samePoint(last, { x: PB.x, y: PB.y })) {
+        this.solvedTracePath = path;
+        this.solved = true;
+      }
       return;
     }
     let { segIndex, rect } = collision;
@@ -802,7 +809,6 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
     if (!axis) {
       return;
     }
-    const [PA, PB] = this.pins;
     const candidates = [];
     if (collisionChipIds.size === 0) {
       const m1 = midBetweenPointAndRect(axis, { x: PA.x, y: PA.y }, rect);
@@ -1371,15 +1377,18 @@ var ChipObstacleSpatialIndex = class {
 // lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry.ts
 var NET_LABEL_HORIZONTAL_WIDTH = 0.45;
 var NET_LABEL_HORIZONTAL_HEIGHT = 0.2;
-function getDimsForOrientation(orientation) {
+function getDimsForOrientation(params) {
+  const { orientation, netLabelWidth } = params;
+  const horizWidth = typeof netLabelWidth === "number" ? netLabelWidth : NET_LABEL_HORIZONTAL_WIDTH;
   if (orientation === "y+" || orientation === "y-") {
     return {
+      // Rotated, so width/height swap
       width: NET_LABEL_HORIZONTAL_HEIGHT,
-      height: NET_LABEL_HORIZONTAL_WIDTH
+      height: horizWidth
     };
   }
   return {
-    width: NET_LABEL_HORIZONTAL_WIDTH,
+    width: horizWidth,
     height: NET_LABEL_HORIZONTAL_HEIGHT
   };
 }
@@ -1508,7 +1517,8 @@ function solveNetLabelPlacementForPortOnlyPin(params) {
     inputTraceMap,
     chipObstacleSpatialIndex,
     overlappingSameNetTraceGroup,
-    availableOrientations
+    availableOrientations,
+    netLabelWidth
   } = params;
   const pinId = overlappingSameNetTraceGroup.portOnlyPinId;
   if (!pinId) {
@@ -1540,7 +1550,10 @@ function solveNetLabelPlacementForPortOnlyPin(params) {
   const outwardOf = (o) => o === "x+" ? { x: 1, y: 0 } : o === "x-" ? { x: -1, y: 0 } : o === "y+" ? { x: 0, y: 1 } : { x: 0, y: -1 };
   const testedCandidates = [];
   for (const orientation of orientations) {
-    const { width: width2, height: height2 } = getDimsForOrientation(orientation);
+    const { width: width2, height: height2 } = getDimsForOrientation({
+      orientation,
+      netLabelWidth
+    });
     const baseCenter2 = getCenterFromAnchor(anchor, orientation, width2, height2);
     const outward2 = outwardOf(orientation);
     const offset2 = 1e-3;
@@ -1607,7 +1620,10 @@ function solveNetLabelPlacementForPortOnlyPin(params) {
     return { placement, testedCandidates };
   }
   const fallbackOrientation = pinFacingDirection;
-  const { width, height } = getDimsForOrientation(fallbackOrientation);
+  const { width, height } = getDimsForOrientation({
+    orientation: fallbackOrientation,
+    netLabelWidth
+  });
   const baseCenter = getCenterFromAnchor(
     anchor,
     fallbackOrientation,
@@ -1699,6 +1715,8 @@ var SingleNetLabelPlacementSolver = class extends BaseSolver {
   overlappingSameNetTraceGroup;
   availableOrientations;
   chipObstacleSpatialIndex;
+  // Optional override for the width of the net label (per netId)
+  netLabelWidth;
   netLabelPlacement = null;
   testedCandidates = [];
   constructor(params) {
@@ -1707,6 +1725,7 @@ var SingleNetLabelPlacementSolver = class extends BaseSolver {
     this.inputTraceMap = params.inputTraceMap;
     this.overlappingSameNetTraceGroup = params.overlappingSameNetTraceGroup;
     this.availableOrientations = params.availableOrientations;
+    this.netLabelWidth = params.netLabelWidth;
     this.chipObstacleSpatialIndex = params.inputProblem._chipObstacleSpatialIndex ?? new ChipObstacleSpatialIndex(params.inputProblem.chips);
   }
   getConstructorParams() {
@@ -1714,7 +1733,8 @@ var SingleNetLabelPlacementSolver = class extends BaseSolver {
       inputProblem: this.inputProblem,
       inputTraceMap: this.inputTraceMap,
       overlappingSameNetTraceGroup: this.overlappingSameNetTraceGroup,
-      availableOrientations: this.availableOrientations
+      availableOrientations: this.availableOrientations,
+      netLabelWidth: this.netLabelWidth
     };
   }
   _step() {
@@ -1728,7 +1748,8 @@ var SingleNetLabelPlacementSolver = class extends BaseSolver {
         inputTraceMap: this.inputTraceMap,
         chipObstacleSpatialIndex: this.chipObstacleSpatialIndex,
         overlappingSameNetTraceGroup: this.overlappingSameNetTraceGroup,
-        availableOrientations: this.availableOrientations
+        availableOrientations: this.availableOrientations,
+        netLabelWidth: this.netLabelWidth
       });
       this.testedCandidates.push(...res.testedCandidates);
       if (res.placement) {
@@ -1796,7 +1817,10 @@ var SingleNetLabelPlacementSolver = class extends BaseSolver {
         const anchors = anchorsForSegment(a, b);
         for (const anchor of anchors) {
           for (const orientation of candidateOrients) {
-            const { width, height } = getDimsForOrientation(orientation);
+            const { width, height } = getDimsForOrientation({
+              orientation,
+              netLabelWidth: this.netLabelWidth
+            });
             const center = getCenterFromAnchor(
               anchor,
               orientation,
@@ -2075,11 +2099,15 @@ var NetLabelPlacementSolver = class extends BaseSolver {
       const isAlreadyFull = currOrients.length === 4 && fullOrients.every((o) => currOrients.includes(o));
       if (!this.triedAnyOrientationFallbackForCurrentGroup && !isAlreadyFull && this.currentGroup) {
         this.triedAnyOrientationFallbackForCurrentGroup = true;
+        const netLabelWidth2 = this.currentGroup.netId ? this.inputProblem.netConnections.find(
+          (nc) => nc.netId === this.currentGroup.netId
+        )?.netLabelWidth : void 0;
         this.activeSubSolver = new SingleNetLabelPlacementSolver({
           inputProblem: this.inputProblem,
           inputTraceMap: this.inputTraceMap,
           overlappingSameNetTraceGroup: this.currentGroup,
-          availableOrientations: fullOrients
+          availableOrientations: fullOrients,
+          netLabelWidth: netLabelWidth2
         });
         return;
       }
@@ -2099,11 +2127,15 @@ var NetLabelPlacementSolver = class extends BaseSolver {
     const netId = nextOverlappingSameNetTraceGroup.netId ?? nextOverlappingSameNetTraceGroup.globalConnNetId;
     this.currentGroup = nextOverlappingSameNetTraceGroup;
     this.triedAnyOrientationFallbackForCurrentGroup = false;
+    const netLabelWidth = this.currentGroup.netId ? this.inputProblem.netConnections.find(
+      (nc) => nc.netId === this.currentGroup.netId
+    )?.netLabelWidth : void 0;
     this.activeSubSolver = new SingleNetLabelPlacementSolver({
       inputProblem: this.inputProblem,
       inputTraceMap: this.inputTraceMap,
       overlappingSameNetTraceGroup: nextOverlappingSameNetTraceGroup,
-      availableOrientations: this.inputProblem.availableNetLabelOrientations[netId] ?? ["x+", "x-", "y+", "y-"]
+      availableOrientations: this.inputProblem.availableNetLabelOrientations[netId] ?? ["x+", "x-", "y+", "y-"],
+      netLabelWidth
     });
   }
   visualize() {

package/lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver.ts

@@ -273,11 +273,17 @@ export class NetLabelPlacementSolver extends BaseSolver {
         this.currentGroup
       ) {
         this.triedAnyOrientationFallbackForCurrentGroup = true
+        const netLabelWidth = this.currentGroup.netId
+          ? this.inputProblem.netConnections.find(
+              (nc) => nc.netId === this.currentGroup!.netId,
+            )?.netLabelWidth
+          : undefined
         this.activeSubSolver = new SingleNetLabelPlacementSolver({
           inputProblem: this.inputProblem,
           inputTraceMap: this.inputTraceMap,
           overlappingSameNetTraceGroup: this.currentGroup,
           availableOrientations: fullOrients,
+          netLabelWidth,
         })
         return
       }
@@ -307,6 +313,12 @@ export class NetLabelPlacementSolver extends BaseSolver {
     this.currentGroup = nextOverlappingSameNetTraceGroup
     this.triedAnyOrientationFallbackForCurrentGroup = false
 
+    const netLabelWidth = this.currentGroup.netId
+      ? this.inputProblem.netConnections.find(
+          (nc) => nc.netId === this.currentGroup!.netId,
+        )?.netLabelWidth
+      : undefined
+
     this.activeSubSolver = new SingleNetLabelPlacementSolver({
       inputProblem: this.inputProblem,
       inputTraceMap: this.inputTraceMap,
@@ -314,6 +326,7 @@ export class NetLabelPlacementSolver extends BaseSolver {
       availableOrientations: this.inputProblem.availableNetLabelOrientations[
         netId
       ] ?? ["x+", "x-", "y+", "y-"],
+      netLabelWidth,
     })
   }
 

package/lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/SingleNetLabelPlacementSolver.ts

@@ -58,6 +58,9 @@ export class SingleNetLabelPlacementSolver extends BaseSolver {
 
   chipObstacleSpatialIndex: ChipObstacleSpatialIndex
 
+  // Optional override for the width of the net label (per netId)
+  netLabelWidth?: number
+
   netLabelPlacement: NetLabelPlacement | null = null
   testedCandidates: Array<{
     center: { x: number; y: number }
@@ -75,12 +78,14 @@ export class SingleNetLabelPlacementSolver extends BaseSolver {
     inputTraceMap: Record<MspConnectionPairId, SolvedTracePath>
     overlappingSameNetTraceGroup: OverlappingSameNetTraceGroup
     availableOrientations: FacingDirection[]
+    netLabelWidth?: number
   }) {
     super()
     this.inputProblem = params.inputProblem
     this.inputTraceMap = params.inputTraceMap
     this.overlappingSameNetTraceGroup = params.overlappingSameNetTraceGroup
     this.availableOrientations = params.availableOrientations
+    this.netLabelWidth = params.netLabelWidth
 
     this.chipObstacleSpatialIndex =
       params.inputProblem._chipObstacleSpatialIndex ??
@@ -95,6 +100,7 @@ export class SingleNetLabelPlacementSolver extends BaseSolver {
       inputTraceMap: this.inputTraceMap,
       overlappingSameNetTraceGroup: this.overlappingSameNetTraceGroup,
       availableOrientations: this.availableOrientations,
+      netLabelWidth: this.netLabelWidth,
     }
   }
 
@@ -112,6 +118,7 @@ export class SingleNetLabelPlacementSolver extends BaseSolver {
         chipObstacleSpatialIndex: this.chipObstacleSpatialIndex,
         overlappingSameNetTraceGroup: this.overlappingSameNetTraceGroup,
         availableOrientations: this.availableOrientations,
+        netLabelWidth: this.netLabelWidth,
       })
       this.testedCandidates.push(...res.testedCandidates)
       if (res.placement) {
@@ -220,7 +227,10 @@ export class SingleNetLabelPlacementSolver extends BaseSolver {
         const anchors = anchorsForSegment(a, b)
         for (const anchor of anchors) {
           for (const orientation of candidateOrients) {
-            const { width, height } = getDimsForOrientation(orientation)
+            const { width, height } = getDimsForOrientation({
+              orientation,
+              netLabelWidth: this.netLabelWidth,
+            })
             const center = getCenterFromAnchor(
               anchor,
               orientation,

package/lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry.ts

@@ -3,15 +3,25 @@ import type { FacingDirection } from "lib/utils/dir"
 export const NET_LABEL_HORIZONTAL_WIDTH = 0.45
 export const NET_LABEL_HORIZONTAL_HEIGHT = 0.2
 
-export function getDimsForOrientation(orientation: FacingDirection) {
+export function getDimsForOrientation(params: {
+  orientation: FacingDirection
+  netLabelWidth?: number
+}) {
+  const { orientation, netLabelWidth } = params
+  const horizWidth =
+    typeof netLabelWidth === "number"
+      ? netLabelWidth
+      : NET_LABEL_HORIZONTAL_WIDTH
+
   if (orientation === "y+" || orientation === "y-") {
     return {
+      // Rotated, so width/height swap
       width: NET_LABEL_HORIZONTAL_HEIGHT,
-      height: NET_LABEL_HORIZONTAL_WIDTH,
+      height: horizWidth,
     }
   }
   return {
-    width: NET_LABEL_HORIZONTAL_WIDTH,
+    width: horizWidth,
     height: NET_LABEL_HORIZONTAL_HEIGHT,
   }
 }

package/lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/solvePortOnlyPin.ts

@@ -21,6 +21,7 @@ export function solveNetLabelPlacementForPortOnlyPin(params: {
   chipObstacleSpatialIndex: ChipObstacleSpatialIndex
   overlappingSameNetTraceGroup: OverlappingSameNetTraceGroup
   availableOrientations: FacingDirection[]
+  netLabelWidth?: number
 }): {
   placement: NetLabelPlacement | null
   testedCandidates: Array<{
@@ -41,6 +42,7 @@ export function solveNetLabelPlacementForPortOnlyPin(params: {
     chipObstacleSpatialIndex,
     overlappingSameNetTraceGroup,
     availableOrientations,
+    netLabelWidth,
   } = params
 
   const pinId = overlappingSameNetTraceGroup.portOnlyPinId
@@ -98,7 +100,10 @@ export function solveNetLabelPlacementForPortOnlyPin(params: {
   }> = []
 
   for (const orientation of orientations) {
-    const { width, height } = getDimsForOrientation(orientation)
+    const { width, height } = getDimsForOrientation({
+      orientation,
+      netLabelWidth,
+    })
     // Place label fully outside the chip: shift center slightly outward
     const baseCenter = getCenterFromAnchor(anchor, orientation, width, height)
     const outward = outwardOf(orientation)
@@ -176,7 +181,10 @@ export function solveNetLabelPlacementForPortOnlyPin(params: {
 
   // If no valid placements found, return placement using pin's facing direction
   const fallbackOrientation = pinFacingDirection
-  const { width, height } = getDimsForOrientation(fallbackOrientation)
+  const { width, height } = getDimsForOrientation({
+    orientation: fallbackOrientation,
+    netLabelWidth,
+  })
   const baseCenter = getCenterFromAnchor(
     anchor,
     fallbackOrientation,

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/SchematicTraceSingleLineSolver2.ts

@@ -129,11 +129,23 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
 
     const { path, collisionChipIds } = state
 
+    const [PA, PB] = this.pins
     const collision = findFirstCollision(path, this.obstacles)
 
     if (!collision) {
-      this.solvedTracePath = path
-      this.solved = true
+      // Sanity check: ensure path still connects PA -> PB
+      const first = path[0]!
+      const last = path[path.length - 1]!
+      const EPS = 1e-9
+      const samePoint = (p: Point, q: Point) =>
+        Math.abs(p.x - q.x) < EPS && Math.abs(p.y - q.y) < EPS
+      if (
+        samePoint(first, { x: PA.x, y: PA.y }) &&
+        samePoint(last, { x: PB.x, y: PB.y })
+      ) {
+        this.solvedTracePath = path
+        this.solved = true
+      }
       return
     }
 
@@ -167,7 +179,7 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
       return
     }
 
-    const [PA, PB] = this.pins
+    // Note: PA and PB are already defined above
     const candidates: number[] = []
 
     if (collisionChipIds.size === 0) {

package/lib/types/InputProblem.ts

@@ -27,6 +27,7 @@ export interface InputDirectConnection {
 export interface InputNetConnection {
   netId: string
   pinIds: Array<PinId>
+  netLabelWidth?: number
 }
 
 export interface InputProblem {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/schematic-trace-solver",
   "main": "dist/index.js",
-  "version": "0.0.35",
+  "version": "0.0.37",
   "type": "module",
   "scripts": {
     "start": "cosmos",

package/site/examples/example21.page.tsx

@@ -0,0 +1,177 @@
+import { PipelineDebugger } from "site/components/PipelineDebugger"
+import type { InputProblem } from "lib/types/InputProblem"
+
+const inputProblem: InputProblem = {
+  chips: [
+    {
+      chipId: "schematic_component_0",
+      center: {
+        x: 0,
+        y: 0,
+      },
+      width: 2,
+      height: 2,
+      pins: [
+        {
+          pinId: "CORNERS.1",
+          x: -1.4,
+          y: -0.6,
+        },
+        {
+          pinId: "CORNERS.2",
+          x: -1.4,
+          y: 0.6,
+        },
+        {
+          pinId: "CORNERS.3",
+          x: 1.4,
+          y: 0.6,
+        },
+        {
+          pinId: "CORNERS.4",
+          x: 1.4,
+          y: -0.6,
+        },
+      ],
+    },
+    {
+      chipId: "schematic_component_1",
+      center: {
+        x: 4.785,
+        y: -0.3999999999999999,
+      },
+      width: 1.2000000000000002,
+      height: 1,
+      pins: [
+        {
+          pinId: "U100.1",
+          x: 3.785,
+          y: -0.29999999999999993,
+        },
+        {
+          pinId: "U100.2",
+          x: 4.785,
+          y: -1.2999999999999998,
+        },
+        {
+          pinId: "U100.3",
+          x: 3.785,
+          y: -0.4999999999999999,
+        },
+        {
+          pinId: "U100.5",
+          x: 5.785,
+          y: -0.3999999999999999,
+        },
+      ],
+    },
+    {
+      chipId: "schematic_component_2",
+      center: {
+        x: 6.7,
+        y: -0.9499999999999993,
+      },
+      width: 0.53,
+      height: 1.06,
+      pins: [
+        {
+          pinId: "C101.1",
+          x: 6.7,
+          y: -0.39999999999999925,
+        },
+        {
+          pinId: "C101.2",
+          x: 6.7,
+          y: -1.4999999999999993,
+        },
+      ],
+    },
+    {
+      chipId: "schematic_component_3",
+      center: {
+        x: 2.8699999999999997,
+        y: -1.75,
+      },
+      width: 0.53,
+      height: 1.06,
+      pins: [
+        {
+          pinId: "C100.1",
+          x: 2.8699999999999997,
+          y: -1.2,
+        },
+        {
+          pinId: "C100.2",
+          x: 2.8699999999999997,
+          y: -2.3,
+        },
+      ],
+    },
+    {
+      chipId: "schematic_component_4",
+      center: {
+        x: 2.9752723250000006,
+        y: 0.050000000000000266,
+      },
+      width: 0.3194553499999995,
+      height: 1.06,
+      pins: [
+        {
+          pinId: "R100.1",
+          x: 2.9752723250000006,
+          y: 0.6000000000000001,
+        },
+        {
+          pinId: "R100.2",
+          x: 2.9752723250000006,
+          y: -0.4999999999999998,
+        },
+      ],
+    },
+  ],
+  directConnections: [
+    {
+      pinIds: ["C101.1", "U100.5"],
+      netId: "group > capacitor.C101 > port.pin1 to U100.VOUT",
+    },
+    {
+      pinIds: ["C100.1", "U100.1"],
+      netId: "group > capacitor.C100 > port.pin1 to U100.VIN",
+    },
+    {
+      pinIds: ["R100.2", "U100.3"],
+      netId: "group > resistor.R100 > port.pin2 to U100.EN",
+    },
+  ],
+  netConnections: [
+    {
+      netId: "GND",
+      pinIds: ["CORNERS.1", "CORNERS.4", "U100.2", "C101.2", "C100.2"],
+      netLabelWidth: 0.3,
+    },
+    {
+      netId: "VIN",
+      pinIds: ["CORNERS.2", "U100.1", "C100.1", "R100.1"],
+      netLabelWidth: 0.3,
+    },
+    {
+      netId: "VOUT",
+      pinIds: ["CORNERS.3", "U100.5", "C101.1"],
+      netLabelWidth: 0.4,
+    },
+    {
+      netId: "LDO_EN",
+      pinIds: ["U100.3", "R100.2"],
+      netLabelWidth: 0.6,
+    },
+  ],
+  availableNetLabelOrientations: {
+    GND: ["y-"],
+    VIN: ["y+"],
+    VOUT: ["y+"],
+    LDO_EN: ["x-", "x+"],
+  },
+  maxMspPairDistance: 2.4,
+} as InputProblem
+
+export default () => <PipelineDebugger inputProblem={inputProblem} />