@tscircuit/schematic-trace-solver 0.0.81 → 0.0.82

package/dist/index.d.ts

@@ -695,7 +695,7 @@ type CandidateLabel = {
     height: number;
 };
 type CandidateStatus$2 = "valid" | "chip-collision" | "text-collision" | "trace-collision" | "trace-clearance-violation" | "netlabel-collision";
-type CandidatePhase = "rotate" | "shift" | "lateral-shift";
+type CandidatePhase = "rotate" | "trace-anchor" | "shift" | "lateral-shift";
 type EvaluatedCandidate = CandidateLabel & {
     status: CandidateStatus$2;
     selected: boolean;
@@ -733,6 +733,8 @@ declare class AvailableNetOrientationSolver extends BaseSolver {
     private setCurrentLabel;
     private findCorrectedCandidate;
     private findValidRotatedCandidate;
+    private findValidTraceAnchorCandidate;
+    private getTraceAnchorCandidatePoints;
     private getAvailableOrientations;
     private findValidShiftedCandidate;
     /**
@@ -757,6 +759,7 @@ declare class AvailableNetOrientationSolver extends BaseSolver {
     private getNetLabelWidth;
     private getNetLabelHeight;
     private getCandidateStatus;
+    private isAcceptableTraceAnchorChipCollision;
     private getBoundsStatus;
     private isTraceTooCloseToLabel;
     private getLabelTraceClearanceBounds;

package/dist/index.js

@@ -6246,6 +6246,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     this.addConnectorTrace(label, candidate, labelIndex);
   }
   addConnectorTrace(label, candidate, labelIndex) {
+    if (candidate.phase === "trace-anchor") return;
     const tracePath = this.getCandidateConnectorTrace(label, candidate);
     if (tracePath.length < 2) return;
     const mspPairId = `available-net-orientation-${labelIndex}-${label.netId ?? label.globalConnNetId}`;
@@ -6280,6 +6281,12 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       orientations
     );
     if (rotatedCandidate) return rotatedCandidate;
+    const traceAnchorCandidate = this.findValidTraceAnchorCandidate(
+      label,
+      orientations[0],
+      labelIndex
+    );
+    if (traceAnchorCandidate) return traceAnchorCandidate;
     const shiftedCandidate = this.findValidShiftedCandidate(
       label,
       orientations[0],
@@ -6313,6 +6320,46 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     }
     return null;
   }
+  findValidTraceAnchorCandidate(label, orientation, labelIndex) {
+    const direction = dir(orientation);
+    const candidatePoints = this.getTraceAnchorCandidatePoints(label).sort(
+      (a, b) => {
+        const aAlongDirection = a.x * direction.x + a.y * direction.y;
+        const bAlongDirection = b.x * direction.x + b.y * direction.y;
+        return bAlongDirection - aAlongDirection;
+      }
+    );
+    for (const anchorPoint of candidatePoints) {
+      const candidate = this.createCandidate(label, anchorPoint, orientation);
+      const result = this.evaluateCandidate(
+        candidate,
+        label,
+        labelIndex,
+        "trace-anchor"
+      );
+      this.currentCandidateResults.push(result);
+      if (result.status === "valid") {
+        result.selected = true;
+        return result;
+      }
+    }
+    return null;
+  }
+  getTraceAnchorCandidatePoints(label) {
+    const seen = /* @__PURE__ */ new Set();
+    const points = [];
+    for (const traceId of label.mspConnectionPairIds ?? []) {
+      const trace = this.traceMap[traceId];
+      if (!trace) continue;
+      for (const point of trace.tracePath) {
+        const key = `${point.x.toFixed(9)},${point.y.toFixed(9)}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        points.push(point);
+      }
+    }
+    return points;
+  }
   getAvailableOrientations(label) {
     const effectiveNetId = label.netId ?? label.globalConnNetId;
     return this.inputProblem.availableNetLabelOrientations[effectiveNetId] ?? [];
@@ -6581,16 +6628,28 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
   }
   getCandidateStatus(params) {
     const { candidate, label, labelIndex, phase } = params;
+    const bounds = getRectBounds(
+      candidate.center,
+      candidate.width,
+      candidate.height
+    );
     const boundsStatus = this.getBoundsStatus({
-      bounds: getRectBounds(
-        candidate.center,
-        candidate.width,
-        candidate.height
-      ),
+      bounds,
       labelIndex,
       label
     });
-    if (boundsStatus !== "valid") return boundsStatus;
+    if (boundsStatus !== "valid") {
+      if (phase !== "trace-anchor" || boundsStatus !== "chip-collision" || !this.isAcceptableTraceAnchorChipCollision(candidate, label, bounds)) {
+        return boundsStatus;
+      }
+      const nonChipBoundsStatus = this.getBoundsStatus({
+        bounds,
+        labelIndex,
+        label,
+        ignoreChipCollisions: true
+      });
+      if (nonChipBoundsStatus !== "valid") return nonChipBoundsStatus;
+    }
     const connectorTrace = this.getCandidateConnectorTrace(label, {
       anchorPoint: candidate.anchorPoint,
       orientation: candidate.orientation,
@@ -6613,17 +6672,35 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     }
     return "valid";
   }
+  isAcceptableTraceAnchorChipCollision(candidate, label, bounds) {
+    const collidingChips = this.chipObstacleSpatialIndex.getChipsInBounds(bounds);
+    if (collidingChips.length === 0) return false;
+    const labelChipIds = new Set(
+      label.pinIds.map((pinId) => this.pinMap[pinId]?.chipId).filter((chipId) => Boolean(chipId))
+    );
+    return collidingChips.every((chip) => {
+      if (!labelChipIds.has(chip.chipId)) return false;
+      const { anchorPoint, orientation } = candidate;
+      const chipBounds = chip.bounds;
+      if (isYOrientation(orientation)) {
+        return anchorPoint.x < chipBounds.minX - EPS8 || anchorPoint.x > chipBounds.maxX + EPS8;
+      }
+      return anchorPoint.y < chipBounds.minY - EPS8 || anchorPoint.y > chipBounds.maxY + EPS8;
+    });
+  }
   getBoundsStatus(candidateBoundsCheck) {
-    const { bounds, labelIndex, label } = candidateBoundsCheck;
-    if (this.chipObstacleSpatialIndex.getChipsInBounds(bounds).length > 0) {
-      return "chip-collision";
+    const { bounds, labelIndex, label, ignoreChipCollisions } = candidateBoundsCheck;
+    if (!ignoreChipCollisions) {
+      if (this.chipObstacleSpatialIndex.getChipsInBounds(bounds).length > 0) {
+        return "chip-collision";
+      }
+      if (this.sharesChipBoundary(bounds)) {
+        return "chip-collision";
+      }
     }
     if (rectIntersectsAnyTextBox(bounds, this.inputProblem)) {
       return "text-collision";
     }
-    if (this.sharesChipBoundary(bounds)) {
-      return "chip-collision";
-    }
     if (traceCrossesBoundsInterior(bounds, this.traceMap)) {
       return "trace-collision";
     }

package/lib/solvers/AvailableNetOrientationSolver/AvailableNetOrientationSolver.ts

@@ -146,6 +146,8 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     candidate: EvaluatedCandidate,
     labelIndex: number,
   ) {
+    if (candidate.phase === "trace-anchor") return
+
     const tracePath = this.getCandidateConnectorTrace(label, candidate)
     if (tracePath.length < 2) return
 
@@ -187,6 +189,13 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     )
     if (rotatedCandidate) return rotatedCandidate
 
+    const traceAnchorCandidate = this.findValidTraceAnchorCandidate(
+      label,
+      orientations[0]!,
+      labelIndex,
+    )
+    if (traceAnchorCandidate) return traceAnchorCandidate
+
     const shiftedCandidate = this.findValidShiftedCandidate(
       label,
       orientations[0]!,
@@ -228,6 +237,57 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     return null
   }
 
+  private findValidTraceAnchorCandidate(
+    label: NetLabelPlacement,
+    orientation: FacingDirection,
+    labelIndex: number,
+  ) {
+    const direction = dir(orientation)
+    const candidatePoints = this.getTraceAnchorCandidatePoints(label).sort(
+      (a, b) => {
+        const aAlongDirection = a.x * direction.x + a.y * direction.y
+        const bAlongDirection = b.x * direction.x + b.y * direction.y
+        return bAlongDirection - aAlongDirection
+      },
+    )
+
+    for (const anchorPoint of candidatePoints) {
+      const candidate = this.createCandidate(label, anchorPoint, orientation)
+      const result = this.evaluateCandidate(
+        candidate,
+        label,
+        labelIndex,
+        "trace-anchor",
+      )
+      this.currentCandidateResults.push(result)
+
+      if (result.status === "valid") {
+        result.selected = true
+        return result
+      }
+    }
+
+    return null
+  }
+
+  private getTraceAnchorCandidatePoints(label: NetLabelPlacement) {
+    const seen = new Set<string>()
+    const points: Point[] = []
+
+    for (const traceId of label.mspConnectionPairIds ?? []) {
+      const trace = this.traceMap[traceId]
+      if (!trace) continue
+      for (const point of trace.tracePath) {
+        const key = `${point.x.toFixed(9)},${point.y.toFixed(9)}`
+        if (seen.has(key)) continue
+        seen.add(key)
+        points.push(point)
+      }
+    }
+
+    return points
+  }
+
   private getAvailableOrientations(label: NetLabelPlacement) {
     const effectiveNetId = label.netId ?? label.globalConnNetId
     return this.inputProblem.availableNetLabelOrientations[effectiveNetId] ?? []
@@ -608,16 +668,33 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     phase: CandidatePhase
   }) {
     const { candidate, label, labelIndex, phase } = params
+    const bounds = getRectBounds(
+      candidate.center,
+      candidate.width,
+      candidate.height,
+    )
     const boundsStatus = this.getBoundsStatus({
-      bounds: getRectBounds(
-        candidate.center,
-        candidate.width,
-        candidate.height,
-      ),
+      bounds,
       labelIndex,
       label,
     })
-    if (boundsStatus !== "valid") return boundsStatus
+    if (boundsStatus !== "valid") {
+      if (
+        phase !== "trace-anchor" ||
+        boundsStatus !== "chip-collision" ||
+        !this.isAcceptableTraceAnchorChipCollision(candidate, label, bounds)
+      ) {
+        return boundsStatus
+      }
+
+      const nonChipBoundsStatus = this.getBoundsStatus({
+        bounds,
+        labelIndex,
+        label,
+        ignoreChipCollisions: true,
+      })
+      if (nonChipBoundsStatus !== "valid") return nonChipBoundsStatus
+    }
 
     const connectorTrace = this.getCandidateConnectorTrace(label, {
       anchorPoint: candidate.anchorPoint,
@@ -647,22 +724,59 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     return "valid"
   }
 
+  private isAcceptableTraceAnchorChipCollision(
+    candidate: CandidateLabel,
+    label: NetLabelPlacement,
+    bounds: Bounds,
+  ) {
+    const collidingChips =
+      this.chipObstacleSpatialIndex.getChipsInBounds(bounds)
+    if (collidingChips.length === 0) return false
+
+    const labelChipIds = new Set(
+      label.pinIds
+        .map((pinId) => this.pinMap[pinId]?.chipId)
+        .filter((chipId): chipId is string => Boolean(chipId)),
+    )
+
+    return collidingChips.every((chip) => {
+      if (!labelChipIds.has(chip.chipId)) return false
+
+      const { anchorPoint, orientation } = candidate
+      const chipBounds = chip.bounds
+      if (isYOrientation(orientation)) {
+        return (
+          anchorPoint.x < chipBounds.minX - EPS ||
+          anchorPoint.x > chipBounds.maxX + EPS
+        )
+      }
+      return (
+        anchorPoint.y < chipBounds.minY - EPS ||
+        anchorPoint.y > chipBounds.maxY + EPS
+      )
+    })
+  }
+
   private getBoundsStatus(candidateBoundsCheck: {
     bounds: Bounds
     labelIndex: number
     label: NetLabelPlacement
+    ignoreChipCollisions?: boolean
   }): CandidateStatus {
-    const { bounds, labelIndex, label } = candidateBoundsCheck
+    const { bounds, labelIndex, label, ignoreChipCollisions } =
+      candidateBoundsCheck
 
-    if (this.chipObstacleSpatialIndex.getChipsInBounds(bounds).length > 0) {
-      return "chip-collision"
+    if (!ignoreChipCollisions) {
+      if (this.chipObstacleSpatialIndex.getChipsInBounds(bounds).length > 0) {
+        return "chip-collision"
+      }
+      if (this.sharesChipBoundary(bounds)) {
+        return "chip-collision"
+      }
     }
     if (rectIntersectsAnyTextBox(bounds, this.inputProblem)) {
       return "text-collision"
     }
-    if (this.sharesChipBoundary(bounds)) {
-      return "chip-collision"
-    }
     if (traceCrossesBoundsInterior(bounds, this.traceMap)) {
       return "trace-collision"
     }

package/lib/solvers/AvailableNetOrientationSolver/types.ts

@@ -35,7 +35,11 @@ export type CandidateStatus =
   | "trace-clearance-violation"
   | "netlabel-collision"
 
-export type CandidatePhase = "rotate" | "shift" | "lateral-shift"
+export type CandidatePhase =
+  | "rotate"
+  | "trace-anchor"
+  | "shift"
+  | "lateral-shift"
 
 export type EvaluatedCandidate = CandidateLabel & {
   status: CandidateStatus

package/package.json

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

package/tests/repros/rotated-components-rail-label.test.ts

@@ -0,0 +1,68 @@
+import { expect, test } from "bun:test"
+import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+
+const inputProblem: InputProblem = {
+  chips: [
+    {
+      chipId: "D1",
+      center: { x: 7.9, y: 0 },
+      width: 0.7400000000000002,
+      height: 1.04,
+      pins: [
+        { pinId: "D1.1", x: 8, y: -0.52 },
+        { pinId: "D1.2", x: 8, y: 0.52 },
+      ],
+    },
+    {
+      chipId: "D2",
+      center: { x: 10, y: 0.07 },
+      width: 1.0399999999999991,
+      height: 0.68,
+      pins: [
+        { pinId: "D2.1", x: 9.48, y: 0 },
+        { pinId: "D2.2", x: 10.52, y: 0 },
+      ],
+    },
+  ],
+  directConnections: [],
+  netConnections: [
+    {
+      netId: "VCC",
+      pinIds: ["D1.1", "D2.1"],
+      netLabelWidth: 0.48,
+      netLabelHeight: 0.42,
+    },
+    {
+      netId: "GND",
+      pinIds: ["D1.2", "D2.2"],
+      netLabelWidth: 0.48,
+      netLabelHeight: 0.42,
+    },
+  ],
+  textBoxes: [],
+  availableNetLabelOrientations: {
+    GND: ["y-"],
+    VCC: ["y+"],
+  },
+  maxMspPairDistance: 0.1,
+}
+
+test("rotated component rail label stays on the existing trace", () => {
+  const solver = new SchematicTracePipelineSolver(inputProblem)
+  solver.solve()
+
+  const traces = solver.netLabelTraceCollisionSolver!.getOutput().traces
+  const labels =
+    solver.netLabelNetLabelCollisionSolver!.getOutput().netLabelPlacements
+  const gndLabel = labels.find((label) => label.netId === "GND")
+
+  expect(
+    traces.some((trace) =>
+      trace.mspPairId.startsWith("available-net-orientation"),
+    ),
+  ).toBe(false)
+  expect(gndLabel?.orientation).toBe("y-")
+  expect(gndLabel?.anchorPoint.x).toBeCloseTo(10.72)
+  expect(gndLabel?.anchorPoint.y).toBeCloseTo(0)
+})