@tscircuit/schematic-trace-solver 0.0.147 → 0.0.149

package/dist/index.d.ts

@@ -1186,6 +1186,8 @@ declare const DEFAULT_INLINE_NET_LABEL_HEIGHT = 0.18;
  * Gap between the trace and the near edge of the inline label text.
  */
 declare const INLINE_NET_LABEL_TRACE_MARGIN = 0.05;
+/** Clearance between a generated terminal stub and an unrelated trace. */
+declare const INLINE_NET_LABEL_STUB_TRACE_CLEARANCE = 0.05;
 /**
  * Largest perpendicular deviation a route may have and still be labeled as one
  * span. A route that is straight except for elbow jogs up to this size reads
@@ -1361,4 +1363,4 @@ declare class SchematicTracePipelineSolver extends BaseSolver {
     preview(): GraphicsObject;
 }
 
-export { type ChipId, DEFAULT_INLINE_NET_LABEL_HEIGHT, INLINE_NET_LABEL_MAX_SPAN_JOG, INLINE_NET_LABEL_TRACE_MARGIN, type InlineNetLabelPlacement, InlineNetLabelSolver, type InputChip, type InputDirectConnection, type InputNetConnection, type InputPin, type InputProblem, type NetId, type NetLabelPlacement, type PinId, SchematicTracePipelineSolver, SchematicTraceSingleLineSolver2, type SectionId, type TextBoxes, estimateInlineNetLabelWidth };
+export { type ChipId, DEFAULT_INLINE_NET_LABEL_HEIGHT, INLINE_NET_LABEL_MAX_SPAN_JOG, INLINE_NET_LABEL_STUB_TRACE_CLEARANCE, INLINE_NET_LABEL_TRACE_MARGIN, type InlineNetLabelPlacement, InlineNetLabelSolver, type InputChip, type InputDirectConnection, type InputNetConnection, type InputPin, type InputProblem, type NetId, type NetLabelPlacement, type PinId, SchematicTracePipelineSolver, SchematicTraceSingleLineSolver2, type SectionId, type TextBoxes, estimateInlineNetLabelWidth };

package/dist/index.js

@@ -6352,6 +6352,51 @@ var generateLShapeRerouteCandidates = ({
   }
   return [[i1_padded, c2, i2_padded]];
 };
+var generatePerimeterCornerTraceDetours = ({
+  trace,
+  chipBounds,
+  clearance
+}) => {
+  if (trace.tracePath.length < 4 || chipBounds.length === 0) return [];
+  const start = trace.tracePath[0];
+  const firstEscape = trace.tracePath[1];
+  const lastEscape = trace.tracePath.at(-2);
+  const end = trace.tracePath.at(-1);
+  const minX = Math.min(...chipBounds.map((bounds) => bounds.minX)) - clearance;
+  const maxX = Math.max(...chipBounds.map((bounds) => bounds.maxX)) + clearance;
+  const minY = Math.min(...chipBounds.map((bounds) => bounds.minY)) - clearance;
+  const maxY = Math.max(...chipBounds.map((bounds) => bounds.maxY)) + clearance;
+  const candidates = [];
+  for (const channelX of [minX, maxX]) {
+    for (const channelY of [minY, maxY]) {
+      candidates.push({
+        traceId: trace.mspPairId,
+        path: simplifyPath([
+          start,
+          firstEscape,
+          { x: firstEscape.x, y: channelY },
+          { x: channelX, y: channelY },
+          { x: channelX, y: lastEscape.y },
+          lastEscape,
+          end
+        ])
+      });
+      candidates.push({
+        traceId: trace.mspPairId,
+        path: simplifyPath([
+          start,
+          firstEscape,
+          { x: channelX, y: firstEscape.y },
+          { x: channelX, y: channelY },
+          { x: lastEscape.x, y: channelY },
+          lastEscape,
+          end
+        ])
+      });
+    }
+  }
+  return candidates;
+};
 var generatePerpendicularTraceDetours = ({
   trace,
   segmentIndex,
@@ -6663,7 +6708,8 @@ var UntangleTraceSubsolver = class extends BaseSolver {
         const otherTrace = traces[secondIndex];
         if (trace.globalConnNetId === otherTrace.globalConnNetId) continue;
         const isInitialBundleCrossing = this._isTraceBundle(trace, otherTrace);
-        if (!isInitialBundleCrossing && !this.reroutedTraceIds.has(trace.mspPairId) && !this.reroutedTraceIds.has(otherTrace.mspPairId)) {
+        const isEligibleInitialCrossing = this.input.eligibleTraceIds?.has(trace.mspPairId) === true || this.input.eligibleTraceIds?.has(otherTrace.mspPairId) === true;
+        if (!isInitialBundleCrossing && !isEligibleInitialCrossing && !this.reroutedTraceIds.has(trace.mspPairId) && !this.reroutedTraceIds.has(otherTrace.mspPairId)) {
           continue;
         }
         const crossings = findPerpendicularPathCrossings(
@@ -6706,6 +6752,16 @@ var UntangleTraceSubsolver = class extends BaseSolver {
         obstacleEnd: crossing.trace.tracePath[crossing.segmentIndex + 1],
         chipBounds,
         clearance: this.input.paddingBuffer
+      }),
+      ...generatePerimeterCornerTraceDetours({
+        trace: crossing.trace,
+        chipBounds,
+        clearance: this.input.paddingBuffer
+      }),
+      ...generatePerimeterCornerTraceDetours({
+        trace: crossing.otherTrace,
+        chipBounds,
+        clearance: this.input.paddingBuffer
       })
     ];
     const chipObstacles = getObstacleRects(this.input.inputProblem).filter(
@@ -12622,47 +12678,6 @@ var TraceElbowTransitionSimplificationSolver = class extends BaseSolver {
   }
 };
 
-// lib/solvers/InlineNetLabelSolver/getAxisAlignedSegments.ts
-var getAxisAlignedSegments = (path, epsilon = 1e-6) => {
-  const segments = [];
-  let runStart = null;
-  let runAxis = null;
-  let runSign = 0;
-  const closeRun = (runEnd) => {
-    if (runStart && runAxis) {
-      const length = runAxis === "x" ? Math.abs(runEnd.x - runStart.x) : Math.abs(runEnd.y - runStart.y);
-      if (length > epsilon) {
-        segments.push({ start: runStart, end: runEnd, axis: runAxis, length });
-      }
-    }
-    runStart = null;
-    runAxis = null;
-    runSign = 0;
-  };
-  for (let i = 0; i < path.length - 1; i++) {
-    const a = path[i];
-    const b = path[i + 1];
-    const dx = b.x - a.x;
-    const dy = b.y - a.y;
-    if (Math.abs(dx) <= epsilon && Math.abs(dy) <= epsilon) continue;
-    const axis = Math.abs(dy) <= epsilon ? "x" : Math.abs(dx) <= epsilon ? "y" : null;
-    if (!axis) {
-      closeRun(a);
-      continue;
-    }
-    const sign = Math.sign(axis === "x" ? dx : dy);
-    if (runStart && runAxis === axis && runSign === sign) continue;
-    closeRun(a);
-    runStart = a;
-    runAxis = axis;
-    runSign = sign;
-  }
-  if (path.length >= 2) {
-    closeRun(path[path.length - 1]);
-  }
-  return segments.sort((a, b) => b.length - a.length);
-};
-
 // lib/solvers/InlineNetLabelSolver/alignPortOnlyInlineNetLabelStubs.ts
 var getStubDirection = (path) => {
   const [start, end] = path;
@@ -12811,6 +12826,47 @@ var alignPortOnlyInlineNetLabelStubs = ({
   return alignedPlacements;
 };
 
+// lib/solvers/InlineNetLabelSolver/getAxisAlignedSegments.ts
+var getAxisAlignedSegments = (path, epsilon = 1e-6) => {
+  const segments = [];
+  let runStart = null;
+  let runAxis = null;
+  let runSign = 0;
+  const closeRun = (runEnd) => {
+    if (runStart && runAxis) {
+      const length = runAxis === "x" ? Math.abs(runEnd.x - runStart.x) : Math.abs(runEnd.y - runStart.y);
+      if (length > epsilon) {
+        segments.push({ start: runStart, end: runEnd, axis: runAxis, length });
+      }
+    }
+    runStart = null;
+    runAxis = null;
+    runSign = 0;
+  };
+  for (let i = 0; i < path.length - 1; i++) {
+    const a = path[i];
+    const b = path[i + 1];
+    const dx = b.x - a.x;
+    const dy = b.y - a.y;
+    if (Math.abs(dx) <= epsilon && Math.abs(dy) <= epsilon) continue;
+    const axis = Math.abs(dy) <= epsilon ? "x" : Math.abs(dx) <= epsilon ? "y" : null;
+    if (!axis) {
+      closeRun(a);
+      continue;
+    }
+    const sign = Math.sign(axis === "x" ? dx : dy);
+    if (runStart && runAxis === axis && runSign === sign) continue;
+    closeRun(a);
+    runStart = a;
+    runAxis = axis;
+    runSign = sign;
+  }
+  if (path.length >= 2) {
+    closeRun(path[path.length - 1]);
+  }
+  return segments.sort((a, b) => b.length - a.length);
+};
+
 // lib/solvers/InlineNetLabelSolver/pushAnchoredNetLabelsAwayFromInlineLabels.ts
 var LABEL_CLEARANCE2 = 0.05;
 var POINT_EPSILON = 1e-6;
@@ -13173,6 +13229,7 @@ var pushAnchoredNetLabelsAwayFromInlineLabels = ({
 // lib/solvers/InlineNetLabelSolver/InlineNetLabelSolver.ts
 var DEFAULT_INLINE_NET_LABEL_HEIGHT = 0.18;
 var INLINE_NET_LABEL_TRACE_MARGIN = 0.05;
+var INLINE_NET_LABEL_STUB_TRACE_CLEARANCE = 0.05;
 var INLINE_NET_LABEL_MAX_SPAN_JOG = 0.4;
 var getPinPairKey2 = (pinIds) => [...pinIds].sort().join("::");
 var InlineNetLabelSolver = class extends BaseSolver {
@@ -13273,7 +13330,15 @@ var InlineNetLabelSolver = class extends BaseSolver {
     const stubLength = Math.max(width + 0.2, 0.6);
     const start = inputPin ? { x: inputPin.x, y: inputPin.y } : anchoredPlacement.anchorPoint;
     const direction = inputPin && inputChip ? inputPin._facingDirection ?? getPinDirection(inputPin, inputChip) : anchoredPlacement.orientation;
-    const end = direction === "x+" ? { x: start.x + stubLength, y: start.y } : direction === "x-" ? { x: start.x - stubLength, y: start.y } : direction === "y+" ? { x: start.x, y: start.y + stubLength } : { x: start.x, y: start.y - stubLength };
+    const intendedEnd = direction === "x+" ? { x: start.x + stubLength, y: start.y } : direction === "x-" ? { x: start.x - stubLength, y: start.y } : direction === "y+" ? { x: start.x, y: start.y + stubLength } : { x: start.x, y: start.y - stubLength };
+    const end = getCollisionLimitedTerminalStubEnd({
+      start,
+      intendedEnd,
+      minimumLength: width + 2 * INLINE_NET_LABEL_TRACE_MARGIN,
+      traces: this.traces,
+      ownGlobalConnNetId: anchoredPlacement.globalConnNetId
+    });
+    if (!end) return null;
     const axis = direction === "x+" || direction === "x-" ? "x" : "y";
     const side = axis === "x" ? "y+" : "x-";
     const anchorPoint = {
@@ -13625,6 +13690,55 @@ var doesPathIntersectBounds2 = (path, bounds) => {
   }
   return false;
 };
+var GEOMETRY_EPSILON = 1e-6;
+var getCollisionLimitedTerminalStubEnd = ({
+  start,
+  intendedEnd,
+  minimumLength,
+  traces,
+  ownGlobalConnNetId
+}) => {
+  const isHorizontal4 = Math.abs(intendedEnd.x - start.x) >= Math.abs(intendedEnd.y - start.y);
+  const alongAxis = isHorizontal4 ? "x" : "y";
+  const acrossAxis = isHorizontal4 ? "y" : "x";
+  const direction = Math.sign(intendedEnd[alongAxis] - start[alongAxis]) || 1;
+  const intendedLength = Math.abs(intendedEnd[alongAxis] - start[alongAxis]);
+  let availableLength = intendedLength;
+  for (const trace of traces) {
+    if (trace.globalConnNetId === ownGlobalConnNetId) continue;
+    for (let segmentIndex = 0; segmentIndex < trace.tracePath.length - 1; segmentIndex++) {
+      const segmentStart = trace.tracePath[segmentIndex];
+      const segmentEnd = trace.tracePath[segmentIndex + 1];
+      const startAlong = (segmentStart[alongAxis] - start[alongAxis]) * direction;
+      const endAlong = (segmentEnd[alongAxis] - start[alongAxis]) * direction;
+      const startAcross = segmentStart[acrossAxis] - start[acrossAxis];
+      const endAcross = segmentEnd[acrossAxis] - start[acrossAxis];
+      const minAlong = Math.min(startAlong, endAlong);
+      const maxAlong = Math.max(startAlong, endAlong);
+      const minAcross = Math.min(startAcross, endAcross);
+      const maxAcross = Math.max(startAcross, endAcross);
+      let collisionDistance;
+      const isCollinear = Math.abs(startAcross) <= GEOMETRY_EPSILON && Math.abs(endAcross) <= GEOMETRY_EPSILON;
+      if (isCollinear && maxAlong >= -GEOMETRY_EPSILON && minAlong <= intendedLength + GEOMETRY_EPSILON) {
+        collisionDistance = Math.max(0, minAlong);
+      } else {
+        const crossesStubAxis = minAcross <= GEOMETRY_EPSILON && maxAcross >= -GEOMETRY_EPSILON;
+        const perpendicularAlong = (startAlong + endAlong) / 2;
+        if (crossesStubAxis && Math.abs(startAlong - endAlong) <= GEOMETRY_EPSILON && perpendicularAlong >= -GEOMETRY_EPSILON && perpendicularAlong <= intendedLength + GEOMETRY_EPSILON) {
+          collisionDistance = Math.max(0, perpendicularAlong);
+        }
+      }
+      if (collisionDistance !== void 0) {
+        availableLength = Math.min(
+          availableLength,
+          collisionDistance - INLINE_NET_LABEL_STUB_TRACE_CLEARANCE
+        );
+      }
+    }
+  }
+  if (availableLength + GEOMETRY_EPSILON < minimumLength) return null;
+  return isHorizontal4 ? { x: start.x + direction * availableLength, y: start.y } : { x: start.x, y: start.y + direction * availableLength };
+};
 
 // lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts
 function definePipelineStep(solverName, solverClass, getConstructorParams, opts = {}) {
@@ -13803,6 +13917,42 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
     definePipelineStep("traceCleanupSolver", TraceCleanupSolver, (instance) => {
       const prevSolverOutput = instance.traceElbowTransitionSimplificationSolver.getOutput();
       const traces = prevSolverOutput.traces;
+      const overlapShiftSolver = instance.traceOverlapShiftSolver;
+      const inlineLabelNetIds = new Set(
+        [
+          ...instance.inputProblem.directConnections,
+          ...instance.inputProblem.netConnections
+        ].filter((connection) => connection.allowInlineNetLabel).map((connection) => connection.netId)
+      );
+      const traceIdsInNewCrossingsAfterOverlapShift = /* @__PURE__ */ new Set();
+      for (let traceIndex = 0; traceIndex < overlapShiftSolver.inputTracePaths.length; traceIndex++) {
+        const inputTrace = overlapShiftSolver.inputTracePaths[traceIndex];
+        const shiftedTrace = overlapShiftSolver.correctedTraceMap[inputTrace.mspPairId];
+        for (let otherTraceIndex = traceIndex + 1; otherTraceIndex < overlapShiftSolver.inputTracePaths.length; otherTraceIndex++) {
+          const otherInputTrace = overlapShiftSolver.inputTracePaths[otherTraceIndex];
+          if (inputTrace.globalConnNetId === otherInputTrace.globalConnNetId) {
+            continue;
+          }
+          if (!inlineLabelNetIds.has(inputTrace.userNetId ?? "") && !inlineLabelNetIds.has(otherInputTrace.userNetId ?? "")) {
+            continue;
+          }
+          const otherShiftedTrace = overlapShiftSolver.correctedTraceMap[otherInputTrace.mspPairId];
+          const crossingCountBeforeShift = findPerpendicularPathCrossings(
+            inputTrace.tracePath,
+            otherInputTrace.tracePath
+          ).length;
+          const crossingCountAfterShift = findPerpendicularPathCrossings(
+            shiftedTrace.tracePath,
+            otherShiftedTrace.tracePath
+          ).length;
+          if (crossingCountAfterShift > crossingCountBeforeShift) {
+            traceIdsInNewCrossingsAfterOverlapShift.add(inputTrace.mspPairId);
+            traceIdsInNewCrossingsAfterOverlapShift.add(
+              otherInputTrace.mspPairId
+            );
+          }
+        }
+      }
       const labelMergingOutput = instance.traceLabelOverlapAvoidanceSolver.labelMergingSolver.getOutput();
       return [
         {
@@ -13810,7 +13960,8 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
           allTraces: traces,
           allLabelPlacements: labelMergingOutput.netLabelPlacements,
           mergedLabelNetIdMap: labelMergingOutput.mergedLabelNetIdMap,
-          paddingBuffer: 0.1
+          paddingBuffer: 0.1,
+          eligibleTraceIds: traceIdsInNewCrossingsAfterOverlapShift
         }
       ];
     }),
