@tscircuit/schematic-trace-solver 0.0.82 → 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;
 }
 

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;
@@ -6725,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) {

package/lib/solvers/Example28Solver/Example28Solver.ts

@@ -1,18 +1,27 @@
 import type { GraphicsObject } from "graphics-debug"
+import {
+  getPinMap,
+  getTracePins,
+} from "lib/solvers/AvailableNetOrientationSolver/traces"
 import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
 import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
-import { getObstacleRects } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
 import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { getObstacleRects } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
 import {
   detectTraceLabelOverlap,
   type TraceLabelOverlap,
 } from "lib/solvers/TraceLabelOverlapAvoidanceSolver/detectTraceLabelOverlap"
-import type { InputProblem } from "lib/types/InputProblem"
+import type { InputPin, InputProblem } from "lib/types/InputProblem"
+import { dir } from "lib/utils/dir"
 import { moveAttachedLabelsToReroutedTrace } from "./labelMovement"
 import { findBestReroutePath } from "./reroute"
 import type { Example28SolverParams, RerouteCandidateResult } from "./types"
 import { visualizeExample28Solver } from "./visualize"
 
+const LABEL_OUTWARD_STEP = 0.1
+const LABEL_MAX_OUTWARD_STEPS = 10
+const LABEL_TRACE_CLEARANCE = 0.1
+
 export class Example28Solver extends BaseSolver {
   inputProblem: InputProblem
   traces: SolvedTracePath[]
@@ -25,6 +34,7 @@ export class Example28Solver extends BaseSolver {
   currentCandidateResults: RerouteCandidateResult[] = []
 
   private chipObstacles: ReturnType<typeof getObstacleRects>
+  private pinMap: Record<string, InputPin & { chipId: string }>
 
   constructor(params: Example28SolverParams) {
     super()
@@ -34,6 +44,7 @@ export class Example28Solver 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
   }
@@ -144,6 +155,8 @@ export class Example28Solver 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,
@@ -169,6 +182,79 @@ export class Example28Solver extends BaseSolver {
     })
   }
 
+  private tryMoveLabelOutward(labelToMove: NetLabelPlacement) {
+    const labelIndex = this.outputNetLabelPlacements.findIndex(
+      (label) =>
+        label.globalConnNetId === labelToMove.globalConnNetId &&
+        label.anchorPoint.x === labelToMove.anchorPoint.x &&
+        label.anchorPoint.y === labelToMove.anchorPoint.y &&
+        label.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 distance = step * LABEL_OUTWARD_STEP
+      const candidate = {
+        ...label,
+        anchorPoint: {
+          x: label.anchorPoint.x + outward.x * distance,
+          y: label.anchorPoint.y + outward.y * distance,
+        },
+        center: {
+          x: label.center.x + outward.x * distance,
+          y: label.center.y + outward.y * distance,
+        },
+      }
+      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
+  }
+
   override visualize(): GraphicsObject {
     return visualizeExample28Solver({
       inputProblem: this.inputProblem,
@@ -180,3 +266,29 @@ export class Example28Solver extends BaseSolver {
     })
   }
 }
+
+const getPortOnlyLabelConnectorMspPairId = (label: NetLabelPlacement) =>
+  `port-only-label-connector-${label.globalConnNetId}-${label.pinIds[0]}`
+
+const createPortOnlyLabelConnectorTrace = ({
+  label,
+  movedLabel,
+  pinMap,
+}: {
+  label: NetLabelPlacement
+  movedLabel: NetLabelPlacement
+  pinMap: Record<string, InputPin & { chipId: string }>
+}): SolvedTracePath => {
+  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,
+  }
+}