@tscircuit/schematic-trace-solver 0.0.81 → 0.0.83

package/biome.json

@@ -19,6 +19,11 @@
       "bracketSameLine": false
     }
   },
+  "json": {
+    "formatter": {
+      "enabled": false
+    }
+  },
   "linter": {
     "enabled": true,
     "rules": {

package/dist/index.d.ts

@@ -666,6 +666,7 @@ declare class Example28Solver extends BaseSolver {
     currentOverlap: TraceLabelOverlap | null;
     currentCandidateResults: RerouteCandidateResult[];
     private chipObstacles;
+    private pinMap;
     constructor(params: Example28SolverParams);
     getConstructorParams(): ConstructorParameters<typeof Example28Solver>[0];
     _step(): void;
@@ -679,6 +680,7 @@ declare class Example28Solver extends BaseSolver {
     private isOverlapStillPresent;
     private getCurrentTrace;
     private rerouteOverlappingTrace;
+    private tryMoveLabelOutward;
     visualize(): GraphicsObject;
 }
 
@@ -695,7 +697,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 +735,8 @@ declare class AvailableNetOrientationSolver extends BaseSolver {
     private setCurrentLabel;
     private findCorrectedCandidate;
     private findValidRotatedCandidate;
+    private findValidTraceAnchorCandidate;
+    private getTraceAnchorCandidatePoints;
     private getAvailableOrientations;
     private findValidShiftedCandidate;
     /**
@@ -757,6 +761,7 @@ declare class AvailableNetOrientationSolver extends BaseSolver {
     private getNetLabelWidth;
     private getNetLabelHeight;
     private getCandidateStatus;
+    private isAcceptableTraceAnchorChipCollision;
     private getBoundsStatus;
     private isTraceTooCloseToLabel;
     private getLabelTraceClearanceBounds;

package/dist/index.js

@@ -5162,6 +5162,54 @@ var TraceCleanupSolver = class extends BaseSolver {
   }
 };
 
+// lib/solvers/AvailableNetOrientationSolver/traces.ts
+var getPinMap = (inputProblem) => {
+  const pinMap = {};
+  for (const chip of inputProblem.chips) {
+    for (const pin of chip.pins) {
+      pinMap[pin.pinId] = { ...pin, chipId: chip.chipId };
+    }
+  }
+  return pinMap;
+};
+var getTracePins = (label, pinMap) => {
+  const pins = label.pinIds.flatMap((pinId) => {
+    const pin = pinMap[pinId];
+    return pin ? [pin] : [];
+  });
+  if (pins.length >= 2) return [pins[0], pins[1]];
+  if (pins.length === 1) return [pins[0], pins[0]];
+  const syntheticPin = {
+    pinId: `${label.globalConnNetId}-netlabel-anchor`,
+    x: label.anchorPoint.x,
+    y: label.anchorPoint.y,
+    chipId: "available-net-orientation"
+  };
+  return [syntheticPin, syntheticPin];
+};
+var toNetLabelPlacementPatch = (candidate) => ({
+  orientation: candidate.orientation,
+  anchorPoint: candidate.anchorPoint,
+  center: candidate.center,
+  width: candidate.width,
+  height: candidate.height
+});
+
+// lib/utils/dir.ts
+var dir = (facingDirection) => {
+  switch (facingDirection) {
+    case "x+":
+      return { x: 1, y: 0 };
+    case "x-":
+      return { x: -1, y: 0 };
+    case "y+":
+      return { x: 0, y: 1 };
+    case "y-":
+      return { x: 0, y: -1 };
+  }
+  throw new Error(`Invalid facing direction: ${facingDirection}`);
+};
+
 // lib/solvers/Example28Solver/types.ts
 var EPS7 = 1e-9;
 
@@ -5369,24 +5417,8 @@ var moveAttachedLabelsToReroutedTrace = ({
   };
 });
 
-// lib/utils/dir.ts
-var dir = (facingDirection) => {
-  switch (facingDirection) {
-    case "x+":
-      return { x: 1, y: 0 };
-    case "x-":
-      return { x: -1, y: 0 };
-    case "y+":
-      return { x: 0, y: 1 };
-    case "y-":
-      return { x: 0, y: -1 };
-  }
-  throw new Error(`Invalid facing direction: ${facingDirection}`);
-};
-
 // lib/solvers/Example28Solver/reroute.ts
-var LABEL_SIDE_CLEARANCE = 0.1;
-var LABEL_HUG_CLEARANCE = 1e-3;
+var LABEL_CLEARANCE = 0.1;
 var findBestReroutePath = ({
   trace,
   obstacleLabel,
@@ -5447,7 +5479,7 @@ var generateRerouteCandidateResults = ({
       trace,
       label,
       problem: inputProblem,
-      paddingBuffer: LABEL_SIDE_CLEARANCE,
+      paddingBuffer: LABEL_CLEARANCE,
       detourCount: 0
     }),
     ...generateEndpointDetourCandidates(trace, label)
@@ -5513,8 +5545,10 @@ var generateEndpointDetourCandidates = (trace, label) => {
   const start = trace.tracePath[0];
   const end = trace.tracePath[trace.tracePath.length - 1];
   if (!start || !end) return [];
+  const startExit = trace.tracePath[1] ?? start;
+  const endEntry = trace.tracePath[trace.tracePath.length - 2] ?? end;
   const bounds = getRectBounds(label.center, label.width, label.height);
-  const padding = LABEL_SIDE_CLEARANCE;
+  const padding = LABEL_CLEARANCE;
   const labelDirection = dir(label.orientation);
   const labelSideX = labelDirection.x < 0 ? bounds.minX - padding : bounds.maxX + padding;
   const oppositeSideX = labelDirection.x < 0 ? bounds.maxX + padding : bounds.minX - padding;
@@ -5525,18 +5559,22 @@ var generateEndpointDetourCandidates = (trace, label) => {
     candidates.push(
       [
         start,
-        { x: start.x, y: topY },
+        startExit,
+        { x: startExit.x, y: topY },
         { x: sideX, y: topY },
         { x: sideX, y: bottomY },
-        { x: end.x, y: bottomY },
+        { x: endEntry.x, y: bottomY },
+        endEntry,
         end
       ],
       [
         start,
-        { x: start.x, y: bottomY },
+        startExit,
+        { x: startExit.x, y: bottomY },
         { x: sideX, y: bottomY },
         { x: sideX, y: topY },
-        { x: end.x, y: topY },
+        { x: endEntry.x, y: topY },
+        endEntry,
         end
       ]
     );
@@ -5547,30 +5585,36 @@ var generateLabelHugCandidates = (trace, label) => {
   const start = trace.tracePath[0];
   const end = trace.tracePath[trace.tracePath.length - 1];
   if (!start || !end) return [];
+  const startExit = trace.tracePath[1] ?? start;
+  const endEntry = trace.tracePath[trace.tracePath.length - 2] ?? end;
   const labelDirection = dir(label.orientation);
   if (labelDirection.x === 0) return [];
   const bounds = getRectBounds(label.center, label.width, label.height);
-  const sideX = labelDirection.x < 0 ? bounds.minX - LABEL_SIDE_CLEARANCE : bounds.maxX + LABEL_SIDE_CLEARANCE;
-  const topY = bounds.maxY + LABEL_HUG_CLEARANCE;
-  const bottomY = bounds.minY - LABEL_HUG_CLEARANCE;
-  const startsAboveEnd = start.y >= end.y;
+  const sideX = labelDirection.x < 0 ? bounds.minX - LABEL_CLEARANCE : bounds.maxX + LABEL_CLEARANCE;
+  const topY = bounds.maxY + LABEL_CLEARANCE;
+  const bottomY = bounds.minY - LABEL_CLEARANCE;
+  const startsAboveEnd = startExit.y >= endEntry.y;
   const firstY = startsAboveEnd ? topY : bottomY;
   const secondY = startsAboveEnd ? bottomY : topY;
   return [
     [
       start,
-      { x: start.x, y: firstY },
+      startExit,
+      { x: startExit.x, y: firstY },
       { x: sideX, y: firstY },
       { x: sideX, y: secondY },
-      { x: end.x, y: secondY },
+      { x: endEntry.x, y: secondY },
+      endEntry,
       end
     ],
     [
       start,
-      { x: start.x, y: secondY },
+      startExit,
+      { x: startExit.x, y: secondY },
       { x: sideX, y: secondY },
       { x: sideX, y: firstY },
-      { x: end.x, y: firstY },
+      { x: endEntry.x, y: firstY },
+      endEntry,
       end
     ]
   ];
@@ -5625,9 +5669,9 @@ var generateHorizontalSegmentPushCandidate = (trace, label) => {
   if (Math.abs(previousAnchor.y - verticalStart.y) >= 1e-9 || Math.abs(verticalEnd.y - nextAnchor.y) >= 1e-9) {
     return null;
   }
-  let segmentPushX = bounds.minX - LABEL_SIDE_CLEARANCE;
+  let segmentPushX = bounds.minX - LABEL_CLEARANCE;
   if (labelDirection.x > 0) {
-    segmentPushX = bounds.maxX + LABEL_SIDE_CLEARANCE;
+    segmentPushX = bounds.maxX + LABEL_CLEARANCE;
   }
   const segmentPushStartY = getClearedHorizontalY({
     start: previousAnchor,
@@ -5665,9 +5709,9 @@ var getClearedHorizontalY = ({
   if (!segmentIntersectsRect2(start, end, labelBounds)) return start.y;
   const labelCenterY = (labelBounds.minY + labelBounds.maxY) / 2;
   if (start.y >= labelCenterY) {
-    return labelBounds.maxY + LABEL_HUG_CLEARANCE;
+    return labelBounds.maxY + LABEL_CLEARANCE;
   }
-  return labelBounds.minY - LABEL_HUG_CLEARANCE;
+  return labelBounds.minY - LABEL_CLEARANCE;
 };
 var markSelectedCandidate = (candidateResults, bestPath) => {
   if (!bestPath) return;
@@ -5800,6 +5844,9 @@ ${label.netId ?? label.globalConnNetId}`
 };
 
 // lib/solvers/Example28Solver/Example28Solver.ts
+var LABEL_OUTWARD_STEP = 0.1;
+var LABEL_MAX_OUTWARD_STEPS = 10;
+var LABEL_TRACE_CLEARANCE = 0.1;
 var Example28Solver = class extends BaseSolver {
   inputProblem;
   traces;
@@ -5810,6 +5857,7 @@ var Example28Solver = class extends BaseSolver {
   currentOverlap = null;
   currentCandidateResults = [];
   chipObstacles;
+  pinMap;
   constructor(params) {
     super();
     this.inputProblem = params.inputProblem;
@@ -5818,6 +5866,7 @@ var Example28Solver = class extends BaseSolver {
     this.outputTraces = [...params.traces];
     this.outputNetLabelPlacements = [...params.netLabelPlacements];
     this.chipObstacles = getObstacleRects(params.inputProblem);
+    this.pinMap = getPinMap(params.inputProblem);
     this.initializeQueuedOverlaps();
     this.currentOverlap = this.queuedOverlaps[0] ?? null;
   }
@@ -5900,6 +5949,7 @@ var Example28Solver = class extends BaseSolver {
     );
     if (traceIndex === -1) return;
     const currentTrace = this.outputTraces[traceIndex];
+    if (this.tryMoveLabelOutward(overlap.label)) return;
     const rerouteResult = findBestReroutePath({
       trace: currentTrace,
       obstacleLabel: overlap.label,
@@ -5922,6 +5972,62 @@ var Example28Solver = class extends BaseSolver {
       netLabelPlacements: this.outputNetLabelPlacements
     });
   }
+  tryMoveLabelOutward(labelToMove) {
+    const labelIndex = this.outputNetLabelPlacements.findIndex(
+      (label2) => label2.globalConnNetId === labelToMove.globalConnNetId && label2.anchorPoint.x === labelToMove.anchorPoint.x && label2.anchorPoint.y === labelToMove.anchorPoint.y && label2.pinIds.join(",") === labelToMove.pinIds.join(",")
+    );
+    if (labelIndex === -1) return false;
+    const label = this.outputNetLabelPlacements[labelIndex];
+    if (label.mspConnectionPairIds.length > 0) return false;
+    if (label.pinIds.length !== 1) return false;
+    if (this.outputNetLabelPlacements.filter(
+      (otherLabel) => otherLabel.globalConnNetId === label.globalConnNetId
+    ).length !== 1) {
+      return false;
+    }
+    const outward = dir(label.orientation);
+    if (outward.x === 0 && outward.y === 0) return false;
+    for (let step = 1; step <= LABEL_MAX_OUTWARD_STEPS; step++) {
+      const distance3 = step * LABEL_OUTWARD_STEP;
+      const candidate = {
+        ...label,
+        anchorPoint: {
+          x: label.anchorPoint.x + outward.x * distance3,
+          y: label.anchorPoint.y + outward.y * distance3
+        },
+        center: {
+          x: label.center.x + outward.x * distance3,
+          y: label.center.y + outward.y * distance3
+        }
+      };
+      const candidateWithClearance = {
+        ...candidate,
+        width: candidate.width + LABEL_TRACE_CLEARANCE * 2,
+        height: candidate.height + LABEL_TRACE_CLEARANCE * 2
+      };
+      if (detectTraceLabelOverlap({
+        traces: this.outputTraces,
+        netLabels: [candidateWithClearance]
+      }).length > 0) {
+        continue;
+      }
+      const connectorTrace = createPortOnlyLabelConnectorTrace({
+        label,
+        movedLabel: candidate,
+        pinMap: this.pinMap
+      });
+      if (detectTraceLabelOverlap({
+        traces: [connectorTrace],
+        netLabels: this.outputNetLabelPlacements
+      }).length > 0) {
+        continue;
+      }
+      this.outputNetLabelPlacements[labelIndex] = candidate;
+      this.outputTraces.push(connectorTrace);
+      return true;
+    }
+    return false;
+  }
   visualize() {
     return visualizeExample28Solver({
       inputProblem: this.inputProblem,
@@ -5933,6 +6039,24 @@ var Example28Solver = class extends BaseSolver {
     });
   }
 };
+var getPortOnlyLabelConnectorMspPairId = (label) => `port-only-label-connector-${label.globalConnNetId}-${label.pinIds[0]}`;
+var createPortOnlyLabelConnectorTrace = ({
+  label,
+  movedLabel,
+  pinMap
+}) => {
+  const mspPairId = getPortOnlyLabelConnectorMspPairId(label);
+  return {
+    mspPairId,
+    dcConnNetId: label.dcConnNetId ?? label.globalConnNetId,
+    globalConnNetId: label.globalConnNetId,
+    userNetId: label.netId,
+    pins: getTracePins(label, pinMap),
+    tracePath: [label.anchorPoint, movedLabel.anchorPoint],
+    mspConnectionPairIds: [mspPairId],
+    pinIds: label.pinIds
+  };
+};
 
 // lib/solvers/AvailableNetOrientationSolver/constants.ts
 var LABEL_SEARCH_STEP = 0.05;
@@ -6046,39 +6170,6 @@ var getMaxSearchDistance = (inputProblem) => {
   return maxChipWidth * 3;
 };
 
-// lib/solvers/AvailableNetOrientationSolver/traces.ts
-var getPinMap = (inputProblem) => {
-  const pinMap = {};
-  for (const chip of inputProblem.chips) {
-    for (const pin of chip.pins) {
-      pinMap[pin.pinId] = { ...pin, chipId: chip.chipId };
-    }
-  }
-  return pinMap;
-};
-var getTracePins = (label, pinMap) => {
-  const pins = label.pinIds.flatMap((pinId) => {
-    const pin = pinMap[pinId];
-    return pin ? [pin] : [];
-  });
-  if (pins.length >= 2) return [pins[0], pins[1]];
-  if (pins.length === 1) return [pins[0], pins[0]];
-  const syntheticPin = {
-    pinId: `${label.globalConnNetId}-netlabel-anchor`,
-    x: label.anchorPoint.x,
-    y: label.anchorPoint.y,
-    chipId: "available-net-orientation"
-  };
-  return [syntheticPin, syntheticPin];
-};
-var toNetLabelPlacementPatch = (candidate) => ({
-  orientation: candidate.orientation,
-  anchorPoint: candidate.anchorPoint,
-  center: candidate.center,
-  width: candidate.width,
-  height: candidate.height
-});
-
 // lib/solvers/AvailableNetOrientationSolver/visualize.ts
 var visualizeAvailableNetOrientationSolver = (params) => {
   const graphics = visualizeInputProblem(params.inputProblem);
@@ -6167,7 +6258,7 @@ var ensureGraphicsArrays = (graphics) => {
 };
 
 // lib/solvers/AvailableNetOrientationSolver/AvailableNetOrientationSolver.ts
-var LABEL_TRACE_CLEARANCE = 0.1;
+var LABEL_TRACE_CLEARANCE2 = 0.1;
 var AvailableNetOrientationSolver = class extends BaseSolver {
   inputProblem;
   traces;
@@ -6246,6 +6337,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 +6372,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 +6411,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 +6719,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 +6763,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";
     }
@@ -6648,10 +6816,10 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
   }
   getLabelTraceClearanceBounds(bounds) {
     return {
-      minX: bounds.minX - LABEL_TRACE_CLEARANCE,
-      minY: bounds.minY - LABEL_TRACE_CLEARANCE,
-      maxX: bounds.maxX + LABEL_TRACE_CLEARANCE,
-      maxY: bounds.maxY + LABEL_TRACE_CLEARANCE
+      minX: bounds.minX - LABEL_TRACE_CLEARANCE2,
+      minY: bounds.minY - LABEL_TRACE_CLEARANCE2,
+      maxX: bounds.maxX + LABEL_TRACE_CLEARANCE2,
+      maxY: bounds.maxY + LABEL_TRACE_CLEARANCE2
     };
   }
   shouldCheckTraceClearanceForLabel(label) {