@tscircuit/schematic-trace-solver 0.0.54 → 0.0.56

package/dist/index.d.ts

@@ -56,6 +56,7 @@ type FacingDirection = "x+" | "x-" | "y+" | "y-";
 type ChipId = string;
 type PinId = string;
 type NetId = string;
+type SectionId = string;
 interface InputPin {
     pinId: PinId;
     x: number;
@@ -71,6 +72,7 @@ interface InputChip {
     width: number;
     height: number;
     pins: Array<InputPin>;
+    sectionId?: SectionId;
 }
 interface InputDirectConnection {
     pinIds: [PinId, PinId];
@@ -818,6 +820,32 @@ declare class TraceAnchoredNetLabelOverlapSolver extends BaseSolver {
     visualize(): GraphicsObject;
 }
 
+interface NetLabelTraceCollisionSolverParams {
+    inputProblem: InputProblem;
+    traces: SolvedTracePath[];
+    netLabelPlacements: NetLabelPlacement[];
+}
+declare class NetLabelTraceCollisionSolver extends BaseSolver {
+    inputProblem: InputProblem;
+    traces: SolvedTracePath[];
+    netLabelPlacements: NetLabelPlacement[];
+    outputTraces: SolvedTracePath[];
+    outputNetLabelPlacements: NetLabelPlacement[];
+    activeSubSolver: SingleOverlapSolver | null;
+    private recentlyFailed;
+    private detourCounts;
+    private currentOverlap;
+    constructor(params: NetLabelTraceCollisionSolverParams);
+    getConstructorParams(): ConstructorParameters<typeof NetLabelTraceCollisionSolver>[0];
+    _step(): void;
+    getOutput(): {
+        traces: SolvedTracePath[];
+        netLabelPlacements: NetLabelPlacement[];
+    };
+    private getOverlapKey;
+    visualize(): GraphicsObject;
+}
+
 /**
  * Pipeline solver that runs a series of solvers to find the best schematic layout.
  * Coordinates the entire layout process from chip partitioning through final packing.
@@ -847,12 +875,13 @@ declare class SchematicTracePipelineSolver extends BaseSolver {
     availableNetOrientationSolver?: AvailableNetOrientationSolver;
     vccNetLabelCornerPlacementSolver?: VccNetLabelCornerPlacementSolver;
     traceAnchoredNetLabelOverlapSolver?: TraceAnchoredNetLabelOverlapSolver;
+    netLabelTraceCollisionSolver?: NetLabelTraceCollisionSolver;
     startTimeOfPhase: Record<string, number>;
     endTimeOfPhase: Record<string, number>;
     timeSpentOnPhase: Record<string, number>;
     firstIterationOfPhase: Record<string, number>;
     inputProblem: InputProblem;
-    pipelineDef: (PipelineStep<typeof MspConnectionPairSolver> | PipelineStep<typeof SchematicTraceLinesSolver> | PipelineStep<typeof LongDistancePairSolver> | PipelineStep<typeof TraceOverlapShiftSolver> | PipelineStep<typeof NetLabelPlacementSolver> | PipelineStep<typeof TraceLabelOverlapAvoidanceSolver> | PipelineStep<typeof TraceCleanupSolver> | PipelineStep<typeof Example28Solver> | PipelineStep<typeof AvailableNetOrientationSolver> | PipelineStep<typeof VccNetLabelCornerPlacementSolver> | PipelineStep<typeof TraceAnchoredNetLabelOverlapSolver>)[];
+    pipelineDef: (PipelineStep<typeof MspConnectionPairSolver> | PipelineStep<typeof SchematicTraceLinesSolver> | PipelineStep<typeof LongDistancePairSolver> | PipelineStep<typeof TraceOverlapShiftSolver> | PipelineStep<typeof NetLabelPlacementSolver> | PipelineStep<typeof TraceLabelOverlapAvoidanceSolver> | PipelineStep<typeof TraceCleanupSolver> | PipelineStep<typeof Example28Solver> | PipelineStep<typeof AvailableNetOrientationSolver> | PipelineStep<typeof VccNetLabelCornerPlacementSolver> | PipelineStep<typeof TraceAnchoredNetLabelOverlapSolver> | PipelineStep<typeof NetLabelTraceCollisionSolver>)[];
     constructor(inputProblem: InputProblem);
     getConstructorParams(): ConstructorParameters<typeof SchematicTracePipelineSolver>[0];
     currentPipelineStepIndex: number;
@@ -868,4 +897,4 @@ declare class SchematicTracePipelineSolver extends BaseSolver {
     preview(): GraphicsObject;
 }
 
-export { type ChipId, type InputChip, type InputDirectConnection, type InputNetConnection, type InputPin, type InputProblem, type NetId, type PinId, SchematicTracePipelineSolver, type SchematicTracePipelineSolverParams, SchematicTraceSingleLineSolver2 };
+export { type ChipId, type InputChip, type InputDirectConnection, type InputNetConnection, type InputPin, type InputProblem, type NetId, type PinId, SchematicTracePipelineSolver, type SchematicTracePipelineSolverParams, SchematicTraceSingleLineSolver2, type SectionId };

package/dist/index.js

@@ -301,6 +301,30 @@ var getColorFromString = (string, alpha = 1) => {
   return `hsl(${hash % 360}, 100%, 50%, ${alpha})`;
 };
 
+// lib/utils/arePinsInDifferentSchematicSections.ts
+var getSectionNameForPin = (sectionByChipId, sectionByPinId, pin) => {
+  if (pin.chipId) {
+    const chipSection = sectionByChipId.get(pin.chipId);
+    if (chipSection) return chipSection;
+  }
+  return sectionByPinId.get(pin.pinId);
+};
+var arePinsInDifferentSchematicSections = (inputProblem, p1, p2) => {
+  const sectionByChipId = /* @__PURE__ */ new Map();
+  const sectionByPinId = /* @__PURE__ */ new Map();
+  for (const chip of inputProblem.chips) {
+    if (!chip.sectionId) continue;
+    sectionByChipId.set(chip.chipId, chip.sectionId);
+    for (const pin of chip.pins) {
+      sectionByPinId.set(pin.pinId, chip.sectionId);
+    }
+  }
+  if (sectionByChipId.size === 0) return false;
+  const s1 = getSectionNameForPin(sectionByChipId, sectionByPinId, p1);
+  const s2 = getSectionNameForPin(sectionByChipId, sectionByPinId, p2);
+  return !!s1 && !!s2 && s1 !== s2;
+};
+
 // lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem.ts
 var visualizeInputProblem = (inputProblem, opts = {}) => {
   const { connectionAlpha = 0.8, chipAlpha = 0.8 } = opts;
@@ -337,6 +361,9 @@ ${pin._facingDirection ?? getPinDirection(pin, chip)}`,
     const [pinId1, pinId2] = directConn.pinIds;
     const pin1 = pinIdMap.get(pinId1);
     const pin2 = pinIdMap.get(pinId2);
+    if (arePinsInDifferentSchematicSections(inputProblem, pin1, pin2)) {
+      continue;
+    }
     graphics.lines.push({
       points: [
         {
@@ -360,6 +387,9 @@ ${pin._facingDirection ?? getPinDirection(pin, chip)}`,
       for (let j = i + 1; j < pins.length; j++) {
         const pin1 = pins[i];
         const pin2 = pins[j];
+        if (arePinsInDifferentSchematicSections(inputProblem, pin1, pin2)) {
+          continue;
+        }
         graphics.lines.push({
           points: [
             { x: pin1.x, y: pin1.y },
@@ -441,6 +471,9 @@ var MspConnectionPairSolver = class extends BaseSolver {
       if (manhattanDist > this.maxMspPairDistance) {
         return;
       }
+      if (arePinsInDifferentSchematicSections(this.inputProblem, p1, p2)) {
+        return;
+      }
       const pinIdMap2 = new Map(Object.entries(this.pinMap));
       if (doesPairCrossRestrictedCenterLines({
         inputProblem: this.inputProblem,
@@ -467,7 +500,11 @@ var MspConnectionPairSolver = class extends BaseSolver {
       directlyConnectedPins.map((p) => this.pinMap[p]).filter(Boolean),
       {
         maxDistance: this.maxMspPairDistance,
-        forbidEdge: (a, b) => doesPairCrossRestrictedCenterLines({
+        forbidEdge: (a, b) => arePinsInDifferentSchematicSections(
+          this.inputProblem,
+          a,
+          b
+        ) || doesPairCrossRestrictedCenterLines({
           inputProblem: this.inputProblem,
           chipMap: this.chipMap,
           pinIdMap,
@@ -479,6 +516,9 @@ var MspConnectionPairSolver = class extends BaseSolver {
     for (const [pin1, pin2] of msp) {
       const p1Obj = this.pinMap[pin1];
       const p2Obj = this.pinMap[pin2];
+      if (arePinsInDifferentSchematicSections(this.inputProblem, p1Obj, p2Obj)) {
+        continue;
+      }
       if (doesPairCrossRestrictedCenterLines({
         inputProblem: this.inputProblem,
         chipMap: this.chipMap,
@@ -3461,6 +3501,9 @@ var LongDistancePairSolver = class extends BaseSolver {
         }).sort((a, b) => a.distance - b.distance).slice(0, NEAREST_NEIGHBOR_COUNT);
         for (const neighbor of neighbors) {
           const pair = [sourcePin, neighbor.pin];
+          if (arePinsInDifferentSchematicSections(inputProblem, pair[0], pair[1])) {
+            continue;
+          }
           const pairKey = pair.map((p) => p.pinId).sort().join("--");
           if (!addedPairKeys.has(pairKey)) {
             candidatePairs.push(pair);
@@ -3559,7 +3602,10 @@ var LongDistancePairSolver = class extends BaseSolver {
   }
   getOutput() {
     if (!this.solved) {
-      return { newTraces: [], allTracesMerged: this.params.alreadySolvedTraces };
+      return {
+        newTraces: [],
+        allTracesMerged: this.params.alreadySolvedTraces
+      };
     }
     return {
       newTraces: this.solvedLongDistanceTraces,
@@ -7104,6 +7150,214 @@ var TraceAnchoredNetLabelOverlapSolver = class extends BaseSolver {
   }
 };
 
+// lib/solvers/NetLabelTraceCollisionSolver/NetLabelTraceCollisionSolver.ts
+function buildMergedObstacleLabel(seedLabel, allLabels) {
+  const TOUCH_MARGIN = 0.01;
+  const getBounds3 = (l) => getRectBounds(l.center, l.width, l.height);
+  const touches = (a, b) => {
+    const ba = getBounds3(a);
+    const bb = getBounds3(b);
+    return ba.minX <= bb.maxX + TOUCH_MARGIN && ba.maxX >= bb.minX - TOUCH_MARGIN && ba.minY <= bb.maxY + TOUCH_MARGIN && ba.maxY >= bb.minY - TOUCH_MARGIN;
+  };
+  const group = /* @__PURE__ */ new Set([seedLabel]);
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const l of allLabels) {
+      if (group.has(l)) continue;
+      if ([...group].some((g) => touches(g, l))) {
+        group.add(l);
+        changed = true;
+      }
+    }
+  }
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const l of group) {
+    const b = getBounds3(l);
+    if (b.minX < minX) minX = b.minX;
+    if (b.minY < minY) minY = b.minY;
+    if (b.maxX > maxX) maxX = b.maxX;
+    if (b.maxY > maxY) maxY = b.maxY;
+  }
+  const cx = (minX + maxX) / 2;
+  const cy = (minY + maxY) / 2;
+  const w = maxX - minX;
+  const h = maxY - minY;
+  return {
+    ...seedLabel,
+    center: { x: cx, y: cy },
+    width: w,
+    height: h
+  };
+}
+function detectInnerTraceLabelOverlaps(traces, labels) {
+  const overlaps = [];
+  for (const trace of traces) {
+    for (const label of labels) {
+      if (trace.globalConnNetId === label.globalConnNetId) continue;
+      const bounds = getRectBounds(label.center, label.width, label.height);
+      const path = trace.tracePath;
+      const innerStart = 1;
+      const innerEnd = path.length - 2;
+      for (let i = innerStart; i < innerEnd; i++) {
+        if (segmentIntersectsRect2(path[i], path[i + 1], bounds)) {
+          overlaps.push({ trace, label });
+          break;
+        }
+      }
+    }
+  }
+  return overlaps;
+}
+var PADDING_BUFFER = 0.1;
+var MAX_DETOUR_ATTEMPTS = 3;
+var NetLabelTraceCollisionSolver = class extends BaseSolver {
+  inputProblem;
+  traces;
+  netLabelPlacements;
+  outputTraces;
+  outputNetLabelPlacements;
+  activeSubSolver = null;
+  recentlyFailed = /* @__PURE__ */ new Set();
+  detourCounts = /* @__PURE__ */ new Map();
+  currentOverlap = null;
+  constructor(params) {
+    super();
+    this.inputProblem = params.inputProblem;
+    this.traces = params.traces;
+    this.netLabelPlacements = params.netLabelPlacements;
+    this.outputTraces = [...params.traces];
+    this.outputNetLabelPlacements = [...params.netLabelPlacements];
+  }
+  getConstructorParams() {
+    return {
+      inputProblem: this.inputProblem,
+      traces: this.traces,
+      netLabelPlacements: this.netLabelPlacements
+    };
+  }
+  _step() {
+    if (this.activeSubSolver) {
+      this.activeSubSolver.step();
+      if (this.activeSubSolver.solved) {
+        const solvedPath = this.activeSubSolver.solvedTracePath;
+        if (solvedPath) {
+          const idx = this.outputTraces.findIndex(
+            (t) => t.mspPairId === this.activeSubSolver.initialTrace.mspPairId
+          );
+          if (idx !== -1) {
+            this.outputTraces[idx] = {
+              ...this.outputTraces[idx],
+              tracePath: solvedPath
+            };
+          }
+        }
+        this.activeSubSolver = null;
+        this.currentOverlap = null;
+      } else if (this.activeSubSolver.failed) {
+        const key = this.getOverlapKey(
+          this.activeSubSolver.initialTrace,
+          this.activeSubSolver.label
+        );
+        this.recentlyFailed.add(key);
+        this.activeSubSolver = null;
+        this.currentOverlap = null;
+      }
+      return;
+    }
+    const overlaps = detectInnerTraceLabelOverlaps(
+      this.outputTraces,
+      this.outputNetLabelPlacements
+    );
+    const actionable = overlaps.filter((o) => {
+      const key = this.getOverlapKey(o.trace, o.label);
+      return !this.recentlyFailed.has(key);
+    });
+    if (actionable.length === 0) {
+      this.solved = true;
+      return;
+    }
+    const next = actionable[0];
+    const traceToFix = this.outputTraces.find(
+      (t) => t.mspPairId === next.trace.mspPairId
+    );
+    this.currentOverlap = next;
+    const mergedLabel = buildMergedObstacleLabel(
+      next.label,
+      this.outputNetLabelPlacements.filter(
+        (l) => l.globalConnNetId !== traceToFix.globalConnNetId
+      )
+    );
+    const mergeKey = `${next.trace.mspPairId}::merged::${mergedLabel.center.x},${mergedLabel.center.y},${mergedLabel.width},${mergedLabel.height}`;
+    const detourCount = this.detourCounts.get(mergeKey) ?? 0;
+    if (detourCount >= MAX_DETOUR_ATTEMPTS) {
+      this.recentlyFailed.add(this.getOverlapKey(next.trace, next.label));
+      this.currentOverlap = null;
+      return;
+    }
+    this.detourCounts.set(mergeKey, detourCount + 1);
+    this.activeSubSolver = new SingleOverlapSolver({
+      trace: traceToFix,
+      label: mergedLabel,
+      problem: this.inputProblem,
+      paddingBuffer: PADDING_BUFFER,
+      detourCount
+    });
+  }
+  getOutput() {
+    return {
+      traces: this.outputTraces,
+      netLabelPlacements: this.outputNetLabelPlacements
+    };
+  }
+  getOverlapKey(trace, label) {
+    return `${trace.mspPairId}::${label.globalConnNetId}`;
+  }
+  visualize() {
+    if (this.activeSubSolver) return this.activeSubSolver.visualize();
+    const graphics = visualizeInputProblem(this.inputProblem);
+    if (!graphics.lines) graphics.lines = [];
+    if (!graphics.rects) graphics.rects = [];
+    if (!graphics.points) graphics.points = [];
+    for (const trace of this.outputTraces) {
+      graphics.lines.push({
+        points: trace.tracePath,
+        strokeColor: "purple"
+      });
+    }
+    for (const label of this.outputNetLabelPlacements) {
+      graphics.rects.push({
+        center: label.center,
+        width: label.width,
+        height: label.height,
+        fill: getColorFromString(label.globalConnNetId, 0.35),
+        strokeColor: getColorFromString(label.globalConnNetId, 0.9),
+        label: `netId: ${label.netId}
+globalConnNetId: ${label.globalConnNetId}`
+      });
+      graphics.points.push({
+        x: label.anchorPoint.x,
+        y: label.anchorPoint.y,
+        color: getColorFromString(label.globalConnNetId, 0.9)
+      });
+    }
+    if (this.currentOverlap) {
+      graphics.lines.push({
+        points: this.currentOverlap.trace.tracePath,
+        strokeColor: "red"
+      });
+      graphics.rects.push({
+        center: this.currentOverlap.label.center,
+        width: this.currentOverlap.label.width,
+        height: this.currentOverlap.label.height,
+        fill: "rgba(255,0,0,0.3)",
+        strokeColor: "red"
+      });
+    }
+    return graphics;
+  }
+};
+
 // lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts
 function definePipelineStep(solverName, solverClass, getConstructorParams, opts = {}) {
   return {
@@ -7128,6 +7382,7 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
   availableNetOrientationSolver;
   vccNetLabelCornerPlacementSolver;
   traceAnchoredNetLabelOverlapSolver;
+  netLabelTraceCollisionSolver;
   startTimeOfPhase;
   endTimeOfPhase;
   timeSpentOnPhase;
@@ -7308,6 +7563,17 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
           netLabelPlacements: instance.vccNetLabelCornerPlacementSolver.outputNetLabelPlacements
         }
       ]
+    ),
+    definePipelineStep(
+      "netLabelTraceCollisionSolver",
+      NetLabelTraceCollisionSolver,
+      (instance) => [
+        {
+          inputProblem: instance.inputProblem,
+          traces: instance.availableNetOrientationSolver.traces,
+          netLabelPlacements: instance.traceAnchoredNetLabelOverlapSolver.outputNetLabelPlacements
+        }
+      ]
     )
   ];
   constructor(inputProblem) {

package/lib/solvers/LongDistancePairSolver/LongDistancePairSolver.ts

@@ -12,6 +12,7 @@ import { doesTraceOverlapWithExistingTraces } from "lib/utils/does-trace-overlap
 import { visualizeInputProblem } from "../SchematicTracePipelineSolver/visualizeInputProblem"
 import type { SolvedTracePath } from "../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
 import type { ConnectivityMap } from "connectivity-map"
+import { arePinsInDifferentSchematicSections } from "../../utils/arePinsInDifferentSchematicSections"
 
 const NEAREST_NEIGHBOR_COUNT = 3
 
@@ -104,6 +105,11 @@ export class LongDistancePairSolver extends BaseSolver {
             InputPin & { chipId: string },
             InputPin & { chipId: string },
           ] = [sourcePin, neighbor.pin]
+          if (
+            arePinsInDifferentSchematicSections(inputProblem, pair[0], pair[1])
+          ) {
+            continue
+          }
           const pairKey = pair
             .map((p) => p.pinId)
             .sort()
@@ -225,7 +231,10 @@ export class LongDistancePairSolver extends BaseSolver {
     allTracesMerged: SolvedTracePath[]
   } {
     if (!this.solved) {
-      return { newTraces: [], allTracesMerged: this.params.alreadySolvedTraces }
+      return {
+        newTraces: [],
+        allTracesMerged: this.params.alreadySolvedTraces,
+      }
     }
     return {
       newTraces: this.solvedLongDistanceTraces,

package/lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver.ts

@@ -12,6 +12,7 @@ import { doesPairCrossRestrictedCenterLines } from "./doesPairCrossRestrictedCen
 import type { GraphicsObject } from "graphics-debug"
 import { getColorFromString } from "lib/utils/getColorFromString"
 import { visualizeInputProblem } from "../SchematicTracePipelineSolver/visualizeInputProblem"
+import { arePinsInDifferentSchematicSections } from "../../utils/arePinsInDifferentSchematicSections"
 
 export type MspConnectionPairId = string
 
@@ -110,6 +111,9 @@ export class MspConnectionPairSolver extends BaseSolver {
         // Too far apart; skip creating an MSP pair for this net
         return
       }
+      if (arePinsInDifferentSchematicSections(this.inputProblem, p1, p2)) {
+        return
+      }
       // Avoid pairs that would cross restricted center lines
       const pinIdMap = new Map(Object.entries(this.pinMap)) as Map<
         PinId,
@@ -153,6 +157,11 @@ export class MspConnectionPairSolver extends BaseSolver {
       {
         maxDistance: this.maxMspPairDistance,
         forbidEdge: (a, b) =>
+          arePinsInDifferentSchematicSections(
+            this.inputProblem,
+            a as InputPin & { chipId: string },
+            b as InputPin & { chipId: string },
+          ) ||
           doesPairCrossRestrictedCenterLines({
             inputProblem: this.inputProblem,
             chipMap: this.chipMap,
@@ -166,6 +175,11 @@ export class MspConnectionPairSolver extends BaseSolver {
     for (const [pin1, pin2] of msp) {
       const p1Obj = this.pinMap[pin1!]!
       const p2Obj = this.pinMap[pin2!]!
+      if (
+        arePinsInDifferentSchematicSections(this.inputProblem, p1Obj, p2Obj)
+      ) {
+        continue
+      }
       // Skip any edge that would cross a restricted center line (safety filter)
       if (
         doesPairCrossRestrictedCenterLines({