@tscircuit/schematic-trace-solver 0.0.200 → 0.0.202

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

@@ -12776,7 +12776,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 +12791,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 +12993,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;
     }
@@ -15159,6 +15202,38 @@ var placeGroundRailLabelsAtOuterEnd = ({
   return output;
 };
 
+// lib/solvers/SameNetJunctionAlignmentSolver/shortenSameSideRailToLabelAnchor.ts
+var MAX_LOCAL_RAIL_SHIFT = 0.5;
+var MIN_ESCAPE_LENGTH = 1;
+var shortenSameSideRailToLabelAnchor = ({
+  traces,
+  netLabelPlacements
+}) => traces.map((trace) => {
+  const path = trace.tracePath;
+  const firstPin = path[0];
+  const secondPin = path.at(-1);
+  if (!firstPin || !secondPin || !nearlyEqual(firstPin.x, secondPin.x)) {
+    return trace;
+  }
+  const railIndex = path.findIndex(
+    (point, index) => index > 0 && index < path.length - 2 && isHorizontal2(path[index - 1], point) && isVertical2(point, path[index + 1]) && isHorizontal2(path[index + 1], path[index + 2])
+  );
+  if (railIndex < 0) return trace;
+  const firstRail = path[railIndex];
+  const secondRail = path[railIndex + 1];
+  const escapeLength = Math.abs(firstRail.x - firstPin.x);
+  const label = netLabelPlacements.find(
+    ({ anchorPoint, orientation, mspConnectionPairIds }) => mspConnectionPairIds.includes(trace.mspPairId) && (orientation === "y-" && anchorPoint.y < Math.min(firstPin.y, secondPin.y) || orientation === "y+" && anchorPoint.y > Math.max(firstPin.y, secondPin.y)) && anchorPoint.x >= Math.min(firstPin.x, firstRail.x) && anchorPoint.x <= Math.max(firstPin.x, firstRail.x) && Math.abs(anchorPoint.x - firstPin.x) < escapeLength && Math.abs(anchorPoint.x - firstRail.x) <= MAX_LOCAL_RAIL_SHIFT && escapeLength >= MIN_ESCAPE_LENGTH
+  );
+  if (!label) return trace;
+  return {
+    ...trace,
+    tracePath: path.map(
+      (point, index) => index === railIndex || index === railIndex + 1 ? { ...point, x: label.anchorPoint.x } : point
+    )
+  };
+});
+
 // lib/solvers/SameNetJunctionAlignmentSolver/SameNetJunctionAlignmentSolver.ts
 var SameNetJunctionAlignmentSolver = class extends BaseSolver {
   input;
@@ -15172,10 +15247,13 @@ var SameNetJunctionAlignmentSolver = class extends BaseSolver {
   }
   _step() {
     const alignment = alignSameNetJunctions(this.input);
-    this.outputTraces = alignment.traces;
+    this.outputTraces = shortenSameSideRailToLabelAnchor({
+      traces: alignment.traces,
+      netLabelPlacements: alignment.netLabelPlacements
+    });
     this.outputNetLabelPlacements = placeGroundRailLabelsAtOuterEnd({
       inputProblem: this.input.inputProblem,
-      traces: alignment.traces,
+      traces: this.outputTraces,
       netLabelPlacements: alignment.netLabelPlacements
     });
     this.stats.alignedJunctionCount = alignment.alignedJunctionCount;
@@ -15593,6 +15671,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)
@@ -15604,13 +15687,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]);
@@ -17524,7 +17620,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({
@@ -18975,7 +19072,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/SameNetJunctionAlignmentSolver/SameNetJunctionAlignmentSolver.ts

@@ -8,6 +8,7 @@ import type { InputProblem } from "lib/types/InputProblem"
 import { getColorFromString } from "lib/utils/getColorFromString"
 import { alignSameNetJunctions } from "./alignSameNetJunctions"
 import { placeGroundRailLabelsAtOuterEnd } from "./placeGroundRailLabelsAtOuterEnd"
+import { shortenSameSideRailToLabelAnchor } from "./shortenSameSideRailToLabelAnchor"
 
 interface SameNetJunctionAlignmentSolverInput {
   inputProblem: InputProblem
@@ -31,10 +32,13 @@ export class SameNetJunctionAlignmentSolver extends BaseSolver {
 
   override _step() {
     const alignment = alignSameNetJunctions(this.input)
-    this.outputTraces = alignment.traces
+    this.outputTraces = shortenSameSideRailToLabelAnchor({
+      traces: alignment.traces,
+      netLabelPlacements: alignment.netLabelPlacements,
+    })
     this.outputNetLabelPlacements = placeGroundRailLabelsAtOuterEnd({
       inputProblem: this.input.inputProblem,
-      traces: alignment.traces,
+      traces: this.outputTraces,
       netLabelPlacements: alignment.netLabelPlacements,
     })
     this.stats.alignedJunctionCount = alignment.alignedJunctionCount

package/lib/solvers/SameNetJunctionAlignmentSolver/shortenSameSideRailToLabelAnchor.ts

@@ -0,0 +1,62 @@
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import {
+  isHorizontal,
+  isVertical,
+  nearlyEqual,
+} from "lib/solvers/TraceCleanupSolver/sameNetRailAlignment/geometry"
+
+const MAX_LOCAL_RAIL_SHIFT = 0.5
+const MIN_ESCAPE_LENGTH = 1
+
+export const shortenSameSideRailToLabelAnchor = ({
+  traces,
+  netLabelPlacements,
+}: {
+  traces: SolvedTracePath[]
+  netLabelPlacements: NetLabelPlacement[]
+}) =>
+  traces.map((trace) => {
+    const path = trace.tracePath
+    const firstPin = path[0]
+    const secondPin = path.at(-1)
+    if (!firstPin || !secondPin || !nearlyEqual(firstPin.x, secondPin.x)) {
+      return trace
+    }
+
+    const railIndex = path.findIndex(
+      (point, index) =>
+        index > 0 &&
+        index < path.length - 2 &&
+        isHorizontal(path[index - 1]!, point) &&
+        isVertical(point, path[index + 1]!) &&
+        isHorizontal(path[index + 1]!, path[index + 2]!),
+    )
+    if (railIndex < 0) return trace
+    const firstRail = path[railIndex]!
+    const secondRail = path[railIndex + 1]!
+    const escapeLength = Math.abs(firstRail.x - firstPin.x)
+    const label = netLabelPlacements.find(
+      ({ anchorPoint, orientation, mspConnectionPairIds }) =>
+        mspConnectionPairIds.includes(trace.mspPairId) &&
+        ((orientation === "y-" &&
+          anchorPoint.y < Math.min(firstPin.y, secondPin.y)) ||
+          (orientation === "y+" &&
+            anchorPoint.y > Math.max(firstPin.y, secondPin.y))) &&
+        anchorPoint.x >= Math.min(firstPin.x, firstRail.x) &&
+        anchorPoint.x <= Math.max(firstPin.x, firstRail.x) &&
+        Math.abs(anchorPoint.x - firstPin.x) < escapeLength &&
+        Math.abs(anchorPoint.x - firstRail.x) <= MAX_LOCAL_RAIL_SHIFT &&
+        escapeLength >= MIN_ESCAPE_LENGTH,
+    )
+    if (!label) return trace
+
+    return {
+      ...trace,
+      tracePath: path.map((point, index) =>
+        index === railIndex || index === railIndex + 1
+          ? { ...point, x: label.anchorPoint.x }
+          : point,
+      ),
+    }
+  })

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

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