@tscircuit/schematic-trace-solver 0.0.202 → 0.0.204

package/dist/index.js

@@ -6328,10 +6328,6 @@ var getFixedLabelCoordinate = (group, netLabelPlacements, traces) => {
   const groupIsWithinSingleComponent = [...groupTraceIds].every(
     (traceId) => traceMap.get(traceId)?.pins.every((pin) => pin.chipId === group[0].componentId) === true
   );
-  const groupHasOnlySingleRailTraces = [...groupTraceIds].every(
-    (traceId) => traceMap.get(traceId)?.tracePath.length === 4
-  );
-  if (!groupHasOnlySingleRailTraces) return null;
   const orientation = group[0].orientation;
   const linkedLabels = getLabelsLinkedToRailGroup(
     group,
@@ -6362,6 +6358,11 @@ var getFixedLabelCoordinate = (group, netLabelPlacements, traces) => {
   const coordinate = group.find(
     (segment) => Math.abs(segment.coordinate - labelCoordinate) <= RAIL_ALIGNMENT_EPSILON
   )?.coordinate ?? labelCoordinate;
+  if (group.some(
+    (segment) => traceMap.get(segment.traceId)?.tracePath.length !== 4 && !nearlyEqual(segment.coordinate, coordinate)
+  )) {
+    return null;
+  }
   const labelIsAnchoredToRoutedBackbone = anchoringLabels.some(
     (label) => label.mspConnectionPairIds.some(
       (traceId) => (traceMap.get(traceId)?.tracePath.length ?? 0) > 4
@@ -7810,6 +7811,36 @@ var is4PointRectangle = (path) => {
   return isHVHC || isVHVC;
 };
 
+// lib/solvers/TraceCleanupSolver/getInteriorShortcutPaths.ts
+var getInteriorShortcutPaths = (path) => {
+  const candidates = [path];
+  for (let startIndex = 1; startIndex < path.length - 3; startIndex++) {
+    for (let endIndex = startIndex + 2; endIndex < path.length - 1; endIndex++) {
+      for (const connection of tryConnectPoints(
+        path[startIndex],
+        path[endIndex]
+      )) {
+        const candidate = simplifyPath([
+          ...path.slice(0, startIndex),
+          ...connection,
+          ...path.slice(endIndex + 1)
+        ]);
+        const preservesTerminalDirections = [
+          [0, 1],
+          [-1, -2]
+        ].every(([endIndex2, neighborIndex]) => {
+          const endpoint = path.at(endIndex2);
+          const neighbor = path.at(neighborIndex);
+          const candidateNeighbor = candidate.at(neighborIndex);
+          return (neighbor.x - endpoint.x) * (candidateNeighbor.x - endpoint.x) + (neighbor.y - endpoint.y) * (candidateNeighbor.y - endpoint.y) > 0;
+        });
+        if (preservesTerminalDirections) candidates.push(candidate);
+      }
+    }
+  }
+  return candidates;
+};
+
 // lib/solvers/TraceCleanupSolver/rerouteGeneratedNetLabelConnectorCrossings.ts
 var EPS13 = 1e-6;
 var getConnectorObstacleBounds = (connector, segmentIndex, labels) => {
@@ -7902,7 +7933,12 @@ var rerouteGeneratedNetLabelConnectorCrossings = ({
         obstacleBounds,
         chipBounds: [],
         clearance
-      }).filter(
+      }).flatMap(
+        (candidate) => getInteriorShortcutPaths(candidate.path).map((path) => ({
+          ...candidate,
+          path
+        }))
+      ).filter(
         (candidate) => getPathLength4(candidate.path) <= getPathLength4(trace.tracePath) + EPS13 && countTurns(candidate.path) <= countTurns(trace.tracePath) + 2 && !isPathCollidingWithObstacles(
           candidate.path,
           componentAndTextObstacles
@@ -15470,7 +15506,17 @@ var TraceElbowTransitionSimplificationSolver = class extends BaseSolver {
     const otherNetTraces = this.outputTraces.filter(
       (otherTrace) => otherTrace.mspPairId !== trace.mspPairId && otherTrace.globalConnNetId !== trace.globalConnNetId
     );
+    const initialPathLength = getPathLength6(tracePath);
     const candidateByPath = /* @__PURE__ */ new Map();
+    for (const candidate of getInteriorShortcutPaths(tracePath)) {
+      if (Math.abs(getPathLength6(candidate) - initialPathLength) > PATH_LENGTH_EPSILON3) {
+        continue;
+      }
+      candidateByPath.set(
+        candidate.map((point) => `${point.x},${point.y}`).join(";"),
+        candidate
+      );
+    }
     const completedReroutes = this.input.completedReroutes.filter(
       (completedReroute) => completedReroute.initialTrace.mspPairId === trace.mspPairId
     );
@@ -15522,7 +15568,6 @@ var TraceElbowTransitionSimplificationSolver = class extends BaseSolver {
         ({ label }) => `${label.globalConnNetId}:${label.netId}`
       )
     );
-    const initialPathLength = getPathLength6(tracePath);
     const validCandidates = [...candidateByPath.values()].filter(
       (candidatePath) => {
         const candidateTrace = { ...trace, tracePath: candidatePath };
@@ -15539,7 +15584,9 @@ var TraceElbowTransitionSimplificationSolver = class extends BaseSolver {
           this.input.netLabelPlacements,
           [trace],
           [candidateTrace]
-        ) && !isPathCollidingWithObstacles(candidatePath, this.obstacles) && !doesPathCoincideWithTraces(candidatePath, otherNetTraces);
+        ) && !isPathCollidingWithObstacles(candidatePath, this.obstacles) && !doesPathCoincideWithTraces(candidatePath, otherNetTraces) && otherNetTraces.every(
+          (otherTrace) => countPathIntersections(candidatePath, otherTrace.tracePath) <= countPathIntersections(tracePath, otherTrace.tracePath)
+        );
       }
     );
     const getOverlapCount = (candidatePath) => detectTraceLabelOverlap({

package/lib/solvers/TraceCleanupSolver/getInteriorShortcutPaths.ts

@@ -0,0 +1,41 @@
+import type { Point } from "@tscircuit/math-utils"
+import { simplifyPath } from "./simplifyPath"
+import { tryConnectPoints } from "./tryConnectPoints"
+
+export const getInteriorShortcutPaths = (path: Point[]): Point[][] => {
+  const candidates: Point[][] = [path]
+  // Reconnect interior points to remove old loops left behind by a connector detour.
+  for (let startIndex = 1; startIndex < path.length - 3; startIndex++) {
+    for (
+      let endIndex = startIndex + 2;
+      endIndex < path.length - 1;
+      endIndex++
+    ) {
+      for (const connection of tryConnectPoints(
+        path[startIndex]!,
+        path[endIndex]!,
+      )) {
+        const candidate = simplifyPath([
+          ...path.slice(0, startIndex),
+          ...connection,
+          ...path.slice(endIndex + 1),
+        ])
+        const preservesTerminalDirections = [
+          [0, 1],
+          [-1, -2],
+        ].every(([endIndex, neighborIndex]) => {
+          const endpoint = path.at(endIndex!)!
+          const neighbor = path.at(neighborIndex!)!
+          const candidateNeighbor = candidate.at(neighborIndex!)!
+          return (
+            (neighbor.x - endpoint.x) * (candidateNeighbor.x - endpoint.x) +
+              (neighbor.y - endpoint.y) * (candidateNeighbor.y - endpoint.y) >
+            0
+          )
+        })
+        if (preservesTerminalDirections) candidates.push(candidate)
+      }
+    }
+  }
+  return candidates
+}

package/lib/solvers/TraceCleanupSolver/rerouteGeneratedNetLabelConnectorCrossings.ts

@@ -9,6 +9,7 @@ import { getObstacleRects } from "lib/solvers/SchematicTraceLinesSolver/Schemati
 import type { InputProblem } from "lib/types/InputProblem"
 import { doesPathCoincideWithTraces } from "lib/utils/doesPathCoincideWithTraces"
 import { countTurns } from "./countTurns"
+import { getInteriorShortcutPaths } from "./getInteriorShortcutPaths"
 import { hasCollisionsWithLabels } from "./hasCollisionsWithLabels"
 import { findPerpendicularPathCrossings } from "./sub-solver/findIntersectionsWithObstacles"
 import { generatePerpendicularTraceDetours } from "./sub-solver/generateLShapeRerouteCandidates"
@@ -150,6 +151,12 @@ export const rerouteGeneratedNetLabelConnectorCrossings = ({
         chipBounds: [],
         clearance,
       })
+        .flatMap((candidate) =>
+          getInteriorShortcutPaths(candidate.path).map((path) => ({
+            ...candidate,
+            path,
+          })),
+        )
         .filter(
           (candidate) =>
             getPathLength(candidate.path) <=

package/lib/solvers/TraceCleanupSolver/sameNetRailAlignment/getFixedLabelCoordinate.ts

@@ -2,7 +2,11 @@ import { distance } from "@tscircuit/math-utils"
 import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
 import { tracePathContainsPoint } from "lib/solvers/RailNetLabelCornerPlacementSolver/geometry"
 import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
-import { getDistinctCoordinates, RAIL_ALIGNMENT_EPSILON } from "./geometry"
+import {
+  getDistinctCoordinates,
+  nearlyEqual,
+  RAIL_ALIGNMENT_EPSILON,
+} from "./geometry"
 import type { RailSegment } from "./types"
 
 const getTransitivelyConnectedTraceIds = (
@@ -59,13 +63,6 @@ export const getFixedLabelCoordinate = (
         .get(traceId)
         ?.pins.every((pin) => pin.chipId === group[0]!.componentId) === true,
   )
-  const groupHasOnlySingleRailTraces = [...groupTraceIds].every(
-    (traceId) => traceMap.get(traceId)?.tracePath.length === 4,
-  )
-  // A fixed label may lengthen the endpoint legs around one movable rail. A
-  // trace with more elbows still has to pass the normal readability scoring.
-  if (!groupHasOnlySingleRailTraces) return null
-
   const orientation = group[0]!.orientation
   const linkedLabels = getLabelsLinkedToRailGroup(
     group,
@@ -107,6 +104,18 @@ export const getFixedLabelCoordinate = (
         Math.abs(segment.coordinate - labelCoordinate) <=
         RAIL_ALIGNMENT_EPSILON,
     )?.coordinate ?? labelCoordinate
+  // A fixed label may lengthen the endpoint legs around one movable rail.
+  // A multi-turn backbone may share the group when it already lies on that
+  // coordinate, but moving its elbows still requires normal readability scoring.
+  if (
+    group.some(
+      (segment) =>
+        traceMap.get(segment.traceId)?.tracePath.length !== 4 &&
+        !nearlyEqual(segment.coordinate, coordinate),
+    )
+  ) {
+    return null
+  }
   const labelIsAnchoredToRoutedBackbone = anchoringLabels.some((label) =>
     label.mspConnectionPairIds.some(
       (traceId) => (traceMap.get(traceId)?.tracePath.length ?? 0) > 4,

package/lib/solvers/TraceElbowTransitionSimplificationSolver/TraceElbowTransitionSimplificationSolver.ts

@@ -1,11 +1,13 @@
 import type { Point } from "@tscircuit/math-utils"
 import type { GraphicsObject } from "graphics-debug"
 import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
+import { countPathIntersections } from "lib/solvers/Example28Solver/geometry"
 import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
 import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
 import { isPathCollidingWithObstacles } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
 import { getObstacleRects } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
 import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
+import { getInteriorShortcutPaths } from "lib/solvers/TraceCleanupSolver/getInteriorShortcutPaths"
 import { preservesLabelAnchors } from "lib/solvers/TraceCleanupSolver/sameNetRailAlignment/preservesLabelAnchors"
 import { simplifyPath } from "lib/solvers/TraceCleanupSolver/simplifyPath"
 import { detectTraceLabelOverlap } from "lib/solvers/TraceLabelOverlapAvoidanceSolver/detectTraceLabelOverlap"
@@ -82,7 +84,24 @@ export class TraceElbowTransitionSimplificationSolver extends BaseSolver {
         otherTrace.mspPairId !== trace.mspPairId &&
         otherTrace.globalConnNetId !== trace.globalConnNetId,
     )
+    const initialPathLength = getPathLength(tracePath)
     const candidateByPath = new Map<string, Point[]>()
+    // Consecutive label detours can leave a staircase between two clear legs.
+    // Keep equivalent-length shortcuts, as with the transition candidates below;
+    // shortening the route belongs to turn minimization. Terminal directions,
+    // label anchors, and collision checks still apply.
+    for (const candidate of getInteriorShortcutPaths(tracePath)) {
+      if (
+        Math.abs(getPathLength(candidate) - initialPathLength) >
+        PATH_LENGTH_EPSILON
+      ) {
+        continue
+      }
+      candidateByPath.set(
+        candidate.map((point) => `${point.x},${point.y}`).join(";"),
+        candidate,
+      )
+    }
     const completedReroutes = this.input.completedReroutes.filter(
       (completedReroute) =>
         completedReroute.initialTrace.mspPairId === trace.mspPairId,
@@ -145,8 +164,6 @@ export class TraceElbowTransitionSimplificationSolver extends BaseSolver {
         ({ label }) => `${label.globalConnNetId}:${label.netId}`,
       ),
     )
-    const initialPathLength = getPathLength(tracePath)
-
     const validCandidates = [...candidateByPath.values()].filter(
       (candidatePath) => {
         const candidateTrace = { ...trace, tracePath: candidatePath }
@@ -175,7 +192,12 @@ export class TraceElbowTransitionSimplificationSolver extends BaseSolver {
             [candidateTrace],
           ) &&
           !isPathCollidingWithObstacles(candidatePath, this.obstacles) &&
-          !doesPathCoincideWithTraces(candidatePath, otherNetTraces)
+          !doesPathCoincideWithTraces(candidatePath, otherNetTraces) &&
+          otherNetTraces.every(
+            (otherTrace) =>
+              countPathIntersections(candidatePath, otherTrace.tracePath) <=
+              countPathIntersections(tracePath, otherTrace.tracePath),
+          )
         )
       },
     )

package/package.json

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

package/site/SchematicTracePipelineSolver/repro-smart-lock-ble-module.page.tsx

@@ -0,0 +1,7 @@
+import type { InputProblem } from "lib/types/InputProblem"
+import { PipelineDebugger } from "site/components/PipelineDebugger"
+import input from "../../tests/repros/assets/repro-smart-lock-ble-module.input.json"
+
+export default () => (
+  <PipelineDebugger inputProblem={input as unknown as InputProblem} />
+)