@tscircuit/schematic-trace-solver 0.0.52 → 0.0.54

package/dist/index.d.ts

@@ -691,11 +691,8 @@ declare class AvailableNetOrientationSolver extends BaseSolver {
     private getSearchDistanceLimit;
     private createCandidate;
     private getNetLabelWidth;
-    private isLabelPlacementValid;
-    private isCandidateValidWithOffset;
     private getCandidateStatus;
     private getBoundsStatus;
-    private getOffsetCollisionBounds;
     private intersectsAnyOtherNetLabel;
     private sharesChipBoundary;
     private getChipSideForPoint;

package/dist/index.js

@@ -2273,6 +2273,44 @@ orientation: ${p.orientation}`
   }
 };
 
+// lib/solvers/SchematicTracePipelineSolver/colorAvailableNetOrientationLabels.ts
+var AVAILABLE_Y_PLUS_COLOR = "#ef4444";
+var AVAILABLE_Y_MINUS_COLOR = "#000000";
+var AVAILABLE_ORIENTATION_FILL_ALPHA = "66";
+var colorAvailableNetOrientationLabels = (graphicsObject, inputProblem) => {
+  const availableOrientations = inputProblem.availableNetLabelOrientations;
+  if (!availableOrientations) return;
+  for (const rect of graphicsObject.rects ?? []) {
+    const orientations = getAvailableOrientationsForRect(
+      rect.label,
+      availableOrientations
+    );
+    if (!orientations) continue;
+    const hasYPlus = orientations.includes("y+");
+    const hasYMinus = orientations.includes("y-");
+    if (hasYPlus === hasYMinus) continue;
+    const color = hasYPlus ? AVAILABLE_Y_PLUS_COLOR : AVAILABLE_Y_MINUS_COLOR;
+    rect.fill = `${color}${AVAILABLE_ORIENTATION_FILL_ALPHA}`;
+    rect.stroke = color;
+    rect.color = color;
+  }
+};
+var getAvailableOrientationsForRect = (label, availableOrientations) => {
+  for (const netId of getNetIdsFromRectLabel(label)) {
+    if (Object.hasOwn(availableOrientations, netId)) {
+      return availableOrientations[netId];
+    }
+  }
+  return void 0;
+};
+var getNetIdsFromRectLabel = (label) => {
+  if (!label) return [];
+  return [
+    label.match(/^netId: (.+)$/m)?.[1],
+    label.match(/^globalConnNetId: (.+)$/m)?.[1]
+  ].filter((netId) => Boolean(netId && netId !== "undefined"));
+};
+
 // lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/LabelMergingSolver/groupLabelsByChipAndOrientation.ts
 var groupLabelsByChipAndOrientation = ({
   labels,
@@ -5641,16 +5679,15 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
   getProcessableLabelIndices() {
     const indices = [];
     for (let i = 0; i < this.outputNetLabelPlacements.length; i++) {
-      if (this.shouldProcessLabel(this.outputNetLabelPlacements[i], i)) {
+      if (this.shouldProcessLabel(this.outputNetLabelPlacements[i])) {
         indices.push(i);
       }
     }
     return indices;
   }
-  shouldProcessLabel(label, labelIndex) {
+  shouldProcessLabel(label) {
     const orientations = this.getAvailableOrientations(label);
-    if (orientations.length === 0) return false;
-    return !(orientations.includes(label.orientation) && this.isLabelPlacementValid(label, labelIndex));
+    return orientations.length > 0 && !orientations.includes(label.orientation);
   }
   processLabel(labelIndex) {
     const label = this.outputNetLabelPlacements[labelIndex];
@@ -5879,22 +5916,6 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       (connection) => connection.netId === label.netId
     )?.netLabelWidth;
   }
-  isLabelPlacementValid(label, labelIndex) {
-    return this.isCandidateValidWithOffset(
-      {
-        orientation: label.orientation,
-        anchorPoint: label.anchorPoint,
-        center: label.center,
-        width: label.width,
-        height: label.height
-      },
-      labelIndex
-    );
-  }
-  isCandidateValidWithOffset(candidate, labelIndex) {
-    const bounds = this.getOffsetCollisionBounds(candidate);
-    return this.getBoundsStatus(bounds, labelIndex) === "valid";
-  }
   getCandidateStatus(candidate, label, labelIndex) {
     const boundsStatus = this.getBoundsStatus(
       getRectBounds(candidate.center, candidate.width, candidate.height),
@@ -5928,15 +5949,6 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     }
     return "valid";
   }
-  getOffsetCollisionBounds(candidate) {
-    const direction = dir(candidate.orientation);
-    const collisionTestOffset = 1e-4;
-    const testCenter = {
-      x: candidate.center.x + direction.x * collisionTestOffset,
-      y: candidate.center.y + direction.y * collisionTestOffset
-    };
-    return getRectBounds(testCenter, candidate.width, candidate.height);
-  }
   intersectsAnyOtherNetLabel(bounds, labelIndex) {
     for (let i = 0; i < this.outputNetLabelPlacements.length; i++) {
       if (i === labelIndex) continue;
@@ -6367,6 +6379,7 @@ var EPS8 = 1e-6;
 var TRACE_BOUNDARY_TOLERANCE2 = 1e-6;
 var getLabelBounds = (label) => getRectBounds(label.center, label.width, label.height);
 var rectsOverlap3 = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) > EPS8 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) > EPS8;
+var rectsTouchOrOverlap = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) >= -EPS8 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) >= -EPS8;
 var traceCrossesBoundsInterior2 = (bounds, traces) => {
   for (const trace of traces) {
     const points = trace.tracePath;
@@ -6439,41 +6452,7 @@ var getTraceVertexDistances = (trace) => {
   }
   return distances;
 };
-var getTraceDistanceCompatibleOrientations = (trace, distance3) => {
-  const orientations = /* @__PURE__ */ new Set();
-  let pathDistance = 0;
-  for (let i = 0; i < trace.tracePath.length - 1; i++) {
-    const start = trace.tracePath[i];
-    const end = trace.tracePath[i + 1];
-    const segmentLength = getManhattanDistance(start, end);
-    const nextDistance = pathDistance + segmentLength;
-    if (distance3 >= pathDistance - EPS8 && distance3 <= nextDistance + EPS8) {
-      addSegmentCompatibleOrientations(orientations, trace, i);
-      if (Math.abs(distance3 - pathDistance) <= EPS8) {
-        addSegmentCompatibleOrientations(orientations, trace, i - 1);
-      }
-      if (Math.abs(distance3 - nextDistance) <= EPS8) {
-        addSegmentCompatibleOrientations(orientations, trace, i + 1);
-      }
-      return orientations;
-    }
-    pathDistance = nextDistance;
-  }
-  return orientations;
-};
 var getManhattanDistance = (a, b) => Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
-var addSegmentCompatibleOrientations = (orientations, trace, segmentIndex) => {
-  const start = trace.tracePath[segmentIndex];
-  const end = trace.tracePath[segmentIndex + 1];
-  if (!start || !end) return;
-  if (isHorizontal2(start, end)) {
-    orientations.add("y+");
-    orientations.add("y-");
-  } else if (isVertical3(start, end)) {
-    orientations.add("x+");
-    orientations.add("x-");
-  }
-};
 var segmentCrossesBoundsInterior2 = (start, end, bounds) => {
   const interior = {
     minX: bounds.minX + TRACE_BOUNDARY_TOLERANCE2,
@@ -6533,25 +6512,18 @@ var generateCandidatesAlongTrace = (params) => {
   const traceLength = getTraceLength(traceLocation.trace);
   const orientationConstraint = getOrientationConstraint(inputProblem, label);
   const candidateDistances = getCandidateDistances(
-    traceLocation,
     traceLength,
-    getTraceVertexDistances(traceLocation.trace),
-    orientationConstraint
+    getTraceVertexDistances(traceLocation.trace)
   );
   const netLabelWidth = getNetLabelWidth(inputProblem, label);
   const candidates = [];
   const seenCandidateKeys = /* @__PURE__ */ new Set();
   for (const pathDistance of candidateDistances) {
     const point = getPointAtTraceDistance(traceLocation.trace, pathDistance);
-    const compatibleOrientations = getTraceDistanceCompatibleOrientations(
-      traceLocation.trace,
-      pathDistance
-    );
     const orientations = getOrientationsForPoint({
       inputProblem,
       label,
       point,
-      compatibleOrientations,
       orientationConstraint
     });
     for (const orientation of orientations) {
@@ -6573,11 +6545,9 @@ var generateCandidatesAlongTrace = (params) => {
       );
     }
   }
-  return candidates.sort(
-    (a, b) => a.distanceFromOriginal - b.distanceFromOriginal || a.pathDistance - b.pathDistance
-  );
+  return candidates;
 };
-var getCandidateDistances = (traceLocation, traceLength, vertexDistances, orientationConstraint) => {
+var getCandidateDistances = (traceLength, vertexDistances) => {
   const distances = /* @__PURE__ */ new Set();
   const maxSteps = Math.ceil(traceLength / CANDIDATE_STEP);
   for (let i = 0; i <= maxSteps; i++) {
@@ -6587,35 +6557,17 @@ var getCandidateDistances = (traceLocation, traceLength, vertexDistances, orient
   for (const distance3 of vertexDistances) {
     distances.add(roundDistance(distance3));
   }
-  distances.add(roundDistance(traceLocation.distance));
-  return [...distances].filter((distance3) => distance3 >= -EPS8 && distance3 <= traceLength + EPS8).filter(
-    (distance3) => isDistanceAllowedByOrientationConstraint(
-      traceLocation,
-      distance3,
-      orientationConstraint
-    )
-  ).sort(
-    (a, b) => Math.abs(a - traceLocation.distance) - Math.abs(b - traceLocation.distance) || a - b
-  );
+  return [...distances].filter((distance3) => distance3 >= -EPS8 && distance3 <= traceLength + EPS8).sort((a, b) => a - b);
 };
 var getOrientationsForPoint = (params) => {
-  const {
-    inputProblem,
-    label,
-    point,
-    compatibleOrientations,
-    orientationConstraint
-  } = params;
+  const { inputProblem, label, point, orientationConstraint } = params;
   if (orientationConstraint) {
-    return orientationConstraint.filter(
-      (orientation) => compatibleOrientations.has(orientation)
-    );
+    return orientationConstraint;
   }
   return getUnconstrainedOrientations({
     label,
     inputProblem,
-    point,
-    compatibleOrientations
+    point
   });
 };
 var createCandidate = (params) => {
@@ -6645,23 +6597,18 @@ var createCandidate = (params) => {
   };
 };
 var getOrientationConstraint = (inputProblem, label) => {
+  const availableOrientations = inputProblem.availableNetLabelOrientations ?? {};
   for (const netId of getOrientationConstraintKeys(inputProblem, label)) {
-    if (Object.hasOwn(inputProblem.availableNetLabelOrientations, netId)) {
-      return inputProblem.availableNetLabelOrientations[netId] ?? [];
+    if (Object.hasOwn(availableOrientations, netId)) {
+      return dedupeOrientations(
+        (availableOrientations[netId] ?? []).map(normalizeFacingDirection).filter(
+          (orientation) => orientation !== void 0
+        )
+      );
     }
   }
   return null;
 };
-var isDistanceAllowedByOrientationConstraint = (traceLocation, distance3, constrainedOrientations) => {
-  if (!constrainedOrientations) return true;
-  const compatibleOrientations = getTraceDistanceCompatibleOrientations(
-    traceLocation.trace,
-    distance3
-  );
-  return constrainedOrientations.some(
-    (orientation) => compatibleOrientations.has(orientation)
-  );
-};
 var getOrientationConstraintKeys = (inputProblem, label) => dedupeStrings([
   label.netId,
   label.globalConnNetId,
@@ -6670,55 +6617,49 @@ var getOrientationConstraintKeys = (inputProblem, label) => dedupeStrings([
   ).map((connection) => connection.netId)
 ]);
 var getUnconstrainedOrientations = (params) => {
-  const { label, inputProblem, point, compatibleOrientations } = params;
+  const { label, inputProblem, point } = params;
   return dedupeOrientations([
-    ...getInitialOrientations(label, compatibleOrientations),
+    ...getInitialOrientations(label),
     ...getOutwardOrientations({
       inputProblem,
-      point,
-      compatibleOrientations
+      point
     }),
-    ...ALL_ORIENTATIONS.filter(
-      (orientation) => compatibleOrientations.has(orientation)
-    )
+    ...ALL_ORIENTATIONS
   ]);
 };
-var getInitialOrientations = (label, compatibleOrientations) => [label.orientation, getFlippedOrientation(label.orientation)].filter(
-  (orientation) => compatibleOrientations.has(orientation)
-);
+var getInitialOrientations = (label) => [
+  label.orientation,
+  getFlippedOrientation(label.orientation)
+];
 var getOutwardOrientations = (params) => {
-  const { inputProblem, point, compatibleOrientations } = params;
+  const { inputProblem, point } = params;
   const chipBounds = getChipBounds(inputProblem);
   return dedupeOrientations(
-    getOutwardOrientationOptions(point, chipBounds, compatibleOrientations).filter(({ orientation }) => compatibleOrientations.has(orientation)).sort((a, b) => b.outwardScore - a.outwardScore).map(({ orientation }) => orientation)
+    getOutwardOrientationOptions(point, chipBounds).sort((a, b) => b.outwardScore - a.outwardScore).map(({ orientation }) => orientation)
   );
 };
-var getOutwardOrientationOptions = (point, chipBounds, compatibleOrientations) => {
+var getOutwardOrientationOptions = (point, chipBounds) => {
   const options = [];
-  if (compatibleOrientations.has("y+") || compatibleOrientations.has("y-")) {
-    options.push(
-      getOutwardAxisOption({
-        value: point.y,
-        min: chipBounds.minY,
-        max: chipBounds.maxY,
-        center: chipBounds.centerY,
-        positiveOrientation: "y+",
-        negativeOrientation: "y-"
-      })
-    );
-  }
-  if (compatibleOrientations.has("x+") || compatibleOrientations.has("x-")) {
-    options.push(
-      getOutwardAxisOption({
-        value: point.x,
-        min: chipBounds.minX,
-        max: chipBounds.maxX,
-        center: chipBounds.centerX,
-        positiveOrientation: "x+",
-        negativeOrientation: "x-"
-      })
-    );
-  }
+  options.push(
+    getOutwardAxisOption({
+      value: point.y,
+      min: chipBounds.minY,
+      max: chipBounds.maxY,
+      center: chipBounds.centerY,
+      positiveOrientation: "y+",
+      negativeOrientation: "y-"
+    })
+  );
+  options.push(
+    getOutwardAxisOption({
+      value: point.x,
+      min: chipBounds.minX,
+      max: chipBounds.maxX,
+      center: chipBounds.centerX,
+      positiveOrientation: "x+",
+      negativeOrientation: "x-"
+    })
+  );
   return options;
 };
 var getOutwardAxisOption = (params) => {
@@ -6796,6 +6737,22 @@ var roundDistance = (distance3) => Number(distance3.toFixed(6));
 var dedupeOrientations = (orientations) => [
   ...new Set(orientations)
 ];
+var normalizeFacingDirection = (value) => {
+  switch (value) {
+    case "x+":
+    case "+x":
+      return "x+";
+    case "x-":
+    case "-x":
+      return "x-";
+    case "y+":
+    case "+y":
+      return "y+";
+    case "y-":
+    case "-y":
+      return "y-";
+  }
+};
 var dedupeStrings = (values) => [
   ...new Set(values.filter((value) => value !== void 0))
 ];
@@ -6808,7 +6765,7 @@ var visualizeTraceAnchoredNetLabelOverlapSolver = (state) => {
   const graphics = visualizeInputProblem(state.inputProblem);
   ensureGraphicsArrays3(graphics);
   drawTraces4(graphics, state.traces);
-  drawNetLabels4(graphics, state.outputNetLabelPlacements);
+  drawNetLabels4(graphics, state.inputProblem, state.outputNetLabelPlacements);
   if (!state.solved) {
     drawCurrentOverlap2(graphics, state);
     drawCurrentCandidates4(graphics, state.currentCandidateResults);
@@ -6823,7 +6780,7 @@ var drawTraces4 = (graphics, traces) => {
     });
   }
 };
-var drawNetLabels4 = (graphics, labels) => {
+var drawNetLabels4 = (graphics, inputProblem, labels) => {
   for (const label of labels) {
     graphics.rects.push({
       center: label.center,
@@ -6831,8 +6788,7 @@ var drawNetLabels4 = (graphics, labels) => {
       height: label.height,
       fill: getColorFromString(label.globalConnNetId, 0.35),
       strokeColor: getColorFromString(label.globalConnNetId, 0.9),
-      label: `netId: ${label.netId}
-globalConnNetId: ${label.globalConnNetId}`
+      label: getNetLabelVisualizationLabel(inputProblem, label)
     });
     graphics.points.push({
       x: label.anchorPoint.x,
@@ -6858,7 +6814,8 @@ var drawCurrentOverlap2 = (graphics, state) => {
       fill: "rgba(255, 0, 0, 0.2)",
       strokeColor: CANDIDATE_REJECTED_COLOR4,
       label: `netlabel overlap target
-${label.netId ?? label.globalConnNetId}`
+${label.netId ?? label.globalConnNetId}
+${getAvailableOrientationText(state.inputProblem, label)}`
     });
   }
 };
