@tscircuit/schematic-trace-solver 0.0.76 → 0.0.78

package/dist/index.d.ts

@@ -137,21 +137,39 @@ declare class MspConnectionPairSolver extends BaseSolver {
     visualize(): GraphicsObject;
 }
 
-type ChipWithBounds = {
-    chipId: string;
+type RectPadding = {
+    minX?: number;
+    minY?: number;
+    maxX?: number;
+    maxY?: number;
+};
+
+type RectBounds = {
     minX: number;
     minY: number;
     maxX: number;
     maxY: number;
 };
-declare const getObstacleRects: (problem: InputProblem) => ChipWithBounds[];
+type ChipObstacleRect = RectBounds & {
+    kind: "chip";
+    chipId: string;
+};
+type TextBoxObstacleRect = RectBounds & {
+    kind: "text_box";
+    textBox: NonNullable<InputProblem["textBoxes"]>[number];
+};
+type ObstacleRect = ChipObstacleRect | TextBoxObstacleRect;
+declare const getObstacleRects: (problem: InputProblem, opts?: {
+    textBoxPadding?: RectPadding;
+}) => ObstacleRect[];
 
 declare class SchematicTraceSingleLineSolver2 extends BaseSolver {
     pins: MspConnectionPair["pins"];
+    connectionPair?: MspConnectionPair;
     inputProblem: InputProblem;
     chipMap: Record<string, InputChip>;
-    obstacles: ChipWithBounds[];
-    rectById: Map<string, ChipWithBounds>;
+    obstacles: ObstacleRect[];
+    textObstacles: Set<ObstacleRect>;
     aabb: {
         minX: number;
         maxX: number;
@@ -164,10 +182,14 @@ declare class SchematicTraceSingleLineSolver2 extends BaseSolver {
     private visited;
     constructor(params: {
         pins: MspConnectionPair["pins"];
+        connectionPair?: MspConnectionPair;
         inputProblem: InputProblem;
         chipMap: Record<string, InputChip>;
     });
     getConstructorParams(): ConstructorParameters<typeof SchematicTraceSingleLineSolver2>[0];
+    private getTextBoxPaddingForConnectionPair;
+    private getNetLabelWidthForConnectionPair;
+    private getNetLabelHeightForConnectionPair;
     private axisOfSegment;
     private pathLength;
     _step(): void;
@@ -324,7 +346,7 @@ declare class SingleNetLabelPlacementSolver extends BaseSolver {
             y: number;
         };
         orientation: FacingDirection;
-        status: "ok" | "chip-collision" | "trace-collision" | "parallel-to-segment";
+        status: "ok" | "chip-collision" | "trace-collision" | "text-collision" | "parallel-to-segment";
         hostSegIndex: number;
     }>;
     constructor(params: {
@@ -672,7 +694,7 @@ type CandidateLabel = {
     width: number;
     height: number;
 };
-type CandidateStatus$2 = "valid" | "chip-collision" | "trace-collision" | "netlabel-collision";
+type CandidateStatus$2 = "valid" | "chip-collision" | "text-collision" | "trace-collision" | "netlabel-collision";
 type CandidatePhase = "rotate" | "shift" | "lateral-shift";
 type EvaluatedCandidate = CandidateLabel & {
     status: CandidateStatus$2;
@@ -756,7 +778,7 @@ type TraceCornerCandidate = {
     traceId: string;
     distance: number;
 };
-type CornerCandidateStatus = "valid" | "chip-collision" | "trace-collision" | "netlabel-collision";
+type CornerCandidateStatus = "valid" | "chip-collision" | "text-collision" | "trace-collision" | "netlabel-collision";
 type EvaluatedCornerCandidate = TraceCornerCandidate & {
     center: Point;
     width: number;
@@ -809,7 +831,7 @@ type LabelOverlap = {
     firstLabelIndex: number;
     secondLabelIndex: number;
 };
-type CandidateStatus$1 = "valid" | "chip-collision" | "trace-collision" | "netlabel-collision";
+type CandidateStatus$1 = "valid" | "chip-collision" | "text-collision" | "trace-collision" | "netlabel-collision";
 type LabelCandidate = {
     anchorPoint: Point;
     center: Point;
@@ -887,7 +909,7 @@ declare class NetLabelTraceCollisionSolver extends BaseSolver {
     visualize(): GraphicsObject;
 }
 
-type CandidateStatus = "ok" | "chip-collision" | "trace-collision" | "label-collision";
+type CandidateStatus = "ok" | "chip-collision" | "text-collision" | "trace-collision" | "label-collision";
 type Candidate = {
     orientation: FacingDirection;
     anchor: {

package/dist/index.js

@@ -357,6 +357,16 @@ ${pin._facingDirection ?? getPinDirection(pin, chip)}`,
       });
     }
   }
+  for (const textBox of inputProblem.textBoxes ?? []) {
+    graphics.rects.push({
+      label: textBox.text ?? "schematic_text",
+      center: textBox.center,
+      width: textBox.width,
+      height: textBox.height,
+      fill: "rgba(160, 0, 220, 0.14)",
+      strokeColor: "rgba(160, 0, 220, 0.9)"
+    });
+  }
   for (const directConn of inputProblem.directConnections) {
     const [pinId1, pinId2] = directConn.pinIds;
     const pin1 = pinIdMap.get(pinId1);
@@ -581,13 +591,41 @@ function getInputChipBounds(chip) {
   };
 }
 
+// lib/utils/textBoxBounds.ts
+function getTextBoxBounds(textBox, padding = {}) {
+  return {
+    minX: textBox.center.x - textBox.width / 2 - (padding.minX ?? 0),
+    minY: textBox.center.y - textBox.height / 2 - (padding.minY ?? 0),
+    maxX: textBox.center.x + textBox.width / 2 + (padding.maxX ?? 0),
+    maxY: textBox.center.y + textBox.height / 2 + (padding.maxY ?? 0)
+  };
+}
+function boundsOverlap(a, b, eps = 1e-9) {
+  return a.minX < b.maxX - eps && a.maxX > b.minX + eps && a.minY < b.maxY - eps && a.maxY > b.minY + eps;
+}
+function rectIntersectsAnyTextBox(bounds, inputProblem) {
+  for (const textBox of inputProblem.textBoxes ?? []) {
+    if (boundsOverlap(bounds, getTextBoxBounds(textBox))) return true;
+  }
+  return false;
+}
+
 // lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect.ts
 var chipToRect = (chip) => {
   const b = getInputChipBounds(chip);
-  return { chipId: chip.chipId, ...b };
+  return { kind: "chip", chipId: chip.chipId, ...b };
 };
-var getObstacleRects = (problem) => {
-  return problem.chips.map(chipToRect);
+var getObstacleRects = (problem, opts = {}) => {
+  const chipRects = problem.chips.map(chipToRect);
+  const textBoxRects = (problem.textBoxes ?? []).map((textBox) => {
+    const b = getTextBoxBounds(textBox, opts.textBoxPadding);
+    return {
+      kind: "text_box",
+      textBox,
+      ...b
+    };
+  });
+  return [...chipRects, ...textBoxRects];
 };
 
 // lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions.ts
@@ -618,9 +656,9 @@ var findFirstCollision = (pts, rects, opts = {}) => {
   for (let i = 0; i < pts.length - 1; i++) {
     const a = pts[i];
     const b = pts[i + 1];
-    const excluded = opts.excludeRectIdsForSegment?.(i) ?? /* @__PURE__ */ new Set();
+    const excluded = opts.excludeRectsForSegment?.(i) ?? /* @__PURE__ */ new Set();
     for (const r of rects) {
-      if (excluded.has(r.chipId)) continue;
+      if (excluded.has(r)) continue;
       if (segmentIntersectsRect(a, b, r)) {
         return { segIndex: i, rect: r };
       }
@@ -666,8 +704,8 @@ var midBetweenPointAndRect = (axis, p, r, eps = EPS2) => {
     return [r.minY - 0.2, r.maxY + 0.2];
   }
 };
-var candidateMidsFromSet = (axis, colliding, rectsById, collisionRectIds, aabb, eps = EPS2) => {
-  const setRects = [...collisionRectIds].map((id) => rectsById.get(id)).filter((r) => !!r);
+var candidateMidsFromSet = (axis, colliding, collisionRects, aabb, eps = EPS2) => {
+  const setRects = [...collisionRects];
   if (axis === "x") {
     const leftBoundaries = [aabb.minX, ...setRects.map((r) => r.maxX)].filter(
       (v) => v < colliding.minX - eps
@@ -768,13 +806,54 @@ var pathKey = (pts, decimals = 6) => {
   return key;
 };
 
+// lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry.ts
+var NET_LABEL_HORIZONTAL_WIDTH = 0.45;
+var NET_LABEL_HORIZONTAL_HEIGHT = 0.2;
+function getDimsForOrientation(params) {
+  const { orientation, netLabelWidth, netLabelHeight } = params;
+  const horizWidth = typeof netLabelWidth === "number" ? netLabelWidth : NET_LABEL_HORIZONTAL_WIDTH;
+  const horizHeight = typeof netLabelHeight === "number" ? netLabelHeight : NET_LABEL_HORIZONTAL_HEIGHT;
+  if (orientation === "y+" || orientation === "y-") {
+    return {
+      // Rotated: horizontal length = netLabelHeight, vertical length = netLabelWidth
+      width: horizHeight,
+      height: horizWidth
+    };
+  }
+  return {
+    width: horizWidth,
+    height: horizHeight
+  };
+}
+function getCenterFromAnchor(anchor, orientation, width, height) {
+  switch (orientation) {
+    case "x+":
+      return { x: anchor.x + width / 2, y: anchor.y };
+    case "x-":
+      return { x: anchor.x - width / 2, y: anchor.y };
+    case "y+":
+      return { x: anchor.x, y: anchor.y + height / 2 };
+    case "y-":
+      return { x: anchor.x, y: anchor.y - height / 2 };
+  }
+}
+function getRectBounds(center, w, h) {
+  return {
+    minX: center.x - w / 2,
+    minY: center.y - h / 2,
+    maxX: center.x + w / 2,
+    maxY: center.y + h / 2
+  };
+}
+
 // lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/SchematicTraceSingleLineSolver2.ts
 var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
   pins;
+  connectionPair;
   inputProblem;
   chipMap;
   obstacles;
-  rectById;
+  textObstacles;
   aabb;
   baseElbow;
   solvedTracePath = null;
@@ -783,6 +862,7 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
   constructor(params) {
     super();
     this.pins = params.pins;
+    this.connectionPair = params.connectionPair;
     this.inputProblem = params.inputProblem;
     this.chipMap = params.chipMap;
     for (const pin of this.pins) {
@@ -791,8 +871,12 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
         pin._facingDirection = getPinDirection(pin, chip);
       }
     }
-    this.obstacles = getObstacleRects(this.inputProblem);
-    this.rectById = new Map(this.obstacles.map((r) => [r.chipId, r]));
+    this.obstacles = getObstacleRects(this.inputProblem, {
+      textBoxPadding: this.getTextBoxPaddingForConnectionPair()
+    });
+    this.textObstacles = new Set(
+      this.obstacles.filter((r) => r.kind === "text_box")
+    );
     const [pin1, pin2] = this.pins;
     this.baseElbow = calculateElbow(
       {
@@ -811,16 +895,84 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
       { x: pin1.x, y: pin1.y },
       { x: pin2.x, y: pin2.y }
     );
-    this.queue.push({ path: this.baseElbow, collisionChipIds: /* @__PURE__ */ new Set() });
+    this.queue.push({ path: this.baseElbow, collisionRects: /* @__PURE__ */ new Set() });
     this.visited.add(pathKey(this.baseElbow));
   }
   getConstructorParams() {
     return {
       chipMap: this.chipMap,
       pins: this.pins,
+      connectionPair: this.connectionPair,
       inputProblem: this.inputProblem
     };
   }
+  getTextBoxPaddingForConnectionPair() {
+    if (!this.inputProblem.textBoxes?.length) return {};
+    const netId = this.connectionPair?.userNetId;
+    if (!netId) return {};
+    const orientations = this.inputProblem.availableNetLabelOrientations[netId] ?? ["x+", "x-", "y+", "y-"];
+    const netLabelWidth = this.getNetLabelWidthForConnectionPair(netId);
+    const netLabelHeight = this.getNetLabelHeightForConnectionPair(netId);
+    const padding = {
+      minX: 0,
+      minY: 0,
+      maxX: 0,
+      maxY: 0
+    };
+    for (const orientation of orientations) {
+      const { width, height } = getDimsForOrientation({
+        orientation,
+        netLabelWidth,
+        netLabelHeight
+      });
+      if (orientation === "y+" || orientation === "y-") {
+        padding.minX = Math.max(padding.minX, width / 2);
+        padding.maxX = Math.max(padding.maxX, width / 2);
+        if (orientation === "y+") {
+          padding.minY = Math.max(padding.minY, height);
+        } else {
+          padding.maxY = Math.max(padding.maxY, height);
+        }
+      } else {
+        padding.minY = Math.max(padding.minY, height / 2);
+        padding.maxY = Math.max(padding.maxY, height / 2);
+        if (orientation === "x+") {
+          padding.minX = Math.max(padding.minX, width);
+        } else {
+          padding.maxX = Math.max(padding.maxX, width);
+        }
+      }
+    }
+    return padding;
+  }
+  getNetLabelWidthForConnectionPair(netId) {
+    const ncWidth = this.inputProblem.netConnections.find(
+      (nc) => nc.netId === netId
+    )?.netLabelWidth;
+    if (ncWidth !== void 0) return ncWidth;
+    const dcWidthByNetId = this.inputProblem.directConnections.find(
+      (dc) => dc.netId === netId
+    )?.netLabelWidth;
+    if (dcWidthByNetId !== void 0) return dcWidthByNetId;
+    const pinIds = this.pins.map((p) => p.pinId);
+    const dcWidthByPinId = this.inputProblem.directConnections.find(
+      (dc) => dc.pinIds.some((pid) => pinIds.includes(pid))
+    )?.netLabelWidth;
+    if (dcWidthByPinId !== void 0) return dcWidthByPinId;
+    return this.inputProblem.netConnections.find(
+      (nc) => nc.pinIds.some((pid) => pinIds.includes(pid))
+    )?.netLabelWidth;
+  }
+  getNetLabelHeightForConnectionPair(netId) {
+    const ncHeight = this.inputProblem.netConnections.find(
+      (nc) => nc.netId === netId
+    )?.netLabelHeight;
+    if (ncHeight !== void 0) return ncHeight;
+    const pinIds = this.pins.map((p) => p.pinId);
+    return this.inputProblem.netConnections.find(
+      (nc) => nc.pinIds.some((pid) => pinIds.includes(pid))
+    )?.netLabelHeight;
+  }
   axisOfSegment(a, b) {
     if (isVertical(a, b)) return "x";
     if (isHorizontal(a, b)) return "y";
@@ -844,9 +996,17 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
       this.error = "No collision-free path found";
       return;
     }
-    const { path, collisionChipIds } = state;
+    const { path, collisionRects } = state;
     const [PA, PB] = this.pins;
-    const collision = findFirstCollision(path, this.obstacles);
+    const collision = findFirstCollision(path, this.obstacles, {
+      excludeRectsForSegment: (segIndex2) => {
+        const lastSegIndex = path.length - 2;
+        if (segIndex2 === 0 || segIndex2 === lastSegIndex) {
+          return this.textObstacles;
+        }
+        return /* @__PURE__ */ new Set();
+      }
+    });
     if (!collision) {
       const first = path[0];
       const last = path[path.length - 1];
@@ -879,20 +1039,14 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
       return;
     }
     const candidates = [];
-    if (collisionChipIds.size === 0) {
+    if (collisionRects.size === 0) {
       const m1 = midBetweenPointAndRect(axis, { x: PA.x, y: PA.y }, rect);
       const m2 = midBetweenPointAndRect(axis, { x: PB.x, y: PB.y }, rect);
       const allCandidates = [...m1, ...m2];
       const uniqueCandidates = [...new Set(allCandidates)];
       candidates.push(...uniqueCandidates);
     } else {
-      const mids = candidateMidsFromSet(
-        axis,
-        rect,
-        this.rectById,
-        collisionChipIds,
-        this.aabb
-      );
+      const mids = candidateMidsFromSet(axis, rect, collisionRects, this.aabb);
       candidates.push(...mids);
     }
     const newStates = [];
@@ -902,14 +1056,14 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
       const key = pathKey(newPath);
       if (this.visited.has(key)) continue;
       this.visited.add(key);
-      const nextSet = new Set(collisionChipIds);
-      nextSet.add(rect.chipId);
+      const nextSet = new Set(collisionRects);
+      nextSet.add(rect);
       const len = this.pathLength(newPath);
-      newStates.push({ path: newPath, collisionRectIds: nextSet, len });
+      newStates.push({ path: newPath, collisionRects: nextSet, len });
     }
     newStates.sort((a2, b2) => a2.len - b2.len);
     for (const st of newStates) {
-      this.queue.push({ path: st.path, collisionChipIds: st.collisionRectIds });
+      this.queue.push({ path: st.path, collisionRects: st.collisionRects });
     }
   }
   visualize() {
@@ -931,7 +1085,7 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
       strokeColor: "blue",
       strokeDash: "5 5"
     });
-    for (const { path, collisionChipIds: collisionRectIds } of this.queue) {
+    for (const { path } of this.queue) {
       g.lines.push({ points: path, strokeColor: "teal", strokeDash: "2 2" });
     }
     if (this.solvedTracePath) {
@@ -1013,6 +1167,7 @@ var SchematicTraceLinesSolver = class extends BaseSolver {
     this.activeSubSolver = new SchematicTraceSingleLineSolver2({
       inputProblem: this.inputProblem,
       pins,
+      connectionPair,
       chipMap: this.chipMap
     });
   }
@@ -1628,46 +1783,6 @@ var ChipObstacleSpatialIndex = class {
   }
 };
 
-// lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry.ts
-var NET_LABEL_HORIZONTAL_WIDTH = 0.45;
-var NET_LABEL_HORIZONTAL_HEIGHT = 0.2;
-function getDimsForOrientation(params) {
-  const { orientation, netLabelWidth, netLabelHeight } = params;
-  const horizWidth = typeof netLabelWidth === "number" ? netLabelWidth : NET_LABEL_HORIZONTAL_WIDTH;
-  const horizHeight = typeof netLabelHeight === "number" ? netLabelHeight : NET_LABEL_HORIZONTAL_HEIGHT;
-  if (orientation === "y+" || orientation === "y-") {
-    return {
-      // Rotated: horizontal length = netLabelHeight, vertical length = netLabelWidth
-      width: horizHeight,
-      height: horizWidth
-    };
-  }
-  return {
-    width: horizWidth,
-    height: horizHeight
-  };
-}
-function getCenterFromAnchor(anchor, orientation, width, height) {
-  switch (orientation) {
-    case "x+":
-      return { x: anchor.x + width / 2, y: anchor.y };
-    case "x-":
-      return { x: anchor.x - width / 2, y: anchor.y };
-    case "y+":
-      return { x: anchor.x, y: anchor.y + height / 2 };
-    case "y-":
-      return { x: anchor.x, y: anchor.y - height / 2 };
-  }
-}
-function getRectBounds(center, w, h) {
-  return {
-    minX: center.x - w / 2,
-    minY: center.y - h / 2,
-    maxX: center.x + w / 2,
-    maxY: center.y + h / 2
-  };
-}
-
 // lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/collisions.ts
 function segmentIntersectsRect2(p1, p2, rect, EPS11 = 1e-9) {
   const isVert = Math.abs(p1.x - p2.x) < EPS11;
@@ -1833,6 +1948,19 @@ function solveNetLabelPlacementForPortOnlyPin(params) {
       });
       continue;
     }
+    if (rectIntersectsAnyTextBox(bounds, inputProblem)) {
+      testedCandidates.push({
+        center,
+        width: width2,
+        height: height2,
+        bounds,
+        anchor,
+        orientation,
+        status: "text-collision",
+        hostSegIndex: -1
+      });
+      continue;
+    }
     const traceIntersectionResult = rectIntersectsAnyTrace(
       bounds,
       inputTraceMap,
@@ -1929,9 +2057,9 @@ function visualizeSingleNetLabelPlacementSolver(solver) {
     });
   }
   for (const c of solver.testedCandidates) {
-    const fill = c.status === "ok" ? "rgba(0, 180, 0, 0.25)" : c.status === "chip-collision" ? "rgba(220, 0, 0, 0.25)" : c.status === "trace-collision" ? "rgba(220, 140, 0, 0.25)" : "rgba(120, 120, 120, 0.15)";
-    const stroke = c.status === "ok" ? "green" : c.status === "chip-collision" ? "red" : c.status === "trace-collision" ? "orange" : "gray";
-    const candidateLabel = c.status === "ok" ? "status: ok(valid net label candidate)" : c.status === "chip-collision" ? "status: chip-collision" : c.status === "trace-collision" ? "status: trace-collision" : "status: parallel-to-segment";
+    const fill = c.status === "ok" ? "rgba(0, 180, 0, 0.25)" : c.status === "chip-collision" ? "rgba(220, 0, 0, 0.25)" : c.status === "trace-collision" ? "rgba(220, 140, 0, 0.25)" : c.status === "text-collision" ? "rgba(160, 0, 220, 0.2)" : "rgba(120, 120, 120, 0.15)";
+    const stroke = c.status === "ok" ? "green" : c.status === "chip-collision" ? "red" : c.status === "trace-collision" ? "orange" : c.status === "text-collision" ? "purple" : "gray";
+    const candidateLabel = c.status === "ok" ? "status: ok(valid net label candidate)" : c.status === "chip-collision" ? "status: chip-collision" : c.status === "trace-collision" ? "status: trace-collision" : c.status === "text-collision" ? "status: text-collision" : "status: parallel-to-segment";
     graphics.rects.push({
       center: {
         x: (c.bounds.minX + c.bounds.maxX) / 2,
@@ -2119,6 +2247,19 @@ var SingleNetLabelPlacementSolver = class extends BaseSolver {
               });
               continue;
             }
+            if (rectIntersectsAnyTextBox(bounds, this.inputProblem)) {
+              this.testedCandidates.push({
+                center: testCenter,
+                width,
+                height,
+                bounds,
+                anchor,
+                orientation,
+                status: "text-collision",
+                hostSegIndex: si
+              });
+              continue;
+            }
             const traceIntersectionResult = rectIntersectsAnyTrace(
               bounds,
               this.inputTraceMap,
@@ -6466,6 +6607,9 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     if (this.chipObstacleSpatialIndex.getChipsInBounds(bounds).length > 0) {
       return "chip-collision";
     }
+    if (rectIntersectsAnyTextBox(bounds, this.inputProblem)) {
+      return "text-collision";
+    }
     if (this.sharesChipBoundary(bounds)) {
       return "chip-collision";
     }
@@ -6826,6 +6970,8 @@ var VccNetLabelCornerPlacementSolver = class extends BaseSolver {
   }
   getCandidateStatus(bounds, labelIndex) {
     if (this.intersectsAnyChip(bounds)) return "chip-collision";
+    if (rectIntersectsAnyTextBox(bounds, this.inputProblem))
+      return "text-collision";
     if (traceCrossesBoundsInterior(bounds, this.traceMap)) {
       return "trace-collision";
     }
@@ -7583,6 +7729,8 @@ var TraceAnchoredNetLabelOverlapSolver = class extends BaseSolver {
   getCandidateStatus(candidate, labelIndex) {
     const bounds = getLabelBounds(candidate);
     if (this.intersectsAnyChip(bounds)) return "chip-collision";
+    if (rectIntersectsAnyTextBox(bounds, this.inputProblem))
+      return "text-collision";
     if (traceCrossesBoundsInterior2(bounds, this.traces))
       return "trace-collision";
     if (this.intersectsAnyOtherLabel(bounds, labelIndex)) {
@@ -7886,15 +8034,17 @@ var CANDIDATE_STATUS_COLOR = {
   ok: "green",
   "label-collision": "orange",
   "trace-collision": "darkorange",
-  "chip-collision": "red"
+  "chip-collision": "red",
+  "text-collision": "purple"
 };
 var CANDIDATE_STATUS_FILL = {
   ok: "rgba(0, 200, 0, 0.25)",
   "label-collision": "rgba(255, 160, 0, 0.2)",
   "trace-collision": "rgba(200, 80, 0, 0.2)",
-  "chip-collision": "rgba(220, 0, 0, 0.15)"
+  "chip-collision": "rgba(220, 0, 0, 0.15)",
+  "text-collision": "rgba(128, 0, 128, 0.15)"
 };
-function boundsOverlap(a, b) {
+function boundsOverlap2(a, b) {
   return a.minX < b.maxX - 1e-9 && a.maxX > b.minX + 1e-9 && a.minY < b.maxY - 1e-9 && a.maxY > b.minY + 1e-9;
 }
 function sampleAnchorsAlongSegment(a, b) {
@@ -7958,7 +8108,7 @@ var NetLabelNetLabelCollisionSolver = class extends BaseSolver {
         const b = labels[j];
         if (a.globalConnNetId === b.globalConnNetId) continue;
         if (this.skippedCollisionKeys.has(this.collisionKey(a, b))) continue;
-        if (boundsOverlap(this.labelBounds(a), this.labelBounds(b)))
+        if (boundsOverlap2(this.labelBounds(a), this.labelBounds(b)))
           return [a, b];
       }
     }
@@ -8050,12 +8200,14 @@ var NetLabelNetLabelCollisionSolver = class extends BaseSolver {
     const { bounds, hostPairId, hostSegIndex } = candidate;
     if (this.chipIndex.getChipsInBounds(bounds).length > 0)
       return "chip-collision";
+    if (rectIntersectsAnyTextBox(bounds, this.inputProblem))
+      return "text-collision";
     if (rectIntersectsAnyTrace(bounds, this.traceMap, hostPairId, hostSegIndex).hasIntersection) {
       return "trace-collision";
     }
     for (const obstacle of obstacleLabels) {
       if (obstacle.globalConnNetId === movingLabelNetId) continue;
-      if (boundsOverlap(bounds, this.labelBounds(obstacle)))
+      if (boundsOverlap2(bounds, this.labelBounds(obstacle)))
         return "label-collision";
     }
     return "ok";

package/lib/solvers/AvailableNetOrientationSolver/AvailableNetOrientationSolver.ts

@@ -36,6 +36,7 @@ import type {
   EvaluatedCandidate,
 } from "./types"
 import { visualizeAvailableNetOrientationSolver } from "./visualize"
+import { rectIntersectsAnyTextBox } from "lib/utils/textBoxBounds"
 
 export class AvailableNetOrientationSolver extends BaseSolver {
   inputProblem: InputProblem
@@ -643,6 +644,9 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     if (this.chipObstacleSpatialIndex.getChipsInBounds(bounds).length > 0) {
       return "chip-collision"
     }
+    if (rectIntersectsAnyTextBox(bounds, this.inputProblem)) {
+      return "text-collision"
+    }
     if (this.sharesChipBoundary(bounds)) {
       return "chip-collision"
     }

package/lib/solvers/AvailableNetOrientationSolver/types.ts

@@ -30,6 +30,7 @@ export type CandidateLabel = {
 export type CandidateStatus =
   | "valid"
   | "chip-collision"
+  | "text-collision"
   | "trace-collision"
   | "netlabel-collision"
 

package/lib/solvers/NetLabelNetLabelCollisionSolver/NetLabelNetLabelCollisionSolver.ts

@@ -14,10 +14,12 @@ import { rectIntersectsAnyTrace } from "lib/solvers/NetLabelPlacementSolver/Sing
 import { ChipObstacleSpatialIndex } from "lib/data-structures/ChipObstacleSpatialIndex"
 import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
 import { getColorFromString } from "lib/utils/getColorFromString"
+import { rectIntersectsAnyTextBox } from "lib/utils/textBoxBounds"
 
 type CandidateStatus =
   | "ok"
   | "chip-collision"
+  | "text-collision"
   | "trace-collision"
   | "label-collision"
 
@@ -37,6 +39,7 @@ const CANDIDATE_STATUS_COLOR: Record<CandidateStatus, string> = {
   "label-collision": "orange",
   "trace-collision": "darkorange",
   "chip-collision": "red",
+  "text-collision": "purple",
 }
 
 const CANDIDATE_STATUS_FILL: Record<CandidateStatus, string> = {
@@ -44,6 +47,7 @@ const CANDIDATE_STATUS_FILL: Record<CandidateStatus, string> = {
   "label-collision": "rgba(255, 160, 0, 0.2)",
   "trace-collision": "rgba(200, 80, 0, 0.2)",
   "chip-collision": "rgba(220, 0, 0, 0.15)",
+  "text-collision": "rgba(128, 0, 128, 0.15)",
 }
 
 type Candidate = {
@@ -269,6 +273,8 @@ export class NetLabelNetLabelCollisionSolver extends BaseSolver {
 
     if (this.chipIndex.getChipsInBounds(bounds).length > 0)
       return "chip-collision"
+    if (rectIntersectsAnyTextBox(bounds, this.inputProblem))
+      return "text-collision"
 
     if (
       rectIntersectsAnyTrace(bounds, this.traceMap, hostPairId, hostSegIndex)