@tscircuit/schematic-trace-solver 0.0.20 → 0.0.22

package/.github/workflows/bun-pver-release.yml

@@ -4,6 +4,9 @@ on:
   push:
     branches:
       - main
+    paths:
+      - 'lib/**'
+  workflow_dispatch:
 jobs:
   publish:
     runs-on: ubuntu-latest

package/dist/index.d.ts

@@ -161,6 +161,7 @@ declare class SchematicTraceSingleLineSolver extends BaseSolver {
     chipMap: Record<string, InputChip>;
     movableSegments: Array<MovableSegment>;
     baseElbow: Point[];
+    allCandidatePaths: Array<Point[]>;
     queuedCandidatePaths: Array<Point[]>;
     chipObstacleSpatialIndex: ChipObstacleSpatialIndex;
     solvedTracePath: {
@@ -343,6 +344,7 @@ type OverlappingSameNetTraceGroup = {
     netId?: string;
     overlappingTraces?: SolvedTracePath;
     portOnlyPinId?: string;
+    mspConnectionPairIds?: MspConnectionPairId[];
 };
 interface NetLabelPlacement {
     globalConnNetId: string;

package/dist/index.js

@@ -6520,81 +6520,167 @@ var dir = (facingDirection) => {
 };
 
 // lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/generateElbowVariants.ts
-var generateElbowVariants = ({
-  baseElbow,
-  guidelines
-}) => {
-  const movableSegments = [];
-  for (let i = 1; i < baseElbow.length - 2; i++) {
-    const prev = baseElbow[i - 1];
-    const start = baseElbow[i];
-    const end = baseElbow[i + 1];
-    const isHorz = Math.abs(start.y - end.y) < 1e-6;
-    let freedom;
-    if (isHorz) {
-      freedom = prev.y <= start.y ? "y+" : "y-";
-    } else {
-      freedom = prev.x <= start.x ? "x+" : "x-";
+var EPS = 1e-6;
+var MIN_LEN = 1e-6;
+var isAxisAligned = (a, b) => Math.abs(a.x - b.x) < EPS || Math.abs(a.y - b.y) < EPS;
+var orientationOf = (a, b) => {
+  const dx = Math.abs(a.x - b.x);
+  const dy = Math.abs(a.y - b.y);
+  if (dx < EPS && dy >= EPS) return "vertical";
+  if (dy < EPS && dx >= EPS) return "horizontal";
+  throw new Error("Non-orthogonal or degenerate segment detected.");
+};
+var assertOrthogonalPolyline = (pts) => {
+  if (pts.length < 2) {
+    throw new Error("Polyline must have at least two points.");
+  }
+  for (let i = 0; i < pts.length - 1; i++) {
+    const a = pts[i];
+    const b = pts[i + 1];
+    if (!isAxisAligned(a, b)) {
+      throw new Error("Polyline contains a non-orthogonal segment.");
+    }
+    const manhattan = Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
+    if (manhattan < MIN_LEN) {
+      throw new Error("Polyline contains a near-zero length segment.");
     }
-    movableSegments.push({ start, end, freedom, dir: dir(freedom) });
   }
-  const segmentGuidelineOptions = [];
-  for (const segment of movableSegments) {
-    const relevantPositions = [];
-    if (segment.freedom === "x+" || segment.freedom === "x-") {
-      for (const guideline of guidelines) {
-        if (guideline.orientation === "vertical" && guideline.x !== void 0) {
-          relevantPositions.push(guideline.x);
-        }
+};
+var uniqSortedWithTol = (vals, tol = EPS) => {
+  const sorted = vals.slice().sort((a, b) => a - b);
+  const out = [];
+  for (const v of sorted) {
+    if (out.length === 0 || Math.abs(v - out[out.length - 1]) > tol) out.push(v);
+  }
+  return out;
+};
+var keyForPolyline = (pts, decimals = 9) => pts.map((p) => `${p.x.toFixed(decimals)},${p.y.toFixed(decimals)}`).join("|");
+var preprocessElbow = (pts, tol = MIN_LEN) => {
+  if (pts.length === 0) return [];
+  const out = [{ ...pts[0] }];
+  for (let i = 1; i < pts.length; i++) {
+    const p = pts[i];
+    const last = out[out.length - 1];
+    const manhattan = Math.abs(p.x - last.x) + Math.abs(p.y - last.y);
+    if (manhattan > tol) out.push({ ...p });
+  }
+  return out;
+};
+var collectAxisCandidates = (axis, guidelines, currentCoord) => {
+  const positions = [];
+  for (const g of guidelines) {
+    if (axis === "x") {
+      if (g.orientation === "vertical" && typeof g.x === "number") {
+        positions.push(g.x);
       }
-      relevantPositions.push(segment.start.x);
     } else {
-      for (const guideline of guidelines) {
-        if (guideline.orientation === "horizontal" && guideline.y !== void 0) {
-          relevantPositions.push(guideline.y);
-        }
+      if (g.orientation === "horizontal" && typeof g.y === "number") {
+        positions.push(g.y);
       }
-      relevantPositions.push(segment.start.y);
     }
-    segmentGuidelineOptions.push(
-      [...new Set(relevantPositions)].sort((a, b) => a - b)
-    );
   }
-  const generateCombinations = (options) => {
-    if (options.length === 0) return [[]];
-    if (options.length === 1) return options[0].map((pos) => [pos]);
-    const combinations = [];
-    const firstOptions = options[0];
-    const restCombinations = generateCombinations(options.slice(1));
-    for (const firstOption of firstOptions) {
-      for (const restCombination of restCombinations) {
-        combinations.push([firstOption, ...restCombination]);
+  positions.push(currentCoord);
+  return uniqSortedWithTol(positions);
+};
+var computeFreedom = (prev, start, end) => {
+  const orient = orientationOf(start, end);
+  if (orient === "horizontal") {
+    const facing = prev.y <= start.y ? "y+" : "y-";
+    return { axis: "y", facing };
+  } else {
+    const facing = prev.x <= start.x ? "x+" : "x-";
+    return { axis: "x", facing };
+  }
+};
+var cartesian = (arrays) => arrays.length === 0 ? [[]] : arrays.reduce(
+  (acc, curr) => acc.flatMap((a) => curr.map((c) => [...a, c])),
+  [[]]
+);
+var generateElbowVariants = ({
+  baseElbow,
+  guidelines
+}) => {
+  const elbow = preprocessElbow(baseElbow);
+  assertOrthogonalPolyline(elbow);
+  const nPts = elbow.length;
+  const nSegs = nPts - 1;
+  if (nSegs < 5) {
+    return {
+      elbowVariants: [elbow.map((p) => ({ ...p }))],
+      movableSegments: []
+    };
+  }
+  const firstMovableIndex = 2;
+  const lastMovableIndex = nPts - 4;
+  const movableSegments = [];
+  const movableIdx = [];
+  const axes = [];
+  const optionsPerSegment = [];
+  for (let i = firstMovableIndex; i <= lastMovableIndex; i++) {
+    const prev = elbow[i - 1];
+    const start = elbow[i];
+    const end = elbow[i + 1];
+    const next2 = elbow[i + 2];
+    const { axis, facing } = computeFreedom(prev, start, end);
+    movableSegments.push({
+      start: { ...start },
+      end: { ...end },
+      freedom: facing,
+      dir: dir(facing)
+    });
+    movableIdx.push(i);
+    axes.push(axis);
+    const currentCoord = axis === "x" ? start.x : start.y;
+    const rawCandidates = collectAxisCandidates(axis, guidelines, currentCoord);
+    const filtered = rawCandidates.filter((pos) => {
+      if (axis === "y") {
+        const lenPrev = Math.abs(prev.y - pos);
+        const lenNext = Math.abs(next2.y - pos);
+        return lenPrev > MIN_LEN && lenNext > MIN_LEN;
+      } else {
+        const lenPrev = Math.abs(prev.x - pos);
+        const lenNext = Math.abs(next2.x - pos);
+        return lenPrev > MIN_LEN && lenNext > MIN_LEN;
       }
-    }
-    return combinations;
-  };
-  const positionCombinations = generateCombinations(segmentGuidelineOptions);
+    });
+    optionsPerSegment.push(filtered);
+  }
+  const combos = cartesian(optionsPerSegment);
+  const seen = /* @__PURE__ */ new Set();
   const elbowVariants = [];
-  for (const combination of positionCombinations) {
-    const variant = [...baseElbow];
-    for (let segmentIndex = 0; segmentIndex < movableSegments.length; segmentIndex++) {
-      const segment = movableSegments[segmentIndex];
-      const newPosition = combination[segmentIndex];
-      const elbowIndex = segmentIndex + 1;
-      if (segment.freedom === "x+" || segment.freedom === "x-") {
-        variant[elbowIndex] = { ...variant[elbowIndex], x: newPosition };
-        variant[elbowIndex + 1] = { ...variant[elbowIndex + 1], x: newPosition };
+  {
+    const key = keyForPolyline(elbow);
+    seen.add(key);
+    elbowVariants.push(elbow.map((p) => ({ ...p })));
+  }
+  for (const combo of combos) {
+    if (combo.length === 0) continue;
+    const variant = elbow.map((p) => ({ ...p }));
+    for (let k = 0; k < movableIdx.length; k++) {
+      const segIndex = movableIdx[k];
+      const axis = axes[k];
+      const newPos = combo[k];
+      if (typeof newPos !== "number" || Number.isNaN(newPos)) continue;
+      if (axis === "y") {
+        variant[segIndex] = { ...variant[segIndex], y: newPos };
+        variant[segIndex + 1] = { ...variant[segIndex + 1], y: newPos };
       } else {
-        variant[elbowIndex] = { ...variant[elbowIndex], y: newPosition };
-        variant[elbowIndex + 1] = { ...variant[elbowIndex + 1], y: newPosition };
+        variant[segIndex] = { ...variant[segIndex], x: newPos };
+        variant[segIndex + 1] = { ...variant[segIndex + 1], x: newPos };
       }
     }
-    elbowVariants.push(variant);
+    try {
+      assertOrthogonalPolyline(variant);
+    } catch {
+      continue;
+    }
+    const key = keyForPolyline(variant);
+    if (!seen.has(key)) {
+      seen.add(key);
+      elbowVariants.push(variant);
+    }
   }
-  return {
-    elbowVariants,
-    movableSegments
-  };
+  return { elbowVariants, movableSegments };
 };
 
 // lib/solvers/GuidelinesSolver/visualizeGuidelines.ts
@@ -6642,6 +6728,7 @@ var SchematicTraceSingleLineSolver = class extends BaseSolver {
   chipMap;
   movableSegments;
   baseElbow;
+  allCandidatePaths;
   queuedCandidatePaths;
   chipObstacleSpatialIndex;
   solvedTracePath = null;
@@ -6691,7 +6778,8 @@ var SchematicTraceSingleLineSolver = class extends BaseSolver {
       }
       return len;
     };
-    this.queuedCandidatePaths = [this.baseElbow, ...elbowVariants].sort(
+    this.allCandidatePaths = [this.baseElbow, ...elbowVariants];
+    this.queuedCandidatePaths = [...this.allCandidatePaths].sort(
       (a, b) => getPathLength(a) - getPathLength(b)
     );
   }
@@ -6728,12 +6816,12 @@ var SchematicTraceSingleLineSolver = class extends BaseSolver {
           const bounds = getInputChipBounds(this.chipMap[startPin.chipId]);
           const dx = end.x - start.x;
           const dy = end.y - start.y;
-          const EPS = 1e-9;
+          const EPS2 = 1e-9;
           const onLeft = Math.abs(start.x - bounds.minX) < 1e-9;
           const onRight = Math.abs(start.x - bounds.maxX) < 1e-9;
           const onBottom = Math.abs(start.y - bounds.minY) < 1e-9;
           const onTop = Math.abs(start.y - bounds.maxY) < 1e-9;
-          const entersInterior = onLeft && dx > EPS || onRight && dx < -EPS || onBottom && dy > EPS || onTop && dy < -EPS;
+          const entersInterior = onLeft && dx > EPS2 || onRight && dx < -EPS2 || onBottom && dy > EPS2 || onTop && dy < -EPS2;
           if (entersInterior) return;
           if (!excludeChipIds.includes(startPin.chipId)) {
             excludeChipIds.push(startPin.chipId);
@@ -6748,12 +6836,12 @@ var SchematicTraceSingleLineSolver = class extends BaseSolver {
           const bounds = getInputChipBounds(this.chipMap[endPin.chipId]);
           const dx = start.x - end.x;
           const dy = start.y - end.y;
-          const EPS = 1e-9;
+          const EPS2 = 1e-9;
           const onLeft = Math.abs(end.x - bounds.minX) < 1e-9;
           const onRight = Math.abs(end.x - bounds.maxX) < 1e-9;
           const onBottom = Math.abs(end.y - bounds.minY) < 1e-9;
           const onTop = Math.abs(end.y - bounds.maxY) < 1e-9;
-          const entersInterior = onLeft && dx > EPS || onRight && dx < -EPS || onBottom && dy > EPS || onTop && dy < -EPS;
+          const entersInterior = onLeft && dx > EPS2 || onRight && dx < -EPS2 || onBottom && dy > EPS2 || onTop && dy < -EPS2;
           if (entersInterior) return;
           if (!excludeChipIds.includes(endPin.chipId)) {
             excludeChipIds.push(endPin.chipId);
@@ -6956,13 +7044,13 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
     }
   }
   _step() {
-    const EPS = 1e-6;
+    const EPS2 = 1e-6;
     const offsets = this.overlappingTraceSegments.map((_, idx) => {
       const n = Math.floor(idx / 2) + 1;
       const signed = idx % 2 === 0 ? -n : n;
       return signed * this.SHIFT_DISTANCE;
     });
-    const eq = (a, b) => Math.abs(a - b) < EPS;
+    const eq = (a, b) => Math.abs(a - b) < EPS2;
     const samePoint = (p, q) => !!p && !!q && eq(p.x, q.x) && eq(p.y, q.y);
     this.overlappingTraceSegments.forEach((group, gidx) => {
       const offset = offsets[gidx];
@@ -6985,8 +7073,8 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
           if (si === 0 || si === pts.length - 2) continue;
           const start = pts[si];
           const end = pts[si + 1];
-          const isVertical = Math.abs(start.x - end.x) < EPS;
-          const isHorizontal = Math.abs(start.y - end.y) < EPS;
+          const isVertical = Math.abs(start.x - end.x) < EPS2;
+          const isHorizontal = Math.abs(start.y - end.y) < EPS2;
           if (!isVertical && !isHorizontal) continue;
           if (isVertical) {
             if (!appliedX.has(si)) {
@@ -7095,7 +7183,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
     return islands;
   }
   findNextOverlapIssue() {
-    const EPS = 1e-6;
+    const EPS2 = 1e-6;
     const netIds = Object.keys(this.traceNetIslands);
     for (let i = 0; i < netIds.length; i++) {
       for (let j = i + 1; j < netIds.length; j++) {
@@ -7113,7 +7201,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
           const minB = Math.min(b1, b2);
           const maxB = Math.max(b1, b2);
           const overlap = Math.min(maxA, maxB) - Math.max(minA, minB);
-          return overlap > EPS;
+          return overlap > EPS2;
         };
         for (let pa = 0; pa < pathsA.length; pa++) {
           const pathA = pathsA[pa];
@@ -7121,8 +7209,8 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
           for (let sa = 0; sa < ptsA.length - 1; sa++) {
             const a1 = ptsA[sa];
             const a2 = ptsA[sa + 1];
-            const aVert = Math.abs(a1.x - a2.x) < EPS;
-            const aHorz = Math.abs(a1.y - a2.y) < EPS;
+            const aVert = Math.abs(a1.x - a2.x) < EPS2;
+            const aHorz = Math.abs(a1.y - a2.y) < EPS2;
             if (!aVert && !aHorz) continue;
             for (let pb = 0; pb < pathsB.length; pb++) {
               const pathB = pathsB[pb];
@@ -7130,11 +7218,11 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
               for (let sb = 0; sb < ptsB.length - 1; sb++) {
                 const b1 = ptsB[sb];
                 const b2 = ptsB[sb + 1];
-                const bVert = Math.abs(b1.x - b2.x) < EPS;
-                const bHorz = Math.abs(b1.y - b2.y) < EPS;
+                const bVert = Math.abs(b1.x - b2.x) < EPS2;
+                const bHorz = Math.abs(b1.y - b2.y) < EPS2;
                 if (!bVert && !bHorz) continue;
                 if (aVert && bVert) {
-                  if (Math.abs(a1.x - b1.x) < EPS) {
+                  if (Math.abs(a1.x - b1.x) < EPS2) {
                     if (overlaps1D(a1.y, a2.y, b1.y, b2.y)) {
                       const keyA = `${pa}:${sa}`;
                       const keyB = `${pb}:${sb}`;
@@ -7155,7 +7243,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
                     }
                   }
                 } else if (aHorz && bHorz) {
-                  if (Math.abs(a1.y - b1.y) < EPS) {
+                  if (Math.abs(a1.y - b1.y) < EPS2) {
                     if (overlaps1D(a1.x, a2.x, b1.x, b2.x)) {
                       const keyA = `${pa}:${sa}`;
                       const keyB = `${pb}:${sb}`;
@@ -7270,24 +7358,24 @@ function getRectBounds(center, w, h) {
 }
 
 // lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/collisions.ts
-function segmentIntersectsRect(p1, p2, rect, EPS = 1e-9) {
-  const isVert = Math.abs(p1.x - p2.x) < EPS;
-  const isHorz = Math.abs(p1.y - p2.y) < EPS;
+function segmentIntersectsRect(p1, p2, rect, EPS2 = 1e-9) {
+  const isVert = Math.abs(p1.x - p2.x) < EPS2;
+  const isHorz = Math.abs(p1.y - p2.y) < EPS2;
   if (!isVert && !isHorz) return false;
   if (isVert) {
     const x = p1.x;
-    if (x < rect.minX - EPS || x > rect.maxX + EPS) return false;
+    if (x < rect.minX - EPS2 || x > rect.maxX + EPS2) return false;
     const segMinY = Math.min(p1.y, p2.y);
     const segMaxY = Math.max(p1.y, p2.y);
     const overlap = Math.min(segMaxY, rect.maxY) - Math.max(segMinY, rect.minY);
-    return overlap > EPS;
+    return overlap > EPS2;
   } else {
     const y = p1.y;
-    if (y < rect.minY - EPS || y > rect.maxY + EPS) return false;
+    if (y < rect.minY - EPS2 || y > rect.maxY + EPS2) return false;
     const segMinX = Math.min(p1.x, p2.x);
     const segMaxX = Math.max(p1.x, p2.x);
     const overlap = Math.min(segMaxX, rect.maxX) - Math.max(segMinX, rect.minX);
-    return overlap > EPS;
+    return overlap > EPS2;
   }
 }
 function rectIntersectsAnyTrace(bounds, inputTraceMap, hostPathId, hostSegIndex) {
@@ -7311,13 +7399,25 @@ function lengthOfTrace(path) {
   return sum;
 }
 function chooseHostTraceForGroup(params) {
-  const { inputProblem, inputTraceMap, globalConnNetId, fallbackTrace } = params;
+  const {
+    inputProblem,
+    inputTraceMap,
+    globalConnNetId,
+    fallbackTrace,
+    mspConnectionPairIds
+  } = params;
   const chipsById = Object.fromEntries(
     inputProblem.chips.map((c) => [c.chipId, c])
   );
-  const groupTraces = Object.values(inputTraceMap).filter(
+  let groupTraces = Object.values(inputTraceMap).filter(
     (t) => t.globalConnNetId === globalConnNetId
   );
+  if (mspConnectionPairIds && mspConnectionPairIds.length > 0) {
+    const idSet = new Set(mspConnectionPairIds);
+    groupTraces = groupTraces.filter(
+      (t) => t.mspConnectionPairIds.some((id) => idSet.has(id))
+    );
+  }
   const chipIdsInGroup = /* @__PURE__ */ new Set();
   for (const t of groupTraces) {
     chipIdsInGroup.add(t.pins[0].chipId);
@@ -7566,15 +7666,19 @@ var SingleNetLabelPlacementSolver = class extends BaseSolver {
       inputProblem: this.inputProblem,
       inputTraceMap: this.inputTraceMap,
       globalConnNetId: groupId,
-      fallbackTrace: this.overlappingSameNetTraceGroup.overlappingTraces
+      fallbackTrace: this.overlappingSameNetTraceGroup.overlappingTraces,
+      mspConnectionPairIds: this.overlappingSameNetTraceGroup.mspConnectionPairIds
     });
     if (!host) {
       this.failed = true;
       this.error = "No host trace found for net label placement";
       return;
     }
+    const traceIdSet = new Set(
+      this.overlappingSameNetTraceGroup.mspConnectionPairIds ?? []
+    );
     const tracesToScanBase = Object.values(this.inputTraceMap).filter(
-      (t) => t.globalConnNetId === groupId
+      (t) => t.globalConnNetId === groupId && (traceIdSet.size === 0 || t.mspConnectionPairIds.some((id) => traceIdSet.has(id)))
     );
     const tracesToScan = this.availableOrientations.length === 1 ? [
       host,
@@ -7596,14 +7700,14 @@ var SingleNetLabelPlacementSolver = class extends BaseSolver {
     };
     let bestCandidate = null;
     let bestScore = -Infinity;
-    const EPS = 1e-6;
+    const EPS2 = 1e-6;
     for (const curr of tracesToScan) {
       const pts = curr.tracePath.slice();
       for (let si = 0; si < pts.length - 1; si++) {
         const a = pts[si];
         const b = pts[si + 1];
-        const isH = Math.abs(a.y - b.y) < EPS;
-        const isV = Math.abs(a.x - b.x) < EPS;
+        const isH = Math.abs(a.y - b.y) < EPS2;
+        const isV = Math.abs(a.x - b.x) < EPS2;
         if (!isH && !isV) continue;
         const segmentAllowed = isH ? ["y+", "y-"] : ["x+", "x-"];
         const candidateOrients = orientations.filter(
@@ -7831,10 +7935,18 @@ var NetLabelPlacementSolver = class extends BaseSolver {
               }
             }
           }
+          const mspConnectionPairIds = Array.from(
+            new Set(
+              compTraces.flatMap(
+                (t) => t.mspConnectionPairIds ?? [t.mspPairId]
+              )
+            )
+          );
           groups.push({
             globalConnNetId,
             netId: userNetId,
-            overlappingTraces: rep
+            overlappingTraces: rep,
+            mspConnectionPairIds
           });
         } else {
           for (const p of component) {

package/lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver.ts

@@ -19,6 +19,7 @@ export type OverlappingSameNetTraceGroup = {
   netId?: string
   overlappingTraces?: SolvedTracePath
   portOnlyPinId?: string
+  mspConnectionPairIds?: MspConnectionPairId[]
 }
 
 export interface NetLabelPlacement {
@@ -196,11 +197,19 @@ export class NetLabelPlacementSolver extends BaseSolver {
               }
             }
           }
+          const mspConnectionPairIds = Array.from(
+            new Set(
+              compTraces.flatMap(
+                (t) => t.mspConnectionPairIds ?? [t.mspPairId],
+              ),
+            ),
+          )
 
           groups.push({
             globalConnNetId,
             netId: userNetId,
             overlappingTraces: rep,
+            mspConnectionPairIds,
           })
         } else {
           // No traces in this component: place label at each pin that has a user net id

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

@@ -121,6 +121,8 @@ export class SingleNetLabelPlacementSolver extends BaseSolver {
       inputTraceMap: this.inputTraceMap,
       globalConnNetId: groupId,
       fallbackTrace: this.overlappingSameNetTraceGroup.overlappingTraces,
+      mspConnectionPairIds:
+        this.overlappingSameNetTraceGroup.mspConnectionPairIds,
     })
 
     if (!host) {
@@ -130,8 +132,14 @@ export class SingleNetLabelPlacementSolver extends BaseSolver {
     }
 
     // Ensure we traverse the host path starting at the segment attached to the largest chip's pin
+    const traceIdSet = new Set(
+      this.overlappingSameNetTraceGroup.mspConnectionPairIds ?? [],
+    )
     const tracesToScanBase = Object.values(this.inputTraceMap).filter(
-      (t) => t.globalConnNetId === groupId,
+      (t) =>
+        t.globalConnNetId === groupId &&
+        (traceIdSet.size === 0 ||
+          t.mspConnectionPairIds.some((id) => traceIdSet.has(id))),
     )
     const tracesToScan =
       this.availableOrientations.length === 1

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

@@ -17,17 +17,29 @@ export function chooseHostTraceForGroup(params: {
   inputTraceMap: Record<MspConnectionPairId, SolvedTracePath>
   globalConnNetId: string
   fallbackTrace?: SolvedTracePath
+  mspConnectionPairIds?: MspConnectionPairId[]
 }): SolvedTracePath | undefined {
-  const { inputProblem, inputTraceMap, globalConnNetId, fallbackTrace } = params
-
+  const {
+    inputProblem,
+    inputTraceMap,
+    globalConnNetId,
+    fallbackTrace,
+    mspConnectionPairIds,
+  } = params
   const chipsById: Record<string, InputChip> = Object.fromEntries(
     inputProblem.chips.map((c) => [c.chipId, c]),
   )
 
-  const groupTraces = Object.values(inputTraceMap).filter(
+  let groupTraces = Object.values(inputTraceMap).filter(
     (t) => t.globalConnNetId === globalConnNetId,
   )
 
+  if (mspConnectionPairIds && mspConnectionPairIds.length > 0) {
+    const idSet = new Set(mspConnectionPairIds)
+    groupTraces = groupTraces.filter((t) =>
+      t.mspConnectionPairIds.some((id) => idSet.has(id)),
+    )
+  }
   const chipIdsInGroup = new Set<string>()
   for (const t of groupTraces) {
     chipIdsInGroup.add(t.pins[0].chipId)

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/SchematicTraceSingleLineSolver.ts

@@ -24,6 +24,7 @@ export class SchematicTraceSingleLineSolver extends BaseSolver {
   movableSegments: Array<MovableSegment>
   baseElbow: Point[]
 
+  allCandidatePaths: Array<Point[]>
   queuedCandidatePaths: Array<Point[]>
 
   chipObstacleSpatialIndex: ChipObstacleSpatialIndex
@@ -91,7 +92,8 @@ export class SchematicTraceSingleLineSolver extends BaseSolver {
       return len
     }
 
-    this.queuedCandidatePaths = [this.baseElbow, ...elbowVariants].sort(
+    this.allCandidatePaths = [this.baseElbow, ...elbowVariants]
+    this.queuedCandidatePaths = [...this.allCandidatePaths].sort(
       (a, b) => getPathLength(a) - getPathLength(b),
     )
   }