@@ -6874,7 +6831,9 @@ var drawCurrentCandidates4 = (graphics, candidates) => {
       strokeDash: candidate.selected ? void 0 : "4 2",
       label: `${candidate.selected ? "selected" : candidate.status} netlabel overlap candidate
 trace: ${candidate.traceId}
-distance: ${candidate.distanceFromOriginal.toFixed(3)}`
+path distance: ${candidate.pathDistance.toFixed(3)}
+orientation: ${candidate.orientation}
+distance from original: ${candidate.distanceFromOriginal.toFixed(3)}`
     });
     graphics.points.push({
       ...candidate.anchorPoint,
@@ -6891,6 +6850,24 @@ var ensureGraphicsArrays3 = (graphics) => {
   if (!graphics.circles) graphics.circles = [];
   if (!graphics.texts) graphics.texts = [];
 };
+var getAvailableOrientationText = (inputProblem, label) => {
+  const orientations = getAvailableOrientationsForLabel(inputProblem, label);
+  return `available orientations: ${orientations?.join(", ") ?? "any"}`;
+};
+var getNetLabelVisualizationLabel = (inputProblem, label) => [
+  `netId: ${label.netId}`,
+  `globalConnNetId: ${label.globalConnNetId}`,
+  getAvailableOrientationText(inputProblem, label)
+].join("\n");
+var getAvailableOrientationsForLabel = (inputProblem, label) => {
+  const availableOrientations = inputProblem.availableNetLabelOrientations ?? {};
+  for (const netId of [label.netId, label.globalConnNetId]) {
+    if (netId && Object.hasOwn(availableOrientations, netId)) {
+      return availableOrientations[netId];
+    }
+  }
+  return void 0;
+};
 
 // lib/solvers/TraceAnchoredNetLabelOverlapSolver/TraceAnchoredNetLabelOverlapSolver.ts
 var TraceAnchoredNetLabelOverlapSolver = class extends BaseSolver {
@@ -7039,9 +7016,7 @@ var TraceAnchoredNetLabelOverlapSolver = class extends BaseSolver {
         })
       );
     }
-    return candidates.sort(
-      (a, b) => a.distanceFromOriginal - b.distanceFromOriginal || a.pathDistance - b.pathDistance
-    );
+    return candidates;
   }
   getCandidateStatus(candidate, labelIndex) {
     const bounds = getLabelBounds(candidate);
@@ -7065,7 +7040,10 @@ var TraceAnchoredNetLabelOverlapSolver = class extends BaseSolver {
   }
   intersectsAnyChip(bounds) {
     return this.inputProblem.chips.some(
-      (chip) => rectsOverlap3(bounds, getRectBounds(chip.center, chip.width, chip.height))
+      (chip) => rectsTouchOrOverlap(
+        bounds,
+        getRectBounds(chip.center, chip.width, chip.height)
+      )
     );
   }
   intersectsAnyOtherLabel(bounds, labelIndex) {
@@ -7424,6 +7402,7 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
       circles: visualizations.flatMap((v) => v.circles || []),
       texts: visualizations.flatMap((v) => v.texts || [])
     };
+    colorAvailableNetOrientationLabels(finalGraphics, this.inputProblem);
     return finalGraphics;
   }
   /**

package/lib/solvers/AvailableNetOrientationSolver/AvailableNetOrientationSolver.ts

@@ -100,7 +100,7 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     const indices: number[] = []
 
     for (let i = 0; i < this.outputNetLabelPlacements.length; i++) {
-      if (this.shouldProcessLabel(this.outputNetLabelPlacements[i]!, i)) {
+      if (this.shouldProcessLabel(this.outputNetLabelPlacements[i]!)) {
         indices.push(i)
       }
     }
@@ -108,14 +108,9 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     return indices
   }
 
-  private shouldProcessLabel(label: NetLabelPlacement, labelIndex: number) {
+  private shouldProcessLabel(label: NetLabelPlacement) {
     const orientations = this.getAvailableOrientations(label)
-    if (orientations.length === 0) return false
-
-    return !(
-      orientations.includes(label.orientation) &&
-      this.isLabelPlacementValid(label, labelIndex)
-    )
+    return orientations.length > 0 && !orientations.includes(label.orientation)
   }
 
   private processLabel(labelIndex: number) {
@@ -441,27 +436,6 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     )?.netLabelWidth
   }
 
-  private isLabelPlacementValid(label: NetLabelPlacement, labelIndex: number) {
-    return this.isCandidateValidWithOffset(
-      {
-        orientation: label.orientation,
-        anchorPoint: label.anchorPoint,
-        center: label.center,
-        width: label.width,
-        height: label.height,
-      },
-      labelIndex,
-    )
-  }
-
-  private isCandidateValidWithOffset(
-    candidate: CandidateLabel,
-    labelIndex: number,
-  ) {
-    const bounds = this.getOffsetCollisionBounds(candidate)
-    return this.getBoundsStatus(bounds, labelIndex) === "valid"
-  }
-
   private getCandidateStatus(
     candidate: CandidateLabel,
     label: NetLabelPlacement,
@@ -505,16 +479,6 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     return "valid"
   }
 
-  private getOffsetCollisionBounds(candidate: CandidateLabel) {
-    const direction = dir(candidate.orientation)
-    const collisionTestOffset = 1e-4
-    const testCenter = {
-      x: candidate.center.x + direction.x * collisionTestOffset,
-      y: candidate.center.y + direction.y * collisionTestOffset,
-    }
-    return getRectBounds(testCenter, candidate.width, candidate.height)
-  }
-
   private intersectsAnyOtherNetLabel(bounds: Bounds, labelIndex: number) {
     for (let i = 0; i < this.outputNetLabelPlacements.length; i++) {
       if (i === labelIndex) continue

package/lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts

@@ -13,6 +13,7 @@ import {
 } from "../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
 import { TraceOverlapShiftSolver } from "../TraceOverlapShiftSolver/TraceOverlapShiftSolver"
 import { NetLabelPlacementSolver } from "../NetLabelPlacementSolver/NetLabelPlacementSolver"
+import { colorAvailableNetOrientationLabels } from "./colorAvailableNetOrientationLabels"
 import { visualizeInputProblem } from "./visualizeInputProblem"
 import { TraceLabelOverlapAvoidanceSolver } from "../TraceLabelOverlapAvoidanceSolver/TraceLabelOverlapAvoidanceSolver"
 import { correctPinsInsideChips } from "./correctPinsInsideChip"
@@ -403,6 +404,7 @@ export class SchematicTracePipelineSolver extends BaseSolver {
       circles: visualizations.flatMap((v) => v.circles || []),
       texts: visualizations.flatMap((v) => v.texts || []),
     }
+    colorAvailableNetOrientationLabels(finalGraphics, this.inputProblem)
     return finalGraphics
   }
 

package/lib/solvers/SchematicTracePipelineSolver/colorAvailableNetOrientationLabels.ts

@@ -0,0 +1,54 @@
+import type { GraphicsObject } from "graphics-debug"
+import type { InputProblem } from "lib/types/InputProblem"
+
+const AVAILABLE_Y_PLUS_COLOR = "#ef4444"
+const AVAILABLE_Y_MINUS_COLOR = "#000000"
+const AVAILABLE_ORIENTATION_FILL_ALPHA = "66"
+
+export const colorAvailableNetOrientationLabels = (
+  graphicsObject: GraphicsObject,
+  inputProblem: InputProblem,
+) => {
+  const availableOrientations = inputProblem.availableNetLabelOrientations
+  if (!availableOrientations) return
+
+  for (const rect of graphicsObject.rects ?? []) {
+    const orientations = getAvailableOrientationsForRect(
+      rect.label,
+      availableOrientations,
+    )
+    if (!orientations) continue
+
+    const hasYPlus = orientations.includes("y+")
+    const hasYMinus = orientations.includes("y-")
+    if (hasYPlus === hasYMinus) continue
+
+    const color = hasYPlus ? AVAILABLE_Y_PLUS_COLOR : AVAILABLE_Y_MINUS_COLOR
+
+    rect.fill = `${color}${AVAILABLE_ORIENTATION_FILL_ALPHA}`
+    rect.stroke = color
+    rect.color = color
+  }
+}
+
+const getAvailableOrientationsForRect = (
+  label: string | undefined,
+  availableOrientations: InputProblem["availableNetLabelOrientations"],
+) => {
+  for (const netId of getNetIdsFromRectLabel(label)) {
+    if (Object.hasOwn(availableOrientations, netId)) {
+      return availableOrientations[netId]
+    }
+  }
+
+  return undefined
+}
+
+const getNetIdsFromRectLabel = (label: string | undefined) => {
+  if (!label) return []
+
+  return [
+    label.match(/^netId: (.+)$/m)?.[1],
+    label.match(/^globalConnNetId: (.+)$/m)?.[1],
+  ].filter((netId): netId is string => Boolean(netId && netId !== "undefined"))
+}

package/lib/solvers/TraceAnchoredNetLabelOverlapSolver/TraceAnchoredNetLabelOverlapSolver.ts

@@ -9,6 +9,7 @@ import {
   getLabelBounds,
   getTraceLocationsForPoint,
   rectsOverlap,
+  rectsTouchOrOverlap,
   traceCrossesBoundsInterior,
 } from "./geometry"
 import type {
@@ -217,11 +218,7 @@ export class TraceAnchoredNetLabelOverlapSolver extends BaseSolver {
       )
     }
 
-    return candidates.sort(
-      (a, b) =>
-        a.distanceFromOriginal - b.distanceFromOriginal ||
-        a.pathDistance - b.pathDistance,
-    )
+    return candidates
   }
 
   private getCandidateStatus(
@@ -256,7 +253,10 @@ export class TraceAnchoredNetLabelOverlapSolver extends BaseSolver {
 
   private intersectsAnyChip(bounds: Bounds) {
     return this.inputProblem.chips.some((chip) =>
-      rectsOverlap(bounds, getRectBounds(chip.center, chip.width, chip.height)),
+      rectsTouchOrOverlap(
+        bounds,
+        getRectBounds(chip.center, chip.width, chip.height),
+      ),
     )
   }