@tscircuit/schematic-trace-solver 0.0.113 → 0.0.114

package/dist/index.d.ts

@@ -586,6 +586,8 @@ declare class LongDistancePairSolver extends BaseSolver {
     solvedLongDistanceTraces: SolvedTracePath[];
     private queuedCandidatePairs;
     private currentCandidatePair;
+    private queuedFailedConnectionPairs;
+    private currentFailedConnectionPair;
     private subSolver;
     private chipMap;
     private inputProblem;
@@ -596,12 +598,15 @@ declare class LongDistancePairSolver extends BaseSolver {
         inputProblem: InputProblem;
         alreadySolvedTraces: SolvedTracePath[];
         primaryMspConnectionPairs: MspConnectionPair[];
+        failedConnectionPairs: MspConnectionPair[];
     });
     getConstructorParams(): {
         inputProblem: InputProblem;
         alreadySolvedTraces: SolvedTracePath[];
         primaryMspConnectionPairs: MspConnectionPair[];
+        failedConnectionPairs: MspConnectionPair[];
     };
+    private acceptFailedConnectionPair;
     _step(): void;
     visualize(): graphics_debug.GraphicsObject;
     getOutput(): {

package/dist/index.js

@@ -420,6 +420,33 @@ function getOrthogonalMinimumSpanningTree(pins, opts = {}) {
   return edges;
 }
 
+// lib/solvers/MspConnectionPairSolver/isLabeledPeripheralConnection.ts
+var isLabeledPeripheralConnection = ({
+  inputProblem,
+  chipMap,
+  pins
+}) => {
+  const [firstPin, secondPin] = pins;
+  const directConnection = inputProblem.directConnections.find(
+    (connection) => connection.pinIds.includes(firstPin.pinId) && connection.pinIds.includes(secondPin.pinId)
+  );
+  if (directConnection?.netLabelWidth === void 0) return false;
+  const firstChip = chipMap[firstPin.chipId];
+  const secondChip = chipMap[secondPin.chipId];
+  if (!firstChip || !secondChip) return false;
+  const hasSinglePinPeripheral = firstChip.pins.length === 1 || secondChip.pins.length === 1;
+  if (!hasSinglePinPeripheral) return false;
+  let firstFacingDirection = firstPin._facingDirection;
+  if (!firstFacingDirection) {
+    firstFacingDirection = getPinDirection(firstPin, firstChip);
+  }
+  let secondFacingDirection = secondPin._facingDirection;
+  if (!secondFacingDirection) {
+    secondFacingDirection = getPinDirection(secondPin, secondChip);
+  }
+  return firstFacingDirection === "x-" && secondFacingDirection === "x+" || firstFacingDirection === "x+" && secondFacingDirection === "x-";
+};
+
 // lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver.ts
 var DEFAULT_MAX_MSP_PAIR_DISTANCE = 1;
 var getPinPairKey = (pinIds) => [...pinIds].sort().join("::");
@@ -489,8 +516,16 @@ var MspConnectionPairSolver = class extends BaseSolver {
       const p1 = this.pinMap[pin1];
       const p2 = this.pinMap[pin2];
       const pinPairKey = getPinPairKey([pin1, pin2]);
-      const pairDistance = this.directConnectionPinPairKeys.has(pinPairKey) ? distance(p1, p2) : Math.abs(p1.x - p2.x) + Math.abs(p1.y - p2.y);
-      if (pairDistance > this.maxMspPairDistance) {
+      let pairDistance = Math.abs(p1.x - p2.x) + Math.abs(p1.y - p2.y);
+      if (this.directConnectionPinPairKeys.has(pinPairKey)) {
+        pairDistance = distance(p1, p2);
+      }
+      const isLabeledPeripheral = isLabeledPeripheralConnection({
+        inputProblem: this.inputProblem,
+        chipMap: this.chipMap,
+        pins: [p1, p2]
+      });
+      if (pairDistance > this.maxMspPairDistance && !isLabeledPeripheral) {
         return;
       }
       if (arePinsInDifferentSchematicSections(this.inputProblem, p1, p2)) {
@@ -4495,6 +4530,13 @@ var LongDistancePairSolver = class extends BaseSolver {
         pinMap.set(pin.pinId, { ...pin, chipId: chip.chipId });
       }
     }
+    this.queuedFailedConnectionPairs = this.params.failedConnectionPairs.filter(
+      (connectionPair) => isLabeledPeripheralConnection({
+        inputProblem: this.inputProblem,
+        chipMap: this.chipMap,
+        pins: connectionPair.pins
+      })
+    );
     const candidatePairs = [];
     const addedPairKeys = /* @__PURE__ */ new Set();
     for (const netId of Object.keys(netConnMap.netMap)) {
@@ -4535,6 +4577,8 @@ var LongDistancePairSolver = class extends BaseSolver {
   solvedLongDistanceTraces = [];
   queuedCandidatePairs = [];
   currentCandidatePair = null;
+  queuedFailedConnectionPairs = [];
+  currentFailedConnectionPair = null;
   subSolver = null;
   chipMap = {};
   inputProblem;
@@ -4544,8 +4588,31 @@ var LongDistancePairSolver = class extends BaseSolver {
   getConstructorParams() {
     return this.params;
   }
+  acceptFailedConnectionPair(tracePath) {
+    const connectionPair = this.currentFailedConnectionPair;
+    if (!connectionPair) return;
+    const solvedTrace = {
+      ...connectionPair,
+      tracePath,
+      mspConnectionPairIds: [connectionPair.mspPairId],
+      pinIds: connectionPair.pins.map((pin) => pin.pinId)
+    };
+    this.solvedLongDistanceTraces.push(solvedTrace);
+    this.allSolvedTraces.push(solvedTrace);
+    for (const pin of connectionPair.pins) {
+      this.newlyConnectedPinIds.add(pin.pinId);
+    }
+  }
   _step() {
-    if (this.subSolver?.solved) {
+    if (this.subSolver?.solved && this.currentFailedConnectionPair) {
+      const tracePath = this.subSolver.solvedTracePath;
+      if (tracePath) {
+        this.acceptFailedConnectionPair(tracePath);
+      }
+      this.subSolver = null;
+      this.currentCandidatePair = null;
+      this.currentFailedConnectionPair = null;
+    } else if (this.subSolver?.solved) {
       const newTracePath = this.subSolver.solvedTracePath;
       if (newTracePath && this.currentCandidatePair) {
         const isTraceClear = !doesTraceOverlapWithExistingTraces(
@@ -4576,11 +4643,23 @@ var LongDistancePairSolver = class extends BaseSolver {
     } else if (this.subSolver?.failed) {
       this.subSolver = null;
       this.currentCandidatePair = null;
+      this.currentFailedConnectionPair = null;
     }
     if (this.subSolver) {
       this.subSolver.step();
       return;
     }
+    const failedConnectionPair = this.queuedFailedConnectionPairs.shift();
+    if (failedConnectionPair) {
+      this.currentFailedConnectionPair = failedConnectionPair;
+      this.currentCandidatePair = failedConnectionPair.pins;
+      this.subSolver = new SchematicTraceSingleLineSolver2({
+        inputProblem: this.params.inputProblem,
+        pins: failedConnectionPair.pins,
+        chipMap: this.chipMap
+      });
+      return;
+    }
     while (this.queuedCandidatePairs.length > 0) {
       const nextPair = this.queuedCandidatePairs.shift();
       const [p1, p2] = nextPair;
@@ -10703,7 +10782,8 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
         {
           inputProblem: instance.inputProblem,
           primaryMspConnectionPairs: instance.mspConnectionPairSolver.mspConnectionPairs,
-          alreadySolvedTraces: instance.schematicTraceLinesSolver.solvedTracePaths
+          alreadySolvedTraces: instance.schematicTraceLinesSolver.solvedTracePaths,
+          failedConnectionPairs: instance.schematicTraceLinesSolver.failedConnectionPairs
         }
       ],
       {

package/lib/solvers/LongDistancePairSolver/LongDistancePairSolver.ts

@@ -13,6 +13,7 @@ import { visualizeInputProblem } from "../SchematicTracePipelineSolver/visualize
 import type { SolvedTracePath } from "../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
 import type { ConnectivityMap } from "connectivity-map"
 import { arePinsInDifferentSchematicSections } from "../../utils/arePinsInDifferentSchematicSections"
+import { isLabeledPeripheralConnection } from "../MspConnectionPairSolver/isLabeledPeripheralConnection"
 
 const NEAREST_NEIGHBOR_COUNT = 3
 
@@ -28,6 +29,8 @@ export class LongDistancePairSolver extends BaseSolver {
   private currentCandidatePair:
     | [InputPin & { chipId: string }, InputPin & { chipId: string }]
     | null = null
+  private queuedFailedConnectionPairs: MspConnectionPair[] = []
+  private currentFailedConnectionPair: MspConnectionPair | null = null
   private subSolver: SchematicTraceSingleLineSolver2 | null = null
   private chipMap: Record<string, InputChip> = {}
   private inputProblem: InputProblem
@@ -40,6 +43,7 @@ export class LongDistancePairSolver extends BaseSolver {
       inputProblem: InputProblem
       alreadySolvedTraces: SolvedTracePath[]
       primaryMspConnectionPairs: MspConnectionPair[]
+      failedConnectionPairs: MspConnectionPair[]
     },
   ) {
     super()
@@ -66,6 +70,16 @@ export class LongDistancePairSolver extends BaseSolver {
         pinMap.set(pin.pinId, { ...pin, chipId: chip.chipId })
       }
     }
+    // Retry failed MSP pairs with their existing identity before creating
+    // new nearest-neighbor candidates.
+    this.queuedFailedConnectionPairs = this.params.failedConnectionPairs.filter(
+      (connectionPair) =>
+        isLabeledPeripheralConnection({
+          inputProblem: this.inputProblem,
+          chipMap: this.chipMap,
+          pins: connectionPair.pins,
+        }),
+    )
 
     // 2. Generate candidate pairs using N-Nearest-Neighbors approach
     const candidatePairs: Array<
@@ -129,9 +143,36 @@ export class LongDistancePairSolver extends BaseSolver {
     return this.params
   }
 
+  private acceptFailedConnectionPair(tracePath: SolvedTracePath["tracePath"]) {
+    const connectionPair = this.currentFailedConnectionPair
+    if (!connectionPair) return
+
+    // Reuse the original pair so downstream solvers retain its connectivity
+    // IDs, user net ID, pins, and MSP pair ID.
+    const solvedTrace: SolvedTracePath = {
+      ...connectionPair,
+      tracePath,
+      mspConnectionPairIds: [connectionPair.mspPairId],
+      pinIds: connectionPair.pins.map((pin) => pin.pinId),
+    }
+    this.solvedLongDistanceTraces.push(solvedTrace)
+    this.allSolvedTraces.push(solvedTrace)
+    for (const pin of connectionPair.pins) {
+      this.newlyConnectedPinIds.add(pin.pinId)
+    }
+  }
+
   override _step() {
     // 1. Check if a sub-solver has finished and process its result
-    if (this.subSolver?.solved) {
+    if (this.subSolver?.solved && this.currentFailedConnectionPair) {
+      const tracePath = this.subSolver.solvedTracePath
+      if (tracePath) {
+        this.acceptFailedConnectionPair(tracePath)
+      }
+      this.subSolver = null
+      this.currentCandidatePair = null
+      this.currentFailedConnectionPair = null
+    } else if (this.subSolver?.solved) {
       const newTracePath = this.subSolver.solvedTracePath
       if (newTracePath && this.currentCandidatePair) {
         const isTraceClear = !doesTraceOverlapWithExistingTraces(
@@ -166,6 +207,7 @@ export class LongDistancePairSolver extends BaseSolver {
     } else if (this.subSolver?.failed) {
       this.subSolver = null
       this.currentCandidatePair = null
+      this.currentFailedConnectionPair = null
     }
 
     // 2. If a sub-solver is already running, let it continue
@@ -174,6 +216,18 @@ export class LongDistancePairSolver extends BaseSolver {
       return
     }
 
+    const failedConnectionPair = this.queuedFailedConnectionPairs.shift()
+    if (failedConnectionPair) {
+      this.currentFailedConnectionPair = failedConnectionPair
+      this.currentCandidatePair = failedConnectionPair.pins
+      this.subSolver = new SchematicTraceSingleLineSolver2({
+        inputProblem: this.params.inputProblem,
+        pins: failedConnectionPair.pins,
+        chipMap: this.chipMap,
+      })
+      return
+    }
+
     // 3. Find the next valid candidate pair and start a new sub-solver
     while (this.queuedCandidatePairs.length > 0) {
       const nextPair = this.queuedCandidatePairs.shift()!

package/lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver.ts

@@ -14,6 +14,7 @@ import { visualizeInputProblem } from "../SchematicTracePipelineSolver/visualize
 import { doesPairCrossRestrictedCenterLines } from "./doesPairCrossRestrictedCenterLines"
 import { getConnectivityMapsFromInputProblem } from "./getConnectivityMapFromInputProblem"
 import { getOrthogonalMinimumSpanningTree } from "./getMspConnectionPairsFromPins"
+import { isLabeledPeripheralConnection } from "./isLabeledPeripheralConnection"
 
 export type MspConnectionPairId = string
 export const DEFAULT_MAX_MSP_PAIR_DISTANCE = 1
@@ -116,10 +117,18 @@ export class MspConnectionPairSolver extends BaseSolver {
       const pinPairKey = getPinPairKey([pin1!, pin2!])
       // Explicit source traces are classified by straight-line distance when
       // their input is created; named nets retain the orthogonal route metric.
-      const pairDistance = this.directConnectionPinPairKeys.has(pinPairKey)
-        ? distance(p1, p2)
-        : Math.abs(p1.x - p2.x) + Math.abs(p1.y - p2.y)
-      if (pairDistance > this.maxMspPairDistance) {
+      let pairDistance = Math.abs(p1.x - p2.x) + Math.abs(p1.y - p2.y)
+      if (this.directConnectionPinPairKeys.has(pinPairKey)) {
+        pairDistance = distance(p1, p2)
+      }
+      // Labeled one-pin peripherals need a real trace even when they are far
+      // apart; skipping the MSP pair would leave only the fallback path.
+      const isLabeledPeripheral = isLabeledPeripheralConnection({
+        inputProblem: this.inputProblem,
+        chipMap: this.chipMap,
+        pins: [p1, p2],
+      })
+      if (pairDistance > this.maxMspPairDistance && !isLabeledPeripheral) {
         // Too far apart; skip creating an MSP pair for this net
         return
       }

package/lib/solvers/MspConnectionPairSolver/isLabeledPeripheralConnection.ts

@@ -0,0 +1,44 @@
+import type { InputChip, InputPin, InputProblem } from "lib/types/InputProblem"
+import { getPinDirection } from "../SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/getPinDirection"
+
+type PinWithChipId = InputPin & { chipId: string }
+
+export const isLabeledPeripheralConnection = ({
+  inputProblem,
+  chipMap,
+  pins,
+}: {
+  inputProblem: InputProblem
+  chipMap: Record<string, InputChip>
+  pins: [PinWithChipId, PinWithChipId]
+}): boolean => {
+  const [firstPin, secondPin] = pins
+  const directConnection = inputProblem.directConnections.find(
+    (connection) =>
+      connection.pinIds.includes(firstPin.pinId) &&
+      connection.pinIds.includes(secondPin.pinId),
+  )
+  if (directConnection?.netLabelWidth === undefined) return false
+
+  const firstChip = chipMap[firstPin.chipId]
+  const secondChip = chipMap[secondPin.chipId]
+  if (!firstChip || !secondChip) return false
+
+  const hasSinglePinPeripheral =
+    firstChip.pins.length === 1 || secondChip.pins.length === 1
+  if (!hasSinglePinPeripheral) return false
+
+  let firstFacingDirection = firstPin._facingDirection
+  if (!firstFacingDirection) {
+    firstFacingDirection = getPinDirection(firstPin, firstChip)
+  }
+  let secondFacingDirection = secondPin._facingDirection
+  if (!secondFacingDirection) {
+    secondFacingDirection = getPinDirection(secondPin, secondChip)
+  }
+
+  return (
+    (firstFacingDirection === "x-" && secondFacingDirection === "x+") ||
+    (firstFacingDirection === "x+" && secondFacingDirection === "x-")
+  )
+}

package/lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts

@@ -140,6 +140,8 @@ export class SchematicTracePipelineSolver extends BaseSolver {
             instance.mspConnectionPairSolver!.mspConnectionPairs,
           alreadySolvedTraces:
             instance.schematicTraceLinesSolver!.solvedTracePaths,
+          failedConnectionPairs:
+            instance.schematicTraceLinesSolver!.failedConnectionPairs,
         },
       ],
       {

package/package.json

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

package/site/bug-reports/bug-report-20260728T144234Z.page.tsx

@@ -0,0 +1,4 @@
+import { PipelineDebugger } from "site/components/PipelineDebugger"
+import inputProblem from "../../tests/bug-reports/bug-report-20260728T144234Z/bug-report-20260728T144234Z.json"
+
+export default () => <PipelineDebugger inputProblem={inputProblem as any} />

package/site/bug-reports/bug-report-20260728T225606Z.page.tsx

@@ -0,0 +1,4 @@
+import { PipelineDebugger } from "site/components/PipelineDebugger"
+import inputProblem from "../../tests/bug-reports/bug-report-20260728T225606Z/bug-report-20260728T225606Z.json"
+
+export default () => <PipelineDebugger inputProblem={inputProblem as any} />