@tscircuit/schematic-trace-solver 0.0.201 → 0.0.203

package/dist/index.d.ts

@@ -1149,6 +1149,8 @@ type Candidate = {
     status: CandidateStatus | null;
 };
 interface NetLabelNetLabelCollisionSolverParams {
+    /** Move temporary port-only inline labels before moving their neighbors. */
+    preserveNonInlineLabelsAgainstInlineEligibleCollisions?: boolean;
     /** Use the final horizontal tag envelope after inline conversion. */
     useRenderedLabelBounds?: boolean;
     /** Already placed labels that are obstacles, but must not be moved. */
@@ -1181,6 +1183,10 @@ declare class NetLabelNetLabelCollisionSolver extends BaseSolver {
     };
     private labelBounds;
     private collisionKey;
+    private isSingleTerminalInlineEligible;
+    private hasSatisfiedSingleOrientation;
+    private isAlignedWithHostTrace;
+    private isProtectedAgainstTemporaryInlineCollision;
     private findNextCollidingPair;
     private netLabelWidthOf;
     private netLabelHeightOf;

package/dist/index.js

@@ -7810,6 +7810,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 +7932,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
@@ -12776,7 +12811,8 @@ var NetLabelNetLabelCollisionSolver = class extends BaseSolver {
       traces: this.traces,
       netLabelPlacements: this.netLabelPlacements,
       fixedNetLabelPlacements: this.params.fixedNetLabelPlacements,
-      useRenderedLabelBounds: this.params.useRenderedLabelBounds
+      useRenderedLabelBounds: this.params.useRenderedLabelBounds,
+      preserveNonInlineLabelsAgainstInlineEligibleCollisions: this.params.preserveNonInlineLabelsAgainstInlineEligibleCollisions
     };
   }
   getOutput() {
@@ -12790,6 +12826,36 @@ var NetLabelNetLabelCollisionSolver = class extends BaseSolver {
   collisionKey(a, b) {
     return [a.globalConnNetId, b.globalConnNetId].sort().join("::");
   }
+  isSingleTerminalInlineEligible(label) {
+    if (!label.netId) return false;
+    return [
+      ...this.inputProblem.netConnections,
+      ...this.inputProblem.directConnections
+    ].some(
+      (connection) => connection.allowInlineNetLabel && connection.pinIds.length === 1 && connection.netId === label.netId && label.pinIds.every((pinId) => connection.pinIds.includes(pinId))
+    );
+  }
+  hasSatisfiedSingleOrientation(label) {
+    if (!label.netId) return false;
+    const orientations = this.inputProblem.availableNetLabelOrientations[label.netId];
+    return orientations?.length === 1 && orientations[0] === label.orientation;
+  }
+  isAlignedWithHostTrace(label) {
+    const orientationAxis = label.orientation.startsWith("x") ? "x" : "y";
+    return label.mspConnectionPairIds.some((mspPairId) => {
+      const trace = this.traceMap[mspPairId];
+      return trace?.tracePath.slice(1).some((end, index) => {
+        const start = trace.tracePath[index];
+        if (!tracePathContainsPoint([start, end], label.anchorPoint))
+          return false;
+        const segmentAxis = Math.abs(start.x - end.x) < SEGMENT_PARALLEL_EPS ? "y" : "x";
+        return segmentAxis === orientationAxis;
+      });
+    });
+  }
+  isProtectedAgainstTemporaryInlineCollision(label) {
+    return !this.isSingleTerminalInlineEligible(label) && this.hasSatisfiedSingleOrientation(label) && this.isAlignedWithHostTrace(label);
+  }
   findNextCollidingPair() {
     const labels = [
       ...this.outputNetLabelPlacements,
@@ -12962,6 +13028,18 @@ var NetLabelNetLabelCollisionSolver = class extends BaseSolver {
       this.labelsToTry = [pair[1], pair[0]].filter(
         (label) => !(this.params.fixedNetLabelPlacements ?? []).includes(label)
       );
+      if (this.params.preserveNonInlineLabelsAgainstInlineEligibleCollisions && pair.some((label) => this.isSingleTerminalInlineEligible(label)) && pair.some(
+        (label) => this.isProtectedAgainstTemporaryInlineCollision(label)
+      )) {
+        this.labelsToTry = this.labelsToTry.filter(
+          (label) => this.isSingleTerminalInlineEligible(label) || !this.isProtectedAgainstTemporaryInlineCollision(label)
+        );
+      }
+      if (this.labelsToTry.length === 0) {
+        this.skippedCollisionKeys.add(this.collisionKey(pair[0], pair[1]));
+        this.clearActiveSearch();
+        return;
+      }
       this.beginSearchForLabel(this.labelsToTry.shift());
       return;
     }
@@ -15628,6 +15706,11 @@ function* getLocalTraceLabelShifts(inputProblem, output, pendingInlinePlacements
     minY: label.center.y - label.height / 2,
     maxY: label.center.y + label.height / 2
   }));
+  const pendingReplacementBounds = output.netLabelPlacements.filter(
+    (label) => pendingInlinePlacements.some(
+      (placement) => placement.globalConnNetId === label.globalConnNetId && placement.pinIds.length === label.pinIds.length && placement.pinIds.every((pinId) => label.pinIds.includes(pinId))
+    )
+  ).map(getAnchoredNetLabelRenderedBounds);
   const pinPositions = [
     ...inputProblem.chips.flatMap((chip) => chip.pins),
     ...output.traces.flatMap((trace) => trace.pins)
@@ -15639,13 +15722,26 @@ function* getLocalTraceLabelShifts(inputProblem, output, pendingInlinePlacements
       const axis = Math.abs(a.x - b.x) < EPS16 ? "x" : "y";
       const along = axis === "x" ? "y" : "x";
       if (Math.abs(a[axis] - b[axis]) > EPS16 || same(a, b)) continue;
-      const blocking = [
+      const candidateObstacles = [
         ...output.netLabelPlacements.filter((label) => label.globalConnNetId !== trace.globalConnNetId).map(getAnchoredNetLabelRenderedBounds),
         ...inlineBounds,
         ...terminalBounds.filter(
           ({ label }) => !trace.pinIds.some((pinId) => label.pinIds.includes(pinId))
         ).map(({ bounds }) => bounds)
-      ].filter((bounds) => segmentIntersectsRect(a, b, bounds));
+      ];
+      const attachedLabelBounds = output.netLabelPlacements.filter(
+        (label) => label.globalConnNetId === trace.globalConnNetId && label.netId != null && inputProblem.availableNetLabelOrientations[label.netId]?.length === 1 && inputProblem.availableNetLabelOrientations[label.netId]?.[0] === label.orientation && (axis === "x" ? label.orientation === "y+" || label.orientation === "y-" : label.orientation === "x+" || label.orientation === "x-") && tracePathContainsPoint([a, b], label.anchorPoint)
+      ).map(getAnchoredNetLabelRenderedBounds);
+      const blocking = [
+        ...candidateObstacles.filter(
+          (bounds) => segmentIntersectsRect(a, b, bounds)
+        ),
+        ...pendingReplacementBounds.filter(
+          (bounds) => attachedLabelBounds.some(
+            (labelBounds) => boundsOverlap(labelBounds, bounds)
+          )
+        )
+      ];
       if (!blocking.length) continue;
       let low = Math.min(a[along], b[along]);
       let high = Math.max(a[along], b[along]);
@@ -17559,7 +17655,8 @@ var InlineNetLabelSolver = class _InlineNetLabelSolver extends BaseSolver {
         netLabelPlacements: retainedNetLabelPlacements,
         fixedNetLabelPlacements: fixedLabels,
         netLabelConnectorTraceIds: this.netLabelConnectorTraceIds,
-        useRenderedLabelBounds: activeInlinePlacements.length > 0
+        useRenderedLabelBounds: activeInlinePlacements.length > 0,
+        preserveNonInlineLabelsAgainstInlineEligibleCollisions: true
       });
       if (activeInlinePlacements.length > 0) labelCollisionSolver.solve();
       const pushed = pushAnchoredNetLabelsAwayFromInlineLabels({
@@ -19010,7 +19107,8 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
           {
             inputProblem: instance.inputProblem,
             traces: simplificationOutput.traces,
-            netLabelPlacements: simplificationOutput.netLabelPlacements
+            netLabelPlacements: simplificationOutput.netLabelPlacements,
+            preserveNonInlineLabelsAgainstInlineEligibleCollisions: true
           }
         ];
       }

package/lib/solvers/InlineNetLabelSolver/InlineNetLabelSolver.ts

@@ -1195,6 +1195,7 @@ export class InlineNetLabelSolver extends BaseSolver {
         fixedNetLabelPlacements: fixedLabels,
         netLabelConnectorTraceIds: this.netLabelConnectorTraceIds,
         useRenderedLabelBounds: activeInlinePlacements.length > 0,
+        preserveNonInlineLabelsAgainstInlineEligibleCollisions: true,
       })
       if (activeInlinePlacements.length > 0) labelCollisionSolver.solve()
       const pushed = pushAnchoredNetLabelsAwayFromInlineLabels({

package/lib/solvers/InlineNetLabelSolver/getLocalTraceLabelShifts.ts

@@ -75,6 +75,16 @@ export function* getLocalTraceLabelShifts(
     minY: label.center.y - label.height / 2,
     maxY: label.center.y + label.height / 2,
   }))
+  const pendingReplacementBounds = output.netLabelPlacements
+    .filter((label) =>
+      pendingInlinePlacements.some(
+        (placement) =>
+          placement.globalConnNetId === label.globalConnNetId &&
+          placement.pinIds.length === label.pinIds.length &&
+          placement.pinIds.every((pinId) => label.pinIds.includes(pinId)),
+      ),
+    )
+    .map(getAnchoredNetLabelRenderedBounds)
   const pinPositions = [
     ...inputProblem.chips.flatMap((chip) => chip.pins),
     ...output.traces.flatMap((trace) => trace.pins),
@@ -87,7 +97,7 @@ export function* getLocalTraceLabelShifts(
       const axis = Math.abs(a.x - b.x) < EPS ? "x" : "y"
       const along = axis === "x" ? "y" : "x"
       if (Math.abs(a[axis] - b[axis]) > EPS || same(a, b)) continue
-      const blocking = [
+      const candidateObstacles = [
         ...output.netLabelPlacements
           .filter((label) => label.globalConnNetId !== trace.globalConnNetId)
           .map(getAnchoredNetLabelRenderedBounds),
@@ -98,7 +108,32 @@ export function* getLocalTraceLabelShifts(
               !trace.pinIds.some((pinId) => label.pinIds.includes(pinId)),
           )
           .map(({ bounds }) => bounds),
-      ].filter((bounds) => segmentIntersectsRect(a, b, bounds))
+      ]
+      const attachedLabelBounds = output.netLabelPlacements
+        .filter(
+          (label) =>
+            label.globalConnNetId === trace.globalConnNetId &&
+            label.netId != null &&
+            inputProblem.availableNetLabelOrientations[label.netId]?.length ===
+              1 &&
+            inputProblem.availableNetLabelOrientations[label.netId]?.[0] ===
+              label.orientation &&
+            (axis === "x"
+              ? label.orientation === "y+" || label.orientation === "y-"
+              : label.orientation === "x+" || label.orientation === "x-") &&
+            tracePathContainsPoint([a, b], label.anchorPoint),
+        )
+        .map(getAnchoredNetLabelRenderedBounds)
+      const blocking = [
+        ...candidateObstacles.filter((bounds) =>
+          segmentIntersectsRect(a, b, bounds),
+        ),
+        ...pendingReplacementBounds.filter((bounds) =>
+          attachedLabelBounds.some((labelBounds) =>
+            boundsOverlap(labelBounds, bounds),
+          ),
+        ),
+      ]
       if (!blocking.length) continue
       // Cleanup can split one rail across several trace records, including a
       // branch that starts at a junction instead of at its pin. Shift the

package/lib/solvers/NetLabelNetLabelCollisionSolver/NetLabelNetLabelCollisionSolver.ts

@@ -93,6 +93,8 @@ function sampleAnchorsAlongSegment(
 }
 
 export interface NetLabelNetLabelCollisionSolverParams {
+  /** Move temporary port-only inline labels before moving their neighbors. */
+  preserveNonInlineLabelsAgainstInlineEligibleCollisions?: boolean
   /** Use the final horizontal tag envelope after inline conversion. */
   useRenderedLabelBounds?: boolean
   /** Already placed labels that are obstacles, but must not be moved. */
@@ -148,6 +150,8 @@ export class NetLabelNetLabelCollisionSolver extends BaseSolver {
       netLabelPlacements: this.netLabelPlacements,
       fixedNetLabelPlacements: this.params.fixedNetLabelPlacements,
       useRenderedLabelBounds: this.params.useRenderedLabelBounds,
+      preserveNonInlineLabelsAgainstInlineEligibleCollisions:
+        this.params.preserveNonInlineLabelsAgainstInlineEligibleCollisions,
     }
   }
 
@@ -168,6 +172,50 @@ export class NetLabelNetLabelCollisionSolver extends BaseSolver {
     return [a.globalConnNetId, b.globalConnNetId].sort().join("::")
   }
 
+  private isSingleTerminalInlineEligible(label: NetLabelPlacement) {
+    if (!label.netId) return false
+    return [
+      ...this.inputProblem.netConnections,
+      ...this.inputProblem.directConnections,
+    ].some(
+      (connection) =>
+        connection.allowInlineNetLabel &&
+        connection.pinIds.length === 1 &&
+        connection.netId === label.netId &&
+        label.pinIds.every((pinId) => connection.pinIds.includes(pinId)),
+    )
+  }
+
+  private hasSatisfiedSingleOrientation(label: NetLabelPlacement) {
+    if (!label.netId) return false
+    const orientations =
+      this.inputProblem.availableNetLabelOrientations[label.netId]
+    return orientations?.length === 1 && orientations[0] === label.orientation
+  }
+
+  private isAlignedWithHostTrace(label: NetLabelPlacement) {
+    const orientationAxis = label.orientation.startsWith("x") ? "x" : "y"
+    return label.mspConnectionPairIds.some((mspPairId) => {
+      const trace = this.traceMap[mspPairId]
+      return trace?.tracePath.slice(1).some((end, index) => {
+        const start = trace.tracePath[index]!
+        if (!tracePathContainsPoint([start, end], label.anchorPoint))
+          return false
+        const segmentAxis =
+          Math.abs(start.x - end.x) < SEGMENT_PARALLEL_EPS ? "y" : "x"
+        return segmentAxis === orientationAxis
+      })
+    })
+  }
+
+  private isProtectedAgainstTemporaryInlineCollision(label: NetLabelPlacement) {
+    return (
+      !this.isSingleTerminalInlineEligible(label) &&
+      this.hasSatisfiedSingleOrientation(label) &&
+      this.isAlignedWithHostTrace(label)
+    )
+  }
+
   private findNextCollidingPair():
     | [NetLabelPlacement, NetLabelPlacement]
     | null {
@@ -394,6 +442,24 @@ export class NetLabelNetLabelCollisionSolver extends BaseSolver {
       this.labelsToTry = [pair[1], pair[0]].filter(
         (label) => !(this.params.fixedNetLabelPlacements ?? []).includes(label),
       )
+      if (
+        this.params.preserveNonInlineLabelsAgainstInlineEligibleCollisions &&
+        pair.some((label) => this.isSingleTerminalInlineEligible(label)) &&
+        pair.some((label) =>
+          this.isProtectedAgainstTemporaryInlineCollision(label),
+        )
+      ) {
+        this.labelsToTry = this.labelsToTry.filter(
+          (label) =>
+            this.isSingleTerminalInlineEligible(label) ||
+            !this.isProtectedAgainstTemporaryInlineCollision(label),
+        )
+      }
+      if (this.labelsToTry.length === 0) {
+        this.skippedCollisionKeys.add(this.collisionKey(pair[0], pair[1]))
+        this.clearActiveSearch()
+        return
+      }
       this.beginSearchForLabel(this.labelsToTry.shift()!)
       return
     }

package/lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts

@@ -559,6 +559,7 @@ export class SchematicTracePipelineSolver extends BaseSolver {
             inputProblem: instance.inputProblem,
             traces: simplificationOutput.traces,
             netLabelPlacements: simplificationOutput.netLabelPlacements,
+            preserveNonInlineLabelsAgainstInlineEligibleCollisions: true,
           },
         ]
       },

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/package.json

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