@@ -14153,6 +14304,7 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
 export {
   DEFAULT_INLINE_NET_LABEL_HEIGHT,
   INLINE_NET_LABEL_MAX_SPAN_JOG,
+  INLINE_NET_LABEL_STUB_TRACE_CLEARANCE,
   INLINE_NET_LABEL_TRACE_MARGIN,
   InlineNetLabelSolver,
   SchematicTracePipelineSolver,

package/lib/solvers/InlineNetLabelSolver/InlineNetLabelSolver.ts

@@ -13,11 +13,11 @@ import type {
 } from "lib/types/InputProblem"
 import { getColorFromString } from "lib/utils/getColorFromString"
 import { boundsOverlap, getTextBoxBounds } from "lib/utils/textBoxBounds"
+import { alignPortOnlyInlineNetLabelStubs } from "./alignPortOnlyInlineNetLabelStubs"
 import {
   type AxisAlignedSegment,
   getAxisAlignedSegments,
 } from "./getAxisAlignedSegments"
-import { alignPortOnlyInlineNetLabelStubs } from "./alignPortOnlyInlineNetLabelStubs"
 import { pushAnchoredNetLabelsAwayFromInlineLabels } from "./pushAnchoredNetLabelsAwayFromInlineLabels"
 
 export const DEFAULT_INLINE_NET_LABEL_HEIGHT = 0.18
@@ -27,6 +27,9 @@ export const DEFAULT_INLINE_NET_LABEL_HEIGHT = 0.18
  */
 export const INLINE_NET_LABEL_TRACE_MARGIN = 0.05
 
+/** Clearance between a generated terminal stub and an unrelated trace. */
+export const INLINE_NET_LABEL_STUB_TRACE_CLEARANCE = 0.05
+
 /**
  * Largest perpendicular deviation a route may have and still be labeled as one
  * span. A route that is straight except for elbow jogs up to this size reads
@@ -248,7 +251,7 @@ export class InlineNetLabelSolver extends BaseSolver {
       inputPin && inputChip
         ? (inputPin._facingDirection ?? getPinDirection(inputPin, inputChip))
         : anchoredPlacement.orientation
-    const end: Point =
+    const intendedEnd: Point =
       direction === "x+"
         ? { x: start.x + stubLength, y: start.y }
         : direction === "x-"
@@ -257,6 +260,15 @@ export class InlineNetLabelSolver extends BaseSolver {
             ? { x: start.x, y: start.y + stubLength }
             : { x: start.x, y: start.y - stubLength }
 
+    const end = getCollisionLimitedTerminalStubEnd({
+      start,
+      intendedEnd,
+      minimumLength: width + 2 * INLINE_NET_LABEL_TRACE_MARGIN,
+      traces: this.traces,
+      ownGlobalConnNetId: anchoredPlacement.globalConnNetId,
+    })
+    if (!end) return null
+
     const axis: InlineNetLabelPlacement["axis"] =
       direction === "x+" || direction === "x-" ? "x" : "y"
     const side: InlineNetLabelPlacement["side"] = axis === "x" ? "y+" : "x-"
@@ -777,3 +789,90 @@ const doesPathIntersectBounds = (path: Point[], bounds: Bounds): boolean => {
   }
   return false
 }
+
+const GEOMETRY_EPSILON = 1e-6
+
+/**
+ * Shortens an axis-aligned terminal stub before the first unrelated trace.
+ * Coordinates are schematic-world millimetres with +x right and +y up.
+ */
+const getCollisionLimitedTerminalStubEnd = ({
+  start,
+  intendedEnd,
+  minimumLength,
+  traces,
+  ownGlobalConnNetId,
+}: {
+  start: Point
+  intendedEnd: Point
+  minimumLength: number
+  traces: SolvedTracePath[]
+  ownGlobalConnNetId: string
+}): Point | null => {
+  const isHorizontal =
+    Math.abs(intendedEnd.x - start.x) >= Math.abs(intendedEnd.y - start.y)
+  const alongAxis = isHorizontal ? "x" : "y"
+  const acrossAxis = isHorizontal ? "y" : "x"
+  const direction = Math.sign(intendedEnd[alongAxis] - start[alongAxis]) || 1
+  const intendedLength = Math.abs(intendedEnd[alongAxis] - start[alongAxis])
+  let availableLength = intendedLength
+
+  for (const trace of traces) {
+    if (trace.globalConnNetId === ownGlobalConnNetId) continue
+
+    for (
+      let segmentIndex = 0;
+      segmentIndex < trace.tracePath.length - 1;
+      segmentIndex++
+    ) {
+      const segmentStart = trace.tracePath[segmentIndex]!
+      const segmentEnd = trace.tracePath[segmentIndex + 1]!
+      const startAlong =
+        (segmentStart[alongAxis] - start[alongAxis]) * direction
+      const endAlong = (segmentEnd[alongAxis] - start[alongAxis]) * direction
+      const startAcross = segmentStart[acrossAxis] - start[acrossAxis]
+      const endAcross = segmentEnd[acrossAxis] - start[acrossAxis]
+      const minAlong = Math.min(startAlong, endAlong)
+      const maxAlong = Math.max(startAlong, endAlong)
+      const minAcross = Math.min(startAcross, endAcross)
+      const maxAcross = Math.max(startAcross, endAcross)
+
+      let collisionDistance: number | undefined
+      const isCollinear =
+        Math.abs(startAcross) <= GEOMETRY_EPSILON &&
+        Math.abs(endAcross) <= GEOMETRY_EPSILON
+      if (
+        isCollinear &&
+        maxAlong >= -GEOMETRY_EPSILON &&
+        minAlong <= intendedLength + GEOMETRY_EPSILON
+      ) {
+        collisionDistance = Math.max(0, minAlong)
+      } else {
+        const crossesStubAxis =
+          minAcross <= GEOMETRY_EPSILON && maxAcross >= -GEOMETRY_EPSILON
+        const perpendicularAlong = (startAlong + endAlong) / 2
+        if (
+          crossesStubAxis &&
+          Math.abs(startAlong - endAlong) <= GEOMETRY_EPSILON &&
+          perpendicularAlong >= -GEOMETRY_EPSILON &&
+          perpendicularAlong <= intendedLength + GEOMETRY_EPSILON
+        ) {
+          collisionDistance = Math.max(0, perpendicularAlong)
+        }
+      }
+
+      if (collisionDistance !== undefined) {
+        availableLength = Math.min(
+          availableLength,
+          collisionDistance - INLINE_NET_LABEL_STUB_TRACE_CLEARANCE,
+        )
+      }
+    }
+  }
+
+  if (availableLength + GEOMETRY_EPSILON < minimumLength) return null
+
+  return isHorizontal
+    ? { x: start.x + direction * availableLength, y: start.y }
+    : { x: start.x, y: start.y + direction * availableLength }
+}

package/lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts

@@ -35,6 +35,7 @@ import { UnroutedTraceRecoverySolver } from "../UnroutedTraceRecoverySolver/Unro
 import { SameNetJunctionAlignmentSolver } from "../SameNetJunctionAlignmentSolver/SameNetJunctionAlignmentSolver"
 import { TraceElbowTransitionSimplificationSolver } from "../TraceElbowTransitionSimplificationSolver/TraceElbowTransitionSimplificationSolver"
 import { InlineNetLabelSolver } from "../InlineNetLabelSolver/InlineNetLabelSolver"
+import { findPerpendicularPathCrossings } from "../TraceCleanupSolver/sub-solver/findIntersectionsWithObstacles"
 
 type PipelineStep<T extends new (...args: any[]) => BaseSolver> = {
   solverName: string
@@ -259,6 +260,61 @@ export class SchematicTracePipelineSolver extends BaseSolver {
       const prevSolverOutput =
         instance.traceElbowTransitionSimplificationSolver!.getOutput()
       const traces = prevSolverOutput.traces
+      const overlapShiftSolver = instance.traceOverlapShiftSolver!
+      const inlineLabelNetIds = new Set(
+        [
+          ...instance.inputProblem.directConnections,
+          ...instance.inputProblem.netConnections,
+        ]
+          .filter((connection) => connection.allowInlineNetLabel)
+          .map((connection) => connection.netId),
+      )
+      // An overlap shift can separate collinear inline-label traces by creating
+      // a new perpendicular crossing. Limit the extra untangle work to those
+      // newly introduced crossings so established routes remain stable.
+      const traceIdsInNewCrossingsAfterOverlapShift = new Set<string>()
+      for (
+        let traceIndex = 0;
+        traceIndex < overlapShiftSolver.inputTracePaths.length;
+        traceIndex++
+      ) {
+        const inputTrace = overlapShiftSolver.inputTracePaths[traceIndex]!
+        const shiftedTrace =
+          overlapShiftSolver.correctedTraceMap[inputTrace.mspPairId]!
+        for (
+          let otherTraceIndex = traceIndex + 1;
+          otherTraceIndex < overlapShiftSolver.inputTracePaths.length;
+          otherTraceIndex++
+        ) {
+          const otherInputTrace =
+            overlapShiftSolver.inputTracePaths[otherTraceIndex]!
+          if (inputTrace.globalConnNetId === otherInputTrace.globalConnNetId) {
+            continue
+          }
+          if (
+            !inlineLabelNetIds.has(inputTrace.userNetId ?? "") &&
+            !inlineLabelNetIds.has(otherInputTrace.userNetId ?? "")
+          ) {
+            continue
+          }
+          const otherShiftedTrace =
+            overlapShiftSolver.correctedTraceMap[otherInputTrace.mspPairId]!
+          const crossingCountBeforeShift = findPerpendicularPathCrossings(
+            inputTrace.tracePath,
+            otherInputTrace.tracePath,
+          ).length
+          const crossingCountAfterShift = findPerpendicularPathCrossings(
+            shiftedTrace.tracePath,
+            otherShiftedTrace.tracePath,
+          ).length
+          if (crossingCountAfterShift > crossingCountBeforeShift) {
+            traceIdsInNewCrossingsAfterOverlapShift.add(inputTrace.mspPairId)
+            traceIdsInNewCrossingsAfterOverlapShift.add(
+              otherInputTrace.mspPairId,
+            )
+          }
+        }
+      }
 
       const labelMergingOutput =
         instance.traceLabelOverlapAvoidanceSolver!.labelMergingSolver!.getOutput()
@@ -270,6 +326,7 @@ export class SchematicTracePipelineSolver extends BaseSolver {
           allLabelPlacements: labelMergingOutput.netLabelPlacements,
           mergedLabelNetIdMap: labelMergingOutput.mergedLabelNetIdMap,
           paddingBuffer: 0.1,
+          eligibleTraceIds: traceIdsInNewCrossingsAfterOverlapShift,
         },
       ]
     }),

