@tscircuit/schematic-trace-solver 0.0.122 → 0.0.124

package/dist/index.js

@@ -5108,6 +5108,51 @@ var getVisibleTraceMetrics = (traces) => {
 var getVisibleTraceLength = (traces) => getVisibleTraceMetrics(traces).length;
 var getVisibleTraceSegmentCount = (traces) => getVisibleTraceMetrics(traces).segmentCount;
 
+// lib/solvers/TraceCleanupSolver/shortenExcessiveLabelPaddingDetour.ts
+var MIN_EXCESSIVE_DETOUR_LENGTH_RATIO = 2.5;
+var getTracePathLength = (tracePath) => {
+  let pathLength = 0;
+  for (let pointIndex = 1; pointIndex < tracePath.length; pointIndex++) {
+    const previousPoint = tracePath[pointIndex - 1];
+    const point = tracePath[pointIndex];
+    pathLength += Math.abs(point.x - previousPoint.x) + Math.abs(point.y - previousPoint.y);
+  }
+  return pathLength;
+};
+var shortenExcessiveLabelPaddingDetour = ({
+  inputProblem,
+  trace
+}) => {
+  const exactConnection = inputProblem.directConnections.find(
+    (connection) => connection.pinIds.every((pinId) => trace.pinIds.includes(pinId))
+  );
+  if (!exactConnection) return trace;
+  const chipMap = {};
+  for (const chip of inputProblem.chips) chipMap[chip.chipId] = chip;
+  const candidateSolver = new SchematicTraceSingleLineSolver2({
+    pins: trace.pins,
+    connectionPair: trace,
+    inputProblem: {
+      ...inputProblem,
+      directConnections: [
+        exactConnection,
+        ...inputProblem.directConnections.filter(
+          (connection) => connection !== exactConnection
+        )
+      ]
+    },
+    chipMap
+  });
+  candidateSolver.solve();
+  if (!candidateSolver.solvedTracePath) return trace;
+  const currentLength = getTracePathLength(trace.tracePath);
+  const candidateLength = getTracePathLength(candidateSolver.solvedTracePath);
+  if (currentLength <= candidateLength * MIN_EXCESSIVE_DETOUR_LENGTH_RATIO) {
+    return trace;
+  }
+  return { ...trace, tracePath: candidateSolver.solvedTracePath };
+};
+
 // lib/solvers/TraceCleanupSolver/minimizeTurnsWithFilteredLabels.ts
 var minimizeTurnsWithFilteredLabels = ({
   targetMspConnectionPairId,
@@ -5117,12 +5162,16 @@ var minimizeTurnsWithFilteredLabels = ({
   mergedLabelNetIdMap,
   paddingBuffer
 }) => {
-  const targetTrace = traces.find(
+  const originalTargetTrace = traces.find(
     (t) => t.mspPairId === targetMspConnectionPairId
   );
-  if (!targetTrace) {
+  if (!originalTargetTrace) {
     throw new Error(`Target trace ${targetMspConnectionPairId} not found`);
   }
+  const targetTrace = shortenExcessiveLabelPaddingDetour({
+    inputProblem,
+    trace: originalTargetTrace
+  });
   const targetPinIds = new Set(targetTrace.pinIds);
   const otherTraces = traces.filter(
     (trace) => trace.mspPairId !== targetMspConnectionPairId
@@ -11181,6 +11230,7 @@ var UnroutedTraceRecoverySolver = class extends BaseSolver {
 };
 
 // lib/solvers/SameNetJunctionAlignmentSolver/pathIntersectsAnyNetLabel.ts
+var NET_LABEL_INTERIOR_INSET = 1e-6;
 var pathIntersectsAnyNetLabel = ({
   path,
   netLabelPlacements
@@ -11195,9 +11245,30 @@ var pathIntersectsAnyNetLabel = ({
   }
   return false;
 };
+var pathEntersAnyNetLabel = ({
+  path,
+  netLabelPlacements
+}) => {
+  for (const label of netLabelPlacements) {
+    const labelBounds = getRectBounds(label.center, label.width, label.height);
+    const labelInteriorBounds = {
+      minX: labelBounds.minX + NET_LABEL_INTERIOR_INSET,
+      minY: labelBounds.minY + NET_LABEL_INTERIOR_INSET,
+      maxX: labelBounds.maxX - NET_LABEL_INTERIOR_INSET,
+      maxY: labelBounds.maxY - NET_LABEL_INTERIOR_INSET
+    };
+    for (let index = 0; index < path.length - 1; index++) {
+      if (segmentIntersectsRect2(path[index], path[index + 1], labelInteriorBounds)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
 
 // lib/solvers/SameNetJunctionAlignmentSolver/alignSameNetJunctions.ts
 var MAX_ALIGNED_LOAD_PIN_OFFSET = 0.2;
+var MAX_SAME_NET_LABEL_BOUNDARY_RAIL_OFFSET = 0.2;
 var getSharedPin = ({
   donorTrace,
   branchTrace
@@ -11274,6 +11345,7 @@ var getAlignedBranchPath = ({
 };
 var candidateIsClear = ({
   candidateTrace,
+  originalTrace,
   traces,
   inputProblem,
   netLabelPlacements
@@ -11288,10 +11360,34 @@ var candidateIsClear = ({
   if (doesPathCoincideWithTraces(candidateTrace.tracePath, otherNetTraces)) {
     return false;
   }
-  return !pathIntersectsAnyNetLabel({
+  const otherNetLabelPlacements = netLabelPlacements.filter(
+    (label) => label.globalConnNetId !== candidateTrace.globalConnNetId
+  );
+  if (pathIntersectsAnyNetLabel({
     path: candidateTrace.tracePath,
-    netLabelPlacements
-  });
+    netLabelPlacements: otherNetLabelPlacements
+  })) {
+    return false;
+  }
+  const sameNetLabelPlacements = netLabelPlacements.filter(
+    (label) => label.globalConnNetId === candidateTrace.globalConnNetId
+  );
+  if (!pathIntersectsAnyNetLabel({
+    path: candidateTrace.tracePath,
+    netLabelPlacements: sameNetLabelPlacements
+  })) {
+    return true;
+  }
+  if (pathEntersAnyNetLabel({
+    path: candidateTrace.tracePath,
+    netLabelPlacements: sameNetLabelPlacements
+  })) {
+    return false;
+  }
+  const originalRail = getLongestHorizontalSegment(originalTrace);
+  const candidateRail = getLongestHorizontalSegment(candidateTrace);
+  if (!originalRail || !candidateRail) return false;
+  return Math.abs(originalRail.start.y - candidateRail.start.y) <= MAX_SAME_NET_LABEL_BOUNDARY_RAIL_OFFSET;
 };
 var alignSameNetJunctions = ({
   inputProblem,
@@ -11324,6 +11420,7 @@ var alignSameNetJunctions = ({
       }
       if (!candidateIsClear({
         candidateTrace,
+        originalTrace: branchTrace,
         traces: outputTraces,
         inputProblem,
         netLabelPlacements

package/lib/solvers/SameNetJunctionAlignmentSolver/alignSameNetJunctions.ts

@@ -12,7 +12,10 @@ import {
 } from "lib/solvers/TraceCleanupSolver/sameNetRailAlignment/geometry"
 import type { InputPin, InputProblem } from "lib/types/InputProblem"
 import { doesPathCoincideWithTraces } from "lib/utils/doesPathCoincideWithTraces"
-import { pathIntersectsAnyNetLabel } from "./pathIntersectsAnyNetLabel"
+import {
+  pathEntersAnyNetLabel,
+  pathIntersectsAnyNetLabel,
+} from "./pathIntersectsAnyNetLabel"
 
 interface AlignSameNetJunctionsInput {
   inputProblem: InputProblem
@@ -25,7 +28,10 @@ interface HorizontalSegment {
   end: Point
 }
 
+// Only near-level load pins should be combined onto one horizontal rail.
 const MAX_ALIGNED_LOAD_PIN_OFFSET = 0.2
+// Limit label-boundary alignment to small corrections that cannot create spikes.
+const MAX_SAME_NET_LABEL_BOUNDARY_RAIL_OFFSET = 0.2
 
 const getSharedPin = ({
   donorTrace,
@@ -135,11 +141,13 @@ const getAlignedBranchPath = ({
 
 const candidateIsClear = ({
   candidateTrace,
+  originalTrace,
   traces,
   inputProblem,
   netLabelPlacements,
 }: {
   candidateTrace: SolvedTracePath
+  originalTrace: SolvedTracePath
   traces: SolvedTracePath[]
   inputProblem: InputProblem
   netLabelPlacements: NetLabelPlacement[]
@@ -156,10 +164,46 @@ const candidateIsClear = ({
     return false
   }
 
-  return !pathIntersectsAnyNetLabel({
-    path: candidateTrace.tracePath,
-    netLabelPlacements,
-  })
+  const otherNetLabelPlacements = netLabelPlacements.filter(
+    (label) => label.globalConnNetId !== candidateTrace.globalConnNetId,
+  )
+  if (
+    pathIntersectsAnyNetLabel({
+      path: candidateTrace.tracePath,
+      netLabelPlacements: otherNetLabelPlacements,
+    })
+  ) {
+    return false
+  }
+
+  const sameNetLabelPlacements = netLabelPlacements.filter(
+    (label) => label.globalConnNetId === candidateTrace.globalConnNetId,
+  )
+  // A same-net rail may follow its label edge, but never enter the label body.
+  if (
+    !pathIntersectsAnyNetLabel({
+      path: candidateTrace.tracePath,
+      netLabelPlacements: sameNetLabelPlacements,
+    })
+  ) {
+    return true
+  }
+  if (
+    pathEntersAnyNetLabel({
+      path: candidateTrace.tracePath,
+      netLabelPlacements: sameNetLabelPlacements,
+    })
+  ) {
+    return false
+  }
+
+  const originalRail = getLongestHorizontalSegment(originalTrace)
+  const candidateRail = getLongestHorizontalSegment(candidateTrace)
+  if (!originalRail || !candidateRail) return false
+  return (
+    Math.abs(originalRail.start.y - candidateRail.start.y) <=
+    MAX_SAME_NET_LABEL_BOUNDARY_RAIL_OFFSET
+  )
 }
 
 export const alignSameNetJunctions = ({
@@ -202,6 +246,7 @@ export const alignSameNetJunctions = ({
       if (
         !candidateIsClear({
           candidateTrace,
+          originalTrace: branchTrace,
           traces: outputTraces,
           inputProblem,
           netLabelPlacements,

package/lib/solvers/SameNetJunctionAlignmentSolver/pathIntersectsAnyNetLabel.ts

@@ -3,6 +3,9 @@ import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetL
 import { segmentIntersectsRect } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/collisions"
 import { getRectBounds } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
 
+// Insetting distinguishes harmless edge contact from entering the label body.
+const NET_LABEL_INTERIOR_INSET = 1e-6
+
 export const pathIntersectsAnyNetLabel = ({
   path,
   netLabelPlacements,
@@ -20,3 +23,29 @@ export const pathIntersectsAnyNetLabel = ({
   }
   return false
 }
+
+export const pathEntersAnyNetLabel = ({
+  path,
+  netLabelPlacements,
+}: {
+  path: Point[]
+  netLabelPlacements: NetLabelPlacement[]
+}) => {
+  for (const label of netLabelPlacements) {
+    const labelBounds = getRectBounds(label.center, label.width, label.height)
+    const labelInteriorBounds = {
+      minX: labelBounds.minX + NET_LABEL_INTERIOR_INSET,
+      minY: labelBounds.minY + NET_LABEL_INTERIOR_INSET,
+      maxX: labelBounds.maxX - NET_LABEL_INTERIOR_INSET,
+      maxY: labelBounds.maxY - NET_LABEL_INTERIOR_INSET,
+    }
+    for (let index = 0; index < path.length - 1; index++) {
+      if (
+        segmentIntersectsRect(path[index], path[index + 1], labelInteriorBounds)
+      ) {
+        return true
+      }
+    }
+  }
+  return false
+}

package/lib/solvers/TraceCleanupSolver/minimizeTurnsWithFilteredLabels.ts

@@ -9,6 +9,7 @@ import {
   getVisibleTraceSegmentCount,
   RAIL_ALIGNMENT_EPSILON,
 } from "./sameNetRailAlignment/geometry"
+import { shortenExcessiveLabelPaddingDetour } from "./shortenExcessiveLabelPaddingDetour"
 
 /**
  * Minimizes turns with a strict pass that treats every other trace as an
@@ -31,12 +32,16 @@ export const minimizeTurnsWithFilteredLabels = ({
   mergedLabelNetIdMap: Record<string, Set<string>>
   paddingBuffer: number
 }): SolvedTracePath => {
-  const targetTrace = traces.find(
+  const originalTargetTrace = traces.find(
     (t) => t.mspPairId === targetMspConnectionPairId,
   )
-  if (!targetTrace) {
+  if (!originalTargetTrace) {
     throw new Error(`Target trace ${targetMspConnectionPairId} not found`)
   }
+  const targetTrace = shortenExcessiveLabelPaddingDetour({
+    inputProblem,
+    trace: originalTargetTrace,
+  })
 
   const targetPinIds = new Set(targetTrace.pinIds)
   const otherTraces = traces.filter(

package/lib/solvers/TraceCleanupSolver/shortenExcessiveLabelPaddingDetour.ts

@@ -0,0 +1,64 @@
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { SchematicTraceSingleLineSolver2 } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/SchematicTraceSingleLineSolver2"
+import type { InputChip, InputProblem } from "lib/types/InputProblem"
+
+const MIN_EXCESSIVE_DETOUR_LENGTH_RATIO = 2.5
+
+const getTracePathLength = (
+  tracePath: SolvedTracePath["tracePath"],
+): number => {
+  let pathLength = 0
+  for (let pointIndex = 1; pointIndex < tracePath.length; pointIndex++) {
+    const previousPoint = tracePath[pointIndex - 1]!
+    const point = tracePath[pointIndex]!
+    pathLength +=
+      Math.abs(point.x - previousPoint.x) + Math.abs(point.y - previousPoint.y)
+  }
+  return pathLength
+}
+
+/**
+ * Retries an already-solved severe detour with its exact direct connection
+ * first, preventing a sibling branch's label width from inflating text padding.
+ * The shorter route is used only when it is less than 40% of the original.
+ */
+export const shortenExcessiveLabelPaddingDetour = ({
+  inputProblem,
+  trace,
+}: {
+  inputProblem: InputProblem
+  trace: SolvedTracePath
+}): SolvedTracePath => {
+  const exactConnection = inputProblem.directConnections.find((connection) =>
+    connection.pinIds.every((pinId) => trace.pinIds.includes(pinId)),
+  )
+  if (!exactConnection) return trace
+
+  const chipMap: Record<string, InputChip> = {}
+  for (const chip of inputProblem.chips) chipMap[chip.chipId] = chip
+
+  const candidateSolver = new SchematicTraceSingleLineSolver2({
+    pins: trace.pins,
+    connectionPair: trace,
+    inputProblem: {
+      ...inputProblem,
+      directConnections: [
+        exactConnection,
+        ...inputProblem.directConnections.filter(
+          (connection) => connection !== exactConnection,
+        ),
+      ],
+    },
+    chipMap,
+  })
+  candidateSolver.solve()
+  if (!candidateSolver.solvedTracePath) return trace
+
+  const currentLength = getTracePathLength(trace.tracePath)
+  const candidateLength = getTracePathLength(candidateSolver.solvedTracePath)
+  if (currentLength <= candidateLength * MIN_EXCESSIVE_DETOUR_LENGTH_RATIO) {
+    return trace
+  }
+
+  return { ...trace, tracePath: candidateSolver.solvedTracePath }
+}

package/package.json

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

package/site/bug-reports/bug-report-20260804T171919Z.page.tsx

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

package/site/bug-reports/bug-report-20260804T225912Z.page.tsx

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