@tscircuit/schematic-trace-solver 0.0.195 → 0.0.197

package/dist/index.d.ts

@@ -1451,6 +1451,7 @@ declare class NetLabelToTraceSolver extends BaseSolver {
     private isPortOnlyFallbackLabel;
     private isDirectConnectionLabel;
     private getMultiPinNetConnection;
+    private getTwoPinNetConnection;
     private buildCandidatePairs;
     private buildRoutedComponentCandidates;
     private isSupersededConnectorTrace;

package/dist/index.js

@@ -13253,6 +13253,16 @@ var pathCollidesWithObstacles = ({
   const lastPathPin = connectionPair.pins.find(
     (pin) => pointsAreEqual(pin, lastPathPoint)
   );
+  for (const [pin, neighbor] of [
+    [firstPathPin, path[1]],
+    [lastPathPin, path[path.length - 2]]
+  ]) {
+    if (!pin?._facingDirection) continue;
+    const outward = dir(pin._facingDirection);
+    if ((neighbor.x - pin.x) * outward.x + (neighbor.y - pin.y) * outward.y < -COORDINATE_TOLERANCE) {
+      return true;
+    }
+  }
   const pathConnectsPairPins = firstPathPin !== void 0 && lastPathPin !== void 0;
   const firstChipObstacle = obstacles.find(
     (obstacle) => obstacle.kind === "chip" && obstacle.chipId === firstPathPin?.chipId
@@ -17890,6 +17900,23 @@ var getTraceRecoveryConnectivityMaps = (inputProblem) => {
   return { chipMap, pinMap };
 };
 
+// lib/solvers/NetLabelToTraceSolver/getSimpleElbowPath.ts
+var getSimpleElbowPath = (first, second) => {
+  const firstDirection = dir(first._facingDirection);
+  const secondDirection = dir(second._facingDirection);
+  if (firstDirection.x * secondDirection.x || firstDirection.y * secondDirection.y)
+    return void 0;
+  const elbow = firstDirection.x ? { x: second.x, y: first.y } : { x: first.x, y: second.y };
+  for (const [pin, direction] of [
+    [first, firstDirection],
+    [second, secondDirection]
+  ]) {
+    if ((elbow.x - pin.x) * direction.x + (elbow.y - pin.y) * direction.y <= 1e-6)
+      return void 0;
+  }
+  return [{ x: first.x, y: first.y }, elbow, { x: second.x, y: second.y }];
+};
+
 // lib/solvers/NetLabelToTraceSolver/reduceTraceCrossings.ts
 var EPS18 = 1e-9;
 var isHorizontal4 = (start, end) => Math.abs(start.y - end.y) < EPS18;
@@ -18064,6 +18091,11 @@ var NetLabelToTraceSolver = class extends BaseSolver {
       (connection) => connection.isGround === false && connection.pinIds.length > 2 && connection.netId === label.netId && connection.pinIds.includes(pinId)
     );
   }
+  getTwoPinNetConnection(label) {
+    return this.inputProblem.netConnections.find(
+      (connection) => !connection.isGround && connection.pinIds.length === 2 && connection.netId === label.netId && connection.pinIds.includes(label.pinIds[0])
+    );
+  }
   buildCandidatePairs() {
     const { netConnMap } = getConnectivityMapsFromInputProblem(
       this.inputProblem
@@ -18076,7 +18108,7 @@ var NetLabelToTraceSolver = class extends BaseSolver {
     }
     const labelsByGlobalNet = /* @__PURE__ */ new Map();
     for (const label of this.input.netLabelPlacements) {
-      if (!this.isPortOnlyFallbackLabel(label, groundGlobalConnNetIds) || !this.isDirectConnectionLabel(label) && !this.getMultiPinNetConnection(label)) {
+      if (!this.isPortOnlyFallbackLabel(label, groundGlobalConnNetIds) || !this.isDirectConnectionLabel(label) && !this.getMultiPinNetConnection(label) && !this.getTwoPinNetConnection(label)) {
         continue;
       }
       const labels = labelsByGlobalNet.get(label.globalConnNetId) ?? [];
@@ -18100,7 +18132,9 @@ var NetLabelToTraceSolver = class extends BaseSolver {
           const bothLabelsBelongToDirectConnections = this.isDirectConnectionLabel(firstLabel) && this.isDirectConnectionLabel(secondLabel);
           const firstMultiPinNetConnection = this.getMultiPinNetConnection(firstLabel);
           const secondMultiPinNetConnection = this.getMultiPinNetConnection(secondLabel);
-          if (!bothLabelsBelongToDirectConnections && (!firstMultiPinNetConnection || firstMultiPinNetConnection !== secondMultiPinNetConnection || perpendicularOffset > MAX_NAMED_NET_RECOVERY_PERPENDICULAR_OFFSET)) {
+          const twoPinNetConnection = this.getTwoPinNetConnection(firstLabel);
+          const simpleElbowPath = !bothLabelsBelongToDirectConnections && twoPinNetConnection && firstPin.chipId !== secondPin.chipId && twoPinNetConnection === this.getTwoPinNetConnection(secondLabel) ? getSimpleElbowPath(firstPin, secondPin) : void 0;
+          if (!simpleElbowPath && !bothLabelsBelongToDirectConnections && (!firstMultiPinNetConnection || firstMultiPinNetConnection !== secondMultiPinNetConnection || perpendicularOffset > MAX_NAMED_NET_RECOVERY_PERPENDICULAR_OFFSET)) {
             continue;
           }
           if (arePinsInDifferentSchematicSections(
@@ -18126,7 +18160,8 @@ var NetLabelToTraceSolver = class extends BaseSolver {
             perpendicularOffset,
             routeDistance: Math.abs(firstPin.x - secondPin.x) + Math.abs(firstPin.y - secondPin.y),
             key: getCanonicalPairKey(firstPin.pinId, secondPin.pinId),
-            recoveryMode: "fallback_labels"
+            recoveryMode: "fallback_labels",
+            simpleElbowPath
           });
         }
       }
@@ -18288,6 +18323,16 @@ var NetLabelToTraceSolver = class extends BaseSolver {
         (trace) => trace.globalConnNetId !== candidate.firstLabel.globalConnNetId
       );
     }
+    if (candidate.simpleElbowPath) {
+      tracePath = candidate.simpleElbowPath;
+      if (findFirstCollision(tracePath, this.activeSubSolver.obstacles) || collisionTraces.reduce(
+        (count, trace) => count + findPerpendicularPathCrossings(tracePath, trace.tracePath, {
+          includeTerminalSegments: true
+        }).length,
+        0
+      ) > 1)
+        return;
+    }
     if (doesTraceRecoveryPathConflict(tracePath, collisionTraces) || this.routeIntersectsRemainingLabels(tracePath, candidate)) {
       return;
     }

package/lib/solvers/NetLabelToTraceSolver/NetLabelToTraceSolver.ts

@@ -27,6 +27,8 @@ import {
   type InlineNetLabelPlacement,
   visualizeInlineNetLabelOutput,
 } from "../InlineNetLabelSolver/InlineNetLabelSolver"
+import { getSimpleElbowPath } from "./getSimpleElbowPath"
+import { findPerpendicularPathCrossings } from "../TraceCleanupSolver/sub-solver/findIntersectionsWithObstacles"
 import { reduceTraceCrossings } from "./reduceTraceCrossings"
 
 type GlobalConnNetId = NetLabelPlacement["globalConnNetId"]
@@ -43,6 +45,7 @@ interface CandidatePair {
     | "routed_components"
     | "routed_direct_connection"
   netConnectionPinIds?: PinId[]
+  simpleElbowPath?: Point[]
 }
 
 const RECOVERED_TRACE_PREFIX = "net-label-to-trace-"
@@ -153,6 +156,16 @@ export class NetLabelToTraceSolver extends BaseSolver {
     )
   }
 
+  private getTwoPinNetConnection(label: NetLabelPlacement) {
+    return this.inputProblem.netConnections.find(
+      (connection) =>
+        !connection.isGround &&
+        connection.pinIds.length === 2 &&
+        connection.netId === label.netId &&
+        connection.pinIds.includes(label.pinIds[0]!),
+    )
+  }
+
   private buildCandidatePairs() {
     const { netConnMap } = getConnectivityMapsFromInputProblem(
       this.inputProblem,
@@ -169,7 +182,8 @@ export class NetLabelToTraceSolver extends BaseSolver {
       if (
         !this.isPortOnlyFallbackLabel(label, groundGlobalConnNetIds) ||
         (!this.isDirectConnectionLabel(label) &&
-          !this.getMultiPinNetConnection(label))
+          !this.getMultiPinNetConnection(label) &&
+          !this.getTwoPinNetConnection(label))
       ) {
         continue
       }
@@ -203,7 +217,16 @@ export class NetLabelToTraceSolver extends BaseSolver {
             this.getMultiPinNetConnection(firstLabel)
           const secondMultiPinNetConnection =
             this.getMultiPinNetConnection(secondLabel)
+          const twoPinNetConnection = this.getTwoPinNetConnection(firstLabel)
+          const simpleElbowPath =
+            !bothLabelsBelongToDirectConnections &&
+            twoPinNetConnection &&
+            firstPin.chipId !== secondPin.chipId &&
+            twoPinNetConnection === this.getTwoPinNetConnection(secondLabel)
+              ? getSimpleElbowPath(firstPin, secondPin)
+              : undefined
           if (
+            !simpleElbowPath &&
             !bothLabelsBelongToDirectConnections &&
             (!firstMultiPinNetConnection ||
               firstMultiPinNetConnection !== secondMultiPinNetConnection ||
@@ -242,6 +265,7 @@ export class NetLabelToTraceSolver extends BaseSolver {
               Math.abs(firstPin.y - secondPin.y),
             key: getCanonicalPairKey(firstPin.pinId, secondPin.pinId),
             recoveryMode: "fallback_labels",
+            simpleElbowPath,
           })
         }
       }
@@ -474,6 +498,23 @@ export class NetLabelToTraceSolver extends BaseSolver {
           trace.globalConnNetId !== candidate.firstLabel.globalConnNetId,
       )
     }
+    // Only recover a named two-pin elbow when the shortest, direction-respecting
+    // path is clear. Do not replace labels with obstacle detours or many hops.
+    if (candidate.simpleElbowPath) {
+      tracePath = candidate.simpleElbowPath
+      if (
+        findFirstCollision(tracePath, this.activeSubSolver!.obstacles) ||
+        collisionTraces.reduce(
+          (count, trace) =>
+            count +
+            findPerpendicularPathCrossings(tracePath!, trace.tracePath, {
+              includeTerminalSegments: true,
+            }).length,
+          0,
+        ) > 1
+      )
+        return
+    }
     if (
       doesTraceRecoveryPathConflict(tracePath, collisionTraces) ||
       this.routeIntersectsRemainingLabels(tracePath, candidate)

package/lib/solvers/NetLabelToTraceSolver/getSimpleElbowPath.ts

@@ -0,0 +1,31 @@
+import type { Point } from "@tscircuit/math-utils"
+import type { TraceRecoveryPin } from "lib/solvers/NetLabelTraceRecovery/getTraceRecoveryConnectivityMaps"
+import { dir } from "lib/utils/dir"
+
+/** The single elbow reached by extending both pins outwards, if it exists. */
+export const getSimpleElbowPath = (
+  first: TraceRecoveryPin,
+  second: TraceRecoveryPin,
+): Point[] | undefined => {
+  const firstDirection = dir(first._facingDirection)
+  const secondDirection = dir(second._facingDirection)
+  if (
+    firstDirection.x * secondDirection.x ||
+    firstDirection.y * secondDirection.y
+  )
+    return undefined
+  const elbow = firstDirection.x
+    ? { x: second.x, y: first.y }
+    : { x: first.x, y: second.y }
+  for (const [pin, direction] of [
+    [first, firstDirection],
+    [second, secondDirection],
+  ] as const) {
+    if (
+      (elbow.x - pin.x) * direction.x + (elbow.y - pin.y) * direction.y <=
+      1e-6
+    )
+      return undefined
+  }
+  return [{ x: first.x, y: first.y }, elbow, { x: second.x, y: second.y }]
+}

package/lib/solvers/UnroutedTraceRecoverySolver/UnroutedTraceRecoverySolver.ts

@@ -20,7 +20,7 @@ import {
 } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
 import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
 import type { InputProblem, PinId } from "lib/types/InputProblem"
-import type { FacingDirection } from "lib/utils/dir"
+import { dir, type FacingDirection } from "lib/utils/dir"
 
 const ROUTE_CLEARANCE = 0.2
 const COORDINATE_TOLERANCE = 1e-9
@@ -306,6 +306,20 @@ const pathCollidesWithObstacles = ({
   const lastPathPin = connectionPair.pins.find((pin) =>
     pointsAreEqual(pin, lastPathPoint),
   )
+  // Endpoint exemptions must not allow a route through the back of a component.
+  for (const [pin, neighbor] of [
+    [firstPathPin, path[1]!],
+    [lastPathPin, path[path.length - 2]!],
+  ] as const) {
+    if (!pin?._facingDirection) continue
+    const outward = dir(pin._facingDirection)
+    if (
+      (neighbor.x - pin.x) * outward.x + (neighbor.y - pin.y) * outward.y <
+      -COORDINATE_TOLERANCE
+    ) {
+      return true
+    }
+  }
   const pathConnectsPairPins =
     firstPathPin !== undefined && lastPathPin !== undefined
   const firstChipObstacle = obstacles.find(

package/package.json

@@ -5,7 +5,7 @@
     "url": "https://github.com/tscircuit/schematic-trace-solver.git"
   },
   "main": "dist/index.js",
-  "version": "0.0.195",
+  "version": "0.0.197",
   "type": "module",
   "scripts": {
     "start": "cosmos",

package/site/bug-reports/enc-scl-hop.page.tsx

@@ -0,0 +1,6 @@
+import { PipelineDebugger } from "site/components/PipelineDebugger"
+import inputProblem from "../../tests/assets/enc-scl-hop.json"
+
+export default () => (
+  <PipelineDebugger inputProblem={inputProblem as any} hideRatsNet />
+)

package/tests/assets/enc-scl-hop.json

@@ -0,0 +1,185 @@
+{
+  "chips": [
+    {
+      "chipId": "R_ENC_SDA",
+      "center": {
+        "x": 0.0,
+        "y": 1.8
+      },
+      "width": 0.16000000000000003,
+      "height": 0.4,
+      "pins": [
+        {
+          "pinId": "R_ENC_SDA.1",
+          "x": 0.0,
+          "y": 2.1,
+          "_facingDirection": "y+"
+        },
+        {
+          "pinId": "R_ENC_SDA.2",
+          "x": 0.0,
+          "y": 1.5,
+          "_facingDirection": "y-"
+        }
+      ]
+    },
+    {
+      "chipId": "R_ENC_SCL",
+      "center": {
+        "x": 2.0,
+        "y": 1.8
+      },
+      "width": 0.16000000000000003,
+      "height": 0.4,
+      "pins": [
+        {
+          "pinId": "R_ENC_SCL.1",
+          "x": 2.0,
+          "y": 2.1,
+          "_facingDirection": "y+"
+        },
+        {
+          "pinId": "R_ENC_SCL.2",
+          "x": 2.0,
+          "y": 1.5,
+          "_facingDirection": "y-"
+        }
+      ]
+    },
+    {
+      "chipId": "U_ENCODER",
+      "center": {
+        "x": 6.0,
+        "y": 0.0
+      },
+      "width": 1.7600000000000002,
+      "height": 1.6,
+      "pins": [
+        {
+          "pinId": "U_ENCODER.6",
+          "displayName": "SDA",
+          "x": 4.720000000000001,
+          "y": 0.1,
+          "_facingDirection": "x-"
+        },
+        {
+          "pinId": "U_ENCODER.7",
+          "displayName": "SCL",
+          "x": 4.720000000000001,
+          "y": -0.1,
+          "_facingDirection": "x-"
+        },
+        {
+          "pinId": "U_ENCODER.1",
+          "displayName": "VDD5V",
+          "x": 5.9,
+          "y": 1.2000000000000002,
+          "_facingDirection": "y+"
+        },
+        {
+          "pinId": "U_ENCODER.2",
+          "displayName": "VDD3V3",
+          "x": 6.1000000000000005,
+          "y": 1.2000000000000002,
+          "_facingDirection": "y+"
+        },
+        {
+          "pinId": "U_ENCODER.4",
+          "displayName": "GND",
+          "x": 5.9,
+          "y": -1.2000000000000002,
+          "_facingDirection": "y-"
+        },
+        {
+          "pinId": "U_ENCODER.8",
+          "displayName": "DIR",
+          "x": 6.1000000000000005,
+          "y": -1.2000000000000002,
+          "_facingDirection": "y-"
+        },
+        {
+          "pinId": "U_ENCODER.3",
+          "displayName": "OUT",
+          "x": 7.28,
+          "y": 0.1,
+          "_facingDirection": "x+"
+        },
+        {
+          "pinId": "U_ENCODER.5",
+          "displayName": "PGO",
+          "x": 7.28,
+          "y": -0.1,
+          "_facingDirection": "x+"
+        }
+      ]
+    }
+  ],
+  "directConnections": [
+    {
+      "netId": "ENC_SDA",
+      "netLabelText": "ENC_SDA",
+      "pinIds": [
+        "R_ENC_SDA.2",
+        "U_ENCODER.6"
+      ]
+    },
+    {
+      "pinIds": [
+        "R_ENC_SDA.1",
+        "R_ENC_SCL.1"
+      ],
+      "netId": "V3V3"
+    },
+    {
+      "pinIds": [
+        "U_ENCODER.1",
+        "U_ENCODER.2"
+      ],
+      "netId": "V3V3"
+    }
+  ],
+  "netConnections": [
+    {
+      "netId": "ENC_SDA",
+      "netLabelText": "ENC_SDA",
+      "pinIds": [
+        "R_ENC_SDA.2",
+        "U_ENCODER.6"
+      ]
+    },
+    {
+      "netId": "ENC_SCL",
+      "netLabelText": "ENC_SCL",
+      "pinIds": [
+        "R_ENC_SCL.2",
+        "U_ENCODER.7"
+      ]
+    },
+    {
+      "netId": "V3V3",
+      "netLabelText": "V3V3",
+      "pinIds": [
+        "R_ENC_SDA.1",
+        "R_ENC_SCL.1",
+        "U_ENCODER.1",
+        "U_ENCODER.2"
+      ]
+    },
+    {
+      "netId": "GND",
+      "netLabelText": "GND",
+      "pinIds": [
+        "U_ENCODER.4",
+        "U_ENCODER.8"
+      ]
+    }
+  ],
+  "availableNetLabelOrientations": {
+    "V3V3": [
+      "y+"
+    ],
+    "GND": [
+      "y-"
+    ]
+  }
+}