package/lib/solvers/TraceCleanupSolver/sub-solver/UntangleTraceSubsolver.ts

@@ -12,6 +12,7 @@ import {
 } from "./findIntersectionsWithObstacles"
 import {
   generateLShapeRerouteCandidates,
+  generatePerimeterCornerTraceDetours,
   generatePerpendicularTraceDetours,
 } from "./generateLShapeRerouteCandidates"
 import { isPathColliding, type CollisionInfo } from "./isPathColliding"
@@ -53,6 +54,7 @@ export interface UntangleTraceSubsolverInput {
   allLabelPlacements: NetLabelPlacement[]
   mergedLabelNetIdMap: Record<string, Set<string>>
   paddingBuffer: number
+  eligibleTraceIds?: ReadonlySet<string>
 }
 
 /**
@@ -127,7 +129,7 @@ export class UntangleTraceSubsolver extends BaseSolver {
 
     if (this.processingCrossings) {
       // The L-shape pass below only reacts when both arms intersect obstacles.
-      // Resolve strict crossings on merged-label bundles before entering it.
+      // Resolve eligible strict cross-net crossings before entering it.
       const crossing = this._findCrossing()
       if (crossing) {
         if (!this._resolveCrossing(crossing)) {
@@ -207,8 +209,12 @@ export class UntangleTraceSubsolver extends BaseSolver {
         const otherTrace = traces[secondIndex]!
         if (trace.globalConnNetId === otherTrace.globalConnNetId) continue
         const isInitialBundleCrossing = this._isTraceBundle(trace, otherTrace)
+        const isEligibleInitialCrossing =
+          this.input.eligibleTraceIds?.has(trace.mspPairId) === true ||
+          this.input.eligibleTraceIds?.has(otherTrace.mspPairId) === true
         if (
           !isInitialBundleCrossing &&
+          !isEligibleInitialCrossing &&
           !this.reroutedTraceIds.has(trace.mspPairId) &&
           !this.reroutedTraceIds.has(otherTrace.mspPairId)
         ) {
@@ -259,6 +265,16 @@ export class UntangleTraceSubsolver extends BaseSolver {
         chipBounds,
         clearance: this.input.paddingBuffer,
       }),
+      ...generatePerimeterCornerTraceDetours({
+        trace: crossing.trace,
+        chipBounds,
+        clearance: this.input.paddingBuffer,
+      }),
+      ...generatePerimeterCornerTraceDetours({
+        trace: crossing.otherTrace,
+        chipBounds,
+        clearance: this.input.paddingBuffer,
+      }),
     ]
     const chipObstacles = getObstacleRects(this.input.inputProblem).filter(
       (obstacle) => obstacle.kind === "chip",

package/lib/solvers/TraceCleanupSolver/sub-solver/generateLShapeRerouteCandidates.ts

@@ -122,6 +122,58 @@ export interface TraceDetourCandidate {
   path: Point[]
 }
 
+export const generatePerimeterCornerTraceDetours = ({
+  trace,
+  chipBounds,
+  clearance,
+}: Omit<
+  PerpendicularTraceDetourInput,
+  "segmentIndex" | "obstacleStart" | "obstacleEnd"
+>): TraceDetourCandidate[] => {
+  if (trace.tracePath.length < 4 || chipBounds.length === 0) return []
+
+  const start = trace.tracePath[0]!
+  const firstEscape = trace.tracePath[1]!
+  const lastEscape = trace.tracePath.at(-2)!
+  const end = trace.tracePath.at(-1)!
+  const minX = Math.min(...chipBounds.map((bounds) => bounds.minX)) - clearance
+  const maxX = Math.max(...chipBounds.map((bounds) => bounds.maxX)) + clearance
+  const minY = Math.min(...chipBounds.map((bounds) => bounds.minY)) - clearance
+  const maxY = Math.max(...chipBounds.map((bounds) => bounds.maxY)) + clearance
+  const candidates: TraceDetourCandidate[] = []
+
+  for (const channelX of [minX, maxX]) {
+    for (const channelY of [minY, maxY]) {
+      candidates.push({
+        traceId: trace.mspPairId,
+        path: simplifyPath([
+          start,
+          firstEscape,
+          { x: firstEscape.x, y: channelY },
+          { x: channelX, y: channelY },
+          { x: channelX, y: lastEscape.y },
+          lastEscape,
+          end,
+        ]),
+      })
+      candidates.push({
+        traceId: trace.mspPairId,
+        path: simplifyPath([
+          start,
+          firstEscape,
+          { x: channelX, y: firstEscape.y },
+          { x: channelX, y: channelY },
+          { x: lastEscape.x, y: channelY },
+          lastEscape,
+          end,
+        ]),
+      })
+    }
+  }
+
+  return candidates
+}
+
 export const generatePerpendicularTraceDetours = ({
   trace,
   segmentIndex,

package/package.json

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

package/site/examples/example51.page.tsx

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