@tscircuit/schematic-trace-solver 0.0.104 → 0.0.106

package/dist/index.js

@@ -4774,6 +4774,95 @@ var minimizeTurns = ({
   return finalSimplifiedPath;
 };
 
+// lib/solvers/TraceCleanupSolver/sameNetRailAlignment/geometry.ts
+var RAIL_ALIGNMENT_EPSILON = 2e-3;
+var nearlyEqual = (a, b) => Math.abs(a - b) < RAIL_ALIGNMENT_EPSILON;
+var isHorizontal2 = (a, b) => nearlyEqual(a.y, b.y);
+var isVertical2 = (a, b) => nearlyEqual(a.x, b.x);
+var isPositiveLength = (a, b) => Math.abs(a.x - b.x) >= RAIL_ALIGNMENT_EPSILON || Math.abs(a.y - b.y) >= RAIL_ALIGNMENT_EPSILON;
+var getRailOrientation = (a, b) => {
+  if (!isPositiveLength(a, b)) return null;
+  if (isVertical2(a, b)) return "vertical";
+  if (isHorizontal2(a, b)) return "horizontal";
+  return null;
+};
+var rangesTouchOrOverlap = (a, b) => Math.min(a.maxAlong, b.maxAlong) - Math.max(a.minAlong, b.minAlong) >= -RAIL_ALIGNMENT_EPSILON;
+var pointsEqual = (a, b) => nearlyEqual(a.x, b.x) && nearlyEqual(a.y, b.y);
+var getDistinctCoordinates = (coordinates) => {
+  const distinct = [];
+  for (const coordinate of coordinates) {
+    if (!distinct.some((item) => nearlyEqual(item, coordinate))) {
+      distinct.push(coordinate);
+    }
+  }
+  return distinct;
+};
+var getMergedIntervalMetrics = (intervals) => {
+  const groups = [];
+  for (const interval of intervals) {
+    const group = groups.find(
+      (items) => nearlyEqual(items[0].coordinate, interval.coordinate)
+    );
+    if (group) group.push(interval);
+    else groups.push([interval]);
+  }
+  return groups.reduce(
+    (total, group) => {
+      const sorted = [...group].sort((a, b) => a.min - b.min);
+      let groupLength = 0;
+      let segmentCount = 1;
+      let currentMin = sorted[0].min;
+      let currentMax = sorted[0].max;
+      for (const interval of sorted.slice(1)) {
+        if (interval.min <= currentMax + RAIL_ALIGNMENT_EPSILON) {
+          currentMax = Math.max(currentMax, interval.max);
+        } else {
+          groupLength += currentMax - currentMin;
+          segmentCount++;
+          currentMin = interval.min;
+          currentMax = interval.max;
+        }
+      }
+      return {
+        length: total.length + groupLength + currentMax - currentMin,
+        segmentCount: total.segmentCount + segmentCount
+      };
+    },
+    { length: 0, segmentCount: 0 }
+  );
+};
+var getVisibleTraceMetrics = (traces) => {
+  const horizontal = [];
+  const vertical = [];
+  for (const trace of traces) {
+    for (let index = 0; index < trace.tracePath.length - 1; index++) {
+      const start = trace.tracePath[index];
+      const end = trace.tracePath[index + 1];
+      if (isHorizontal2(start, end)) {
+        horizontal.push({
+          coordinate: start.y,
+          min: Math.min(start.x, end.x),
+          max: Math.max(start.x, end.x)
+        });
+      } else if (isVertical2(start, end)) {
+        vertical.push({
+          coordinate: start.x,
+          min: Math.min(start.y, end.y),
+          max: Math.max(start.y, end.y)
+        });
+      }
+    }
+  }
+  const horizontalMetrics = getMergedIntervalMetrics(horizontal);
+  const verticalMetrics = getMergedIntervalMetrics(vertical);
+  return {
+    length: horizontalMetrics.length + verticalMetrics.length,
+    segmentCount: horizontalMetrics.segmentCount + verticalMetrics.segmentCount
+  };
+};
+var getVisibleTraceLength = (traces) => getVisibleTraceMetrics(traces).length;
+var getVisibleTraceSegmentCount = (traces) => getVisibleTraceMetrics(traces).segmentCount;
+
 // lib/solvers/TraceCleanupSolver/minimizeTurnsWithFilteredLabels.ts
 var minimizeTurnsWithFilteredLabels = ({
   targetMspConnectionPairId,
@@ -4789,11 +4878,16 @@ var minimizeTurnsWithFilteredLabels = ({
   if (!targetTrace) {
     throw new Error(`Target trace ${targetMspConnectionPairId} not found`);
   }
-  const obstacleTraces = traces.filter(
-    (t) => t.mspPairId !== targetMspConnectionPairId
+  const targetPinIds = new Set(targetTrace.pinIds);
+  const otherTraces = traces.filter(
+    (trace) => trace.mspPairId !== targetMspConnectionPairId
   );
+  const relaxedObstacleTraces = otherTraces.filter((trace) => {
+    const sharesEndpoint = trace.pinIds.some((pinId) => targetPinIds.has(pinId));
+    return trace.globalConnNetId !== targetTrace.globalConnNetId || !sharesEndpoint;
+  });
   const TRACE_WIDTH = 0.01;
-  const traceObstacles = obstacleTraces.flatMap(
+  const getTraceObstacles2 = (obstacleTraces) => obstacleTraces.flatMap(
     (trace, i) => trace.tracePath.slice(0, -1).map((p1, pi) => {
       const p2 = trace.tracePath[pi + 1];
       return {
@@ -4814,7 +4908,6 @@ var minimizeTurnsWithFilteredLabels = ({
     maxX: obs.maxX + PADDING,
     maxY: obs.maxY + PADDING
   }));
-  const combinedObstacles = [...staticObstacles, ...traceObstacles];
   const originalPath = targetTrace.tracePath;
   const filteredLabels = allLabelPlacements.filter((label) => {
     const originalNetIds = mergedLabelNetIdMap[label.globalConnNetId];
@@ -4829,12 +4922,46 @@ var minimizeTurnsWithFilteredLabels = ({
     minY: nl.center.y - nl.height / 2 - paddingBuffer,
     maxY: nl.center.y + nl.height / 2 + paddingBuffer
   }));
-  const newPath = minimizeTurns({
+  const strictPath = minimizeTurns({
+    path: originalPath,
+    obstacles: [...staticObstacles, ...getTraceObstacles2(otherTraces)],
+    labelBounds,
+    originalPath
+  });
+  const relaxedPath = minimizeTurns({
     path: originalPath,
-    obstacles: combinedObstacles,
+    obstacles: [
+      ...staticObstacles,
+      ...getTraceObstacles2(relaxedObstacleTraces)
+    ],
     labelBounds,
     originalPath
   });
+  const sameNetTraces = otherTraces.filter(
+    (trace) => trace.globalConnNetId === targetTrace.globalConnNetId
+  );
+  const getSameNetReadability = (tracePath) => {
+    const tracesWithCandidate = [
+      ...sameNetTraces,
+      { ...targetTrace, tracePath }
+    ];
+    return {
+      segmentCount: getVisibleTraceSegmentCount(tracesWithCandidate),
+      visibleLength: getVisibleTraceLength(tracesWithCandidate)
+    };
+  };
+  const strictTurns = countTurns(strictPath);
+  const relaxedTurns = countTurns(relaxedPath);
+  let newPath = strictPath;
+  if (relaxedTurns < strictTurns) {
+    newPath = relaxedPath;
+  } else if (relaxedTurns === strictTurns) {
+    const strictReadability = getSameNetReadability(strictPath);
+    const relaxedReadability = getSameNetReadability(relaxedPath);
+    if (relaxedReadability.segmentCount < strictReadability.segmentCount || relaxedReadability.segmentCount === strictReadability.segmentCount && relaxedReadability.visibleLength < strictReadability.visibleLength - RAIL_ALIGNMENT_EPSILON) {
+      newPath = relaxedPath;
+    }
+  }
   return {
     ...targetTrace,
     tracePath: newPath
@@ -4978,80 +5105,6 @@ var balanceZShapes = ({
   };
 };
 
-// lib/solvers/TraceCleanupSolver/sameNetRailAlignment/geometry.ts
-var RAIL_ALIGNMENT_EPSILON = 2e-3;
-var nearlyEqual = (a, b) => Math.abs(a - b) < RAIL_ALIGNMENT_EPSILON;
-var isHorizontal2 = (a, b) => nearlyEqual(a.y, b.y);
-var isVertical2 = (a, b) => nearlyEqual(a.x, b.x);
-var isPositiveLength = (a, b) => Math.abs(a.x - b.x) >= RAIL_ALIGNMENT_EPSILON || Math.abs(a.y - b.y) >= RAIL_ALIGNMENT_EPSILON;
-var getRailOrientation = (a, b) => {
-  if (!isPositiveLength(a, b)) return null;
-  if (isVertical2(a, b)) return "vertical";
-  if (isHorizontal2(a, b)) return "horizontal";
-  return null;
-};
-var rangesTouchOrOverlap = (a, b) => Math.min(a.maxAlong, b.maxAlong) - Math.max(a.minAlong, b.minAlong) >= -RAIL_ALIGNMENT_EPSILON;
-var pointsEqual = (a, b) => nearlyEqual(a.x, b.x) && nearlyEqual(a.y, b.y);
-var getDistinctCoordinates = (coordinates) => {
-  const distinct = [];
-  for (const coordinate of coordinates) {
-    if (!distinct.some((item) => nearlyEqual(item, coordinate))) {
-      distinct.push(coordinate);
-    }
-  }
-  return distinct;
-};
-var getMergedIntervalLength = (intervals) => {
-  const groups = [];
-  for (const interval of intervals) {
-    const group = groups.find(
-      (items) => nearlyEqual(items[0].coordinate, interval.coordinate)
-    );
-    if (group) group.push(interval);
-    else groups.push([interval]);
-  }
-  return groups.reduce((total, group) => {
-    const sorted = [...group].sort((a, b) => a.min - b.min);
-    let groupLength = 0;
-    let currentMin = sorted[0].min;
-    let currentMax = sorted[0].max;
-    for (const interval of sorted.slice(1)) {
-      if (interval.min <= currentMax + RAIL_ALIGNMENT_EPSILON) {
-        currentMax = Math.max(currentMax, interval.max);
-      } else {
-        groupLength += currentMax - currentMin;
-        currentMin = interval.min;
-        currentMax = interval.max;
-      }
-    }
-    return total + groupLength + currentMax - currentMin;
-  }, 0);
-};
-var getVisibleTraceLength = (traces) => {
-  const horizontal = [];
-  const vertical = [];
-  for (const trace of traces) {
-    for (let index = 0; index < trace.tracePath.length - 1; index++) {
-      const start = trace.tracePath[index];
-      const end = trace.tracePath[index + 1];
-      if (isHorizontal2(start, end)) {
-        horizontal.push({
-          coordinate: start.y,
-          min: Math.min(start.x, end.x),
-          max: Math.max(start.x, end.x)
-        });
-      } else if (isVertical2(start, end)) {
-        vertical.push({
-          coordinate: start.x,
-          min: Math.min(start.y, end.y),
-          max: Math.max(start.y, end.y)
-        });
-      }
-    }
-  }
-  return getMergedIntervalLength(horizontal) + getMergedIntervalLength(vertical);
-};
-
 // lib/solvers/TraceCleanupSolver/sameNetRailAlignment/moveRailSegments.ts
 var moveRailSegments = (trace, segments, coordinate) => {
   const pointsToMove = /* @__PURE__ */ new Set();

package/lib/solvers/TraceCleanupSolver/minimizeTurnsWithFilteredLabels.ts

@@ -3,13 +3,18 @@ import { minimizeTurns } from "./turnMinimization"
 import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
 import { getObstacleRects } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
 import type { NetLabelPlacement } from "../NetLabelPlacementSolver/NetLabelPlacementSolver"
+import { countTurns } from "./countTurns"
+import {
+  getVisibleTraceLength,
+  getVisibleTraceSegmentCount,
+  RAIL_ALIGNMENT_EPSILON,
+} from "./sameNetRailAlignment/geometry"
 
 /**
- * Minimizes the turns of a target trace while considering other traces and labels as obstacles.
- * This function first identifies the target trace and separates it from other traces, which are then treated as obstacles.
- * It also filters out labels that belong to the target trace's net, so they don't act as obstacles.
- * The function then combines static obstacles (from the input problem) with the other traces and filtered labels to create a comprehensive set of obstacles.
- * Finally, it uses a turn minimization algorithm to find a new path for the target trace that avoids these combined obstacles.
+ * Minimizes turns with a strict pass that treats every other trace as an
+ * obstacle and a relaxed pass that permits joining endpoint-sharing same-net
+ * branches. Equivalent-turn routes are compared by their rendered same-net
+ * complexity so aligned rails win without arbitrarily shifting local routes.
  */
 export const minimizeTurnsWithFilteredLabels = ({
   targetMspConnectionPairId,
@@ -33,23 +38,31 @@ export const minimizeTurnsWithFilteredLabels = ({
     throw new Error(`Target trace ${targetMspConnectionPairId} not found`)
   }
 
-  const obstacleTraces = traces.filter(
-    (t) => t.mspPairId !== targetMspConnectionPairId,
+  const targetPinIds = new Set(targetTrace.pinIds)
+  const otherTraces = traces.filter(
+    (trace) => trace.mspPairId !== targetMspConnectionPairId,
   )
+  const relaxedObstacleTraces = otherTraces.filter((trace) => {
+    const sharesEndpoint = trace.pinIds.some((pinId) => targetPinIds.has(pinId))
+    return (
+      trace.globalConnNetId !== targetTrace.globalConnNetId || !sharesEndpoint
+    )
+  })
 
   const TRACE_WIDTH = 0.01
-  const traceObstacles = obstacleTraces.flatMap((trace, i) =>
-    trace.tracePath.slice(0, -1).map((p1, pi) => {
-      const p2 = trace.tracePath[pi + 1]!
-      return {
-        chipId: `trace-obstacle-${i}-${pi}`,
-        minX: Math.min(p1.x, p2.x) - TRACE_WIDTH / 2,
-        minY: Math.min(p1.y, p2.y) - TRACE_WIDTH / 2,
-        maxX: Math.max(p1.x, p2.x) + TRACE_WIDTH / 2,
-        maxY: Math.max(p1.y, p2.y) + TRACE_WIDTH / 2,
-      }
-    }),
-  )
+  const getTraceObstacles = (obstacleTraces: SolvedTracePath[]) =>
+    obstacleTraces.flatMap((trace, i) =>
+      trace.tracePath.slice(0, -1).map((p1, pi) => {
+        const p2 = trace.tracePath[pi + 1]!
+        return {
+          chipId: `trace-obstacle-${i}-${pi}`,
+          minX: Math.min(p1.x, p2.x) - TRACE_WIDTH / 2,
+          minY: Math.min(p1.y, p2.y) - TRACE_WIDTH / 2,
+          maxX: Math.max(p1.x, p2.x) + TRACE_WIDTH / 2,
+          maxY: Math.max(p1.y, p2.y) + TRACE_WIDTH / 2,
+        }
+      }),
+    )
 
   const staticObstaclesRaw = getObstacleRects(inputProblem)
   const PADDING = 0.01
@@ -61,8 +74,6 @@ export const minimizeTurnsWithFilteredLabels = ({
     maxY: obs.maxY + PADDING,
   }))
 
-  const combinedObstacles = [...staticObstacles, ...traceObstacles]
-
   const originalPath = targetTrace.tracePath
   const filteredLabels = allLabelPlacements.filter((label) => {
     const originalNetIds = mergedLabelNetIdMap[label.globalConnNetId]
@@ -79,13 +90,57 @@ export const minimizeTurnsWithFilteredLabels = ({
     maxY: nl.center.y + nl.height / 2 + paddingBuffer,
   }))
 
-  const newPath = minimizeTurns({
+  const strictPath = minimizeTurns({
     path: originalPath,
-    obstacles: combinedObstacles,
+    obstacles: [...staticObstacles, ...getTraceObstacles(otherTraces)],
     labelBounds,
     originalPath: originalPath,
   })
 
+  const relaxedPath = minimizeTurns({
+    path: originalPath,
+    obstacles: [
+      ...staticObstacles,
+      ...getTraceObstacles(relaxedObstacleTraces),
+    ],
+    labelBounds,
+    originalPath: originalPath,
+  })
+
+  const sameNetTraces = otherTraces.filter(
+    (trace) => trace.globalConnNetId === targetTrace.globalConnNetId,
+  )
+  const getSameNetReadability = (tracePath: SolvedTracePath["tracePath"]) => {
+    const tracesWithCandidate = [
+      ...sameNetTraces,
+      { ...targetTrace, tracePath },
+    ]
+    return {
+      segmentCount: getVisibleTraceSegmentCount(tracesWithCandidate),
+      visibleLength: getVisibleTraceLength(tracesWithCandidate),
+    }
+  }
+
+  const strictTurns = countTurns(strictPath)
+  const relaxedTurns = countTurns(relaxedPath)
+  let newPath = strictPath
+
+  if (relaxedTurns < strictTurns) {
+    newPath = relaxedPath
+  } else if (relaxedTurns === strictTurns) {
+    const strictReadability = getSameNetReadability(strictPath)
+    const relaxedReadability = getSameNetReadability(relaxedPath)
+
+    if (
+      relaxedReadability.segmentCount < strictReadability.segmentCount ||
+      (relaxedReadability.segmentCount === strictReadability.segmentCount &&
+        relaxedReadability.visibleLength <
+          strictReadability.visibleLength - RAIL_ALIGNMENT_EPSILON)
+    ) {
+      newPath = relaxedPath
+    }
+  }
+
   return {
     ...targetTrace,
     tracePath: newPath,

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

@@ -48,7 +48,7 @@ interface Interval {
   max: number
 }
 
-const getMergedIntervalLength = (intervals: Interval[]) => {
+const getMergedIntervalMetrics = (intervals: Interval[]) => {
   const groups: Interval[][] = []
   for (const interval of intervals) {
     const group = groups.find((items) =>
@@ -58,28 +58,35 @@ const getMergedIntervalLength = (intervals: Interval[]) => {
     else groups.push([interval])
   }
 
-  return groups.reduce((total, group) => {
-    const sorted = [...group].sort((a, b) => a.min - b.min)
-    let groupLength = 0
-    let currentMin = sorted[0]!.min
-    let currentMax = sorted[0]!.max
-
-    for (const interval of sorted.slice(1)) {
-      if (interval.min <= currentMax + RAIL_ALIGNMENT_EPSILON) {
-        currentMax = Math.max(currentMax, interval.max)
-      } else {
-        groupLength += currentMax - currentMin
-        currentMin = interval.min
-        currentMax = interval.max
+  return groups.reduce(
+    (total, group) => {
+      const sorted = [...group].sort((a, b) => a.min - b.min)
+      let groupLength = 0
+      let segmentCount = 1
+      let currentMin = sorted[0]!.min
+      let currentMax = sorted[0]!.max
+
+      for (const interval of sorted.slice(1)) {
+        if (interval.min <= currentMax + RAIL_ALIGNMENT_EPSILON) {
+          currentMax = Math.max(currentMax, interval.max)
+        } else {
+          groupLength += currentMax - currentMin
+          segmentCount++
+          currentMin = interval.min
+          currentMax = interval.max
+        }
       }
-    }
 
-    return total + groupLength + currentMax - currentMin
-  }, 0)
+      return {
+        length: total.length + groupLength + currentMax - currentMin,
+        segmentCount: total.segmentCount + segmentCount,
+      }
+    },
+    { length: 0, segmentCount: 0 },
+  )
 }
 
-/** Returns rendered length after overlapping collinear runs are merged. */
-export const getVisibleTraceLength = (traces: SolvedTracePath[]) => {
+const getVisibleTraceMetrics = (traces: SolvedTracePath[]) => {
   const horizontal: Interval[] = []
   const vertical: Interval[] = []
 
@@ -104,5 +111,18 @@ export const getVisibleTraceLength = (traces: SolvedTracePath[]) => {
     }
   }
 
-  return getMergedIntervalLength(horizontal) + getMergedIntervalLength(vertical)
+  const horizontalMetrics = getMergedIntervalMetrics(horizontal)
+  const verticalMetrics = getMergedIntervalMetrics(vertical)
+  return {
+    length: horizontalMetrics.length + verticalMetrics.length,
+    segmentCount: horizontalMetrics.segmentCount + verticalMetrics.segmentCount,
+  }
 }
+
+/** Returns rendered length after overlapping collinear runs are merged. */
+export const getVisibleTraceLength = (traces: SolvedTracePath[]) =>
+  getVisibleTraceMetrics(traces).length
+
+/** Returns the number of distinct collinear runs visible on the schematic. */
+export const getVisibleTraceSegmentCount = (traces: SolvedTracePath[]) =>
+  getVisibleTraceMetrics(traces).segmentCount

package/package.json

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

package/site/bug-reports/bug-report-20260721T221026Z.page.tsx

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