@tscircuit/schematic-trace-solver 0.0.115 → 0.0.117

package/dist/index.d.ts

@@ -782,6 +782,8 @@ declare class AvailableNetOrientationSolver extends BaseSolver {
     private findValidCandidateInShiftColumn;
     private evaluateCandidate;
     private getCandidateConnectorTrace;
+    private isStandaloneSinglePinNetLabel;
+    private labelIntersectsDifferentNetTrace;
     private getSearchStartAnchor;
     private getWickOffsetAnchor;
     private getSideOffsetAnchor;
@@ -1047,6 +1049,24 @@ declare class UnroutedTraceRecoverySolver extends BaseSolver {
     visualize(): graphics_debug.GraphicsObject;
 }
 
+interface SameNetJunctionAlignmentSolverInput {
+    inputProblem: InputProblem;
+    traces: SolvedTracePath[];
+    netLabelPlacements: NetLabelPlacement[];
+}
+/** Turns separate same-net load traces into one shared rail with short junction branches. */
+declare class SameNetJunctionAlignmentSolver extends BaseSolver {
+    private input;
+    outputTraces: SolvedTracePath[];
+    constructor(input: SameNetJunctionAlignmentSolverInput);
+    _step(): void;
+    getOutput(): {
+        traces: SolvedTracePath[];
+        netLabelPlacements: NetLabelPlacement[];
+    };
+    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.
@@ -1081,13 +1101,14 @@ declare class SchematicTracePipelineSolver extends BaseSolver {
     netLabelTraceCollisionSolver?: NetLabelTraceCollisionSolver;
     traceCleanupSolver2?: TraceCleanupSolver;
     netLabelNetLabelCollisionSolver?: NetLabelNetLabelCollisionSolver;
+    sameNetJunctionAlignmentSolver?: SameNetJunctionAlignmentSolver;
     startTimeOfPhase: Record<string, number>;
     endTimeOfPhase: Record<string, number>;
     timeSpentOnPhase: Record<string, number>;
     firstIterationOfPhase: Record<string, number>;
     inputProblem: InputProblem;
     hideRatsNet: boolean;
-    pipelineDef: (PipelineStep<typeof MspConnectionPairSolver> | PipelineStep<typeof SchematicTraceLinesSolver> | PipelineStep<typeof LongDistancePairSolver> | PipelineStep<typeof UnroutedTraceRecoverySolver> | PipelineStep<typeof TraceOverlapShiftSolver> | PipelineStep<typeof NetLabelPlacementSolver> | PipelineStep<typeof TraceLabelOverlapAvoidanceSolver> | PipelineStep<typeof TraceCleanupSolver> | PipelineStep<typeof Example28Solver> | PipelineStep<typeof AvailableNetOrientationSolver> | PipelineStep<typeof RailNetLabelCornerPlacementSolver> | PipelineStep<typeof TraceAnchoredNetLabelOverlapSolver> | PipelineStep<typeof NetLabelTraceCollisionSolver> | PipelineStep<typeof NetLabelNetLabelCollisionSolver>)[];
+    pipelineDef: (PipelineStep<typeof MspConnectionPairSolver> | PipelineStep<typeof SchematicTraceLinesSolver> | PipelineStep<typeof LongDistancePairSolver> | PipelineStep<typeof UnroutedTraceRecoverySolver> | PipelineStep<typeof TraceOverlapShiftSolver> | PipelineStep<typeof NetLabelPlacementSolver> | PipelineStep<typeof TraceLabelOverlapAvoidanceSolver> | PipelineStep<typeof TraceCleanupSolver> | PipelineStep<typeof Example28Solver> | PipelineStep<typeof AvailableNetOrientationSolver> | PipelineStep<typeof RailNetLabelCornerPlacementSolver> | PipelineStep<typeof TraceAnchoredNetLabelOverlapSolver> | PipelineStep<typeof NetLabelTraceCollisionSolver> | PipelineStep<typeof NetLabelNetLabelCollisionSolver> | PipelineStep<typeof SameNetJunctionAlignmentSolver>)[];
     constructor(inputProblem: InputProblem, opts?: Options);
     getConstructorParams(): ConstructorParameters<typeof SchematicTracePipelineSolver>;
     currentPipelineStepIndex: number;

package/dist/index.js

@@ -7895,6 +7895,34 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
         indices.push(i);
       }
     }
+    const blockedStandaloneLabelIndex = indices.find((index) => {
+      const label = this.outputNetLabelPlacements[index];
+      const orientations = this.getAvailableOrientations(label);
+      return this.isPortOnlyLabel(label) && this.isStandaloneSinglePinNetLabel(label) && orientations.length === 1 && isYOrientation(orientations[0]) && this.labelIntersectsDifferentNetTrace(label);
+    });
+    if (blockedStandaloneLabelIndex === void 0) return indices;
+    const blockedLabel = this.outputNetLabelPlacements[blockedStandaloneLabelIndex];
+    const requiredOrientation = this.getAvailableOrientations(blockedLabel)[0];
+    const chipSide = this.getChipSideForPoint(blockedLabel.anchorPoint);
+    const affectedSlots = [];
+    const labelsToOrder = [];
+    for (let slot = 0; slot < indices.length; slot++) {
+      const index = indices[slot];
+      const label = this.outputNetLabelPlacements[index];
+      const orientations = this.getAvailableOrientations(label);
+      if (this.getChipSideForPoint(label.anchorPoint) === chipSide && orientations.length === 1 && orientations[0] === requiredOrientation) {
+        affectedSlots.push(slot);
+        labelsToOrder.push(index);
+      }
+    }
+    labelsToOrder.sort((a, b) => {
+      const aY = this.outputNetLabelPlacements[a].anchorPoint.y;
+      const bY = this.outputNetLabelPlacements[b].anchorPoint.y;
+      return requiredOrientation === "y+" ? bY - aY : aY - bY;
+    });
+    for (let i = 0; i < affectedSlots.length; i++) {
+      indices[affectedSlots[i]] = labelsToOrder[i];
+    }
     return indices;
   }
   shouldProcessLabel(label) {
@@ -8213,6 +8241,28 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       candidate.orientation
     );
   }
+  isStandaloneSinglePinNetLabel(label) {
+    return this.inputProblem.netConnections.some(
+      (connection) => connection.netId === label.netId && connection.pinIds.length === 1 && connection.pinIds[0] === label.pinIds[0]
+    );
+  }
+  labelIntersectsDifferentNetTrace(label) {
+    const { width, height } = getDimsForOrientation({
+      orientation: label.orientation,
+      netLabelWidth: this.getNetLabelWidth(label),
+      netLabelHeight: this.getNetLabelHeight(label)
+    });
+    const center = getCenterFromAnchor(
+      label.anchorPoint,
+      label.orientation,
+      width,
+      height
+    );
+    const bounds = getRectBounds(center, width, height);
+    return Object.values(this.traceMap).some(
+      (trace) => trace.globalConnNetId !== label.globalConnNetId && tracePathIntersectsBounds(trace.tracePath, bounds)
+    );
+  }
   getSearchStartAnchor(label, orientation) {
     const anchorPoint = this.getWickOffsetAnchor(label.anchorPoint, orientation);
     const { width, height } = getDimsForOrientation({
@@ -10717,6 +10767,222 @@ var UnroutedTraceRecoverySolver = class extends BaseSolver {
   }
 };
 
+// lib/solvers/SameNetJunctionAlignmentSolver/pathIntersectsAnyNetLabel.ts
+var pathIntersectsAnyNetLabel = ({
+  path,
+  netLabelPlacements
+}) => {
+  for (const label of netLabelPlacements) {
+    const labelBounds = getRectBounds(label.center, label.width, label.height);
+    for (let index = 0; index < path.length - 1; index++) {
+      if (segmentIntersectsRect2(path[index], path[index + 1], labelBounds)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+
+// lib/solvers/SameNetJunctionAlignmentSolver/alignSameNetJunctions.ts
+var MAX_ALIGNED_LOAD_PIN_OFFSET = 0.2;
+var getSharedPin = ({
+  donorTrace,
+  branchTrace
+}) => {
+  const branchPinIds = new Set(branchTrace.pins.map((pin) => pin.pinId));
+  return donorTrace.pins.find((pin) => branchPinIds.has(pin.pinId)) ?? null;
+};
+var getOtherPin = ({
+  trace,
+  sharedPin
+}) => trace.pins.find((pin) => pin.pinId !== sharedPin.pinId) ?? null;
+var getLongestHorizontalSegment = (trace) => {
+  let longest = null;
+  for (let index = 0; index < trace.tracePath.length - 1; index++) {
+    const start = trace.tracePath[index];
+    const end = trace.tracePath[index + 1];
+    if (!isHorizontal2(start, end)) continue;
+    if (!longest || Math.abs(end.x - start.x) > Math.abs(longest.end.x - longest.start.x)) {
+      longest = { start, end };
+    }
+  }
+  return longest;
+};
+var getJunctionPoint = ({
+  segment,
+  sharedPin
+}) => {
+  const startDistance = Math.abs(segment.start.x - sharedPin.x);
+  const endDistance = Math.abs(segment.end.x - sharedPin.x);
+  if (startDistance <= endDistance) return segment.start;
+  return segment.end;
+};
+var railIsOnFacingSide = ({
+  railY,
+  pin
+}) => {
+  if (pin._facingDirection === "y+") return railY > pin.y;
+  return false;
+};
+var getAlignedBranchPath = ({
+  donorTrace,
+  branchTrace
+}) => {
+  const sharedPin = getSharedPin({ donorTrace, branchTrace });
+  if (!sharedPin) return null;
+  const donorOtherPin = getOtherPin({ trace: donorTrace, sharedPin });
+  if (!donorOtherPin) return null;
+  const otherPin = getOtherPin({ trace: branchTrace, sharedPin });
+  if (!otherPin) return null;
+  if (Math.abs(sharedPin.y - otherPin.y) > MAX_ALIGNED_LOAD_PIN_OFFSET) {
+    return null;
+  }
+  const donorRail = getLongestHorizontalSegment(donorTrace);
+  if (!donorRail) return null;
+  const branchRail = getLongestHorizontalSegment(branchTrace);
+  if (branchRail && nearlyEqual(branchRail.start.y, donorRail.start.y)) {
+    return null;
+  }
+  if (!railIsOnFacingSide({ railY: donorRail.start.y, pin: otherPin })) {
+    return null;
+  }
+  const junction = getJunctionPoint({ segment: donorRail, sharedPin });
+  const extendsDonorRail = donorOtherPin.x < junction.x && otherPin.x > junction.x || donorOtherPin.x > junction.x && otherPin.x < junction.x;
+  if (!extendsDonorRail) return null;
+  const sharedToOther = simplifyPath([
+    { x: sharedPin.x, y: sharedPin.y },
+    { x: junction.x, y: sharedPin.y },
+    { x: junction.x, y: junction.y },
+    { x: otherPin.x, y: junction.y },
+    { x: otherPin.x, y: otherPin.y }
+  ]);
+  if (branchTrace.pins[0].pinId === sharedPin.pinId) return sharedToOther;
+  return [...sharedToOther].reverse();
+};
+var candidateIsClear = ({
+  candidateTrace,
+  traces,
+  inputProblem,
+  netLabelPlacements
+}) => {
+  const obstacles = getObstacleRects(inputProblem);
+  if (isPathCollidingWithObstacles(candidateTrace.tracePath, obstacles)) {
+    return false;
+  }
+  const otherNetTraces = traces.filter(
+    (trace) => trace.globalConnNetId !== candidateTrace.globalConnNetId
+  );
+  if (doesPathCoincideWithTraces(candidateTrace.tracePath, otherNetTraces)) {
+    return false;
+  }
+  return !pathIntersectsAnyNetLabel({
+    path: candidateTrace.tracePath,
+    netLabelPlacements
+  });
+};
+var alignSameNetJunctions = ({
+  inputProblem,
+  traces,
+  netLabelPlacements
+}) => {
+  let outputTraces = [...traces];
+  const alignedBranchTraceIds = /* @__PURE__ */ new Set();
+  let alignedJunctionCount = 0;
+  for (const donorTraceId of traces.map((trace) => trace.mspPairId)) {
+    const donorTrace = outputTraces.find(
+      (trace) => trace.mspPairId === donorTraceId
+    );
+    for (const branchTrace of outputTraces) {
+      if (alignedBranchTraceIds.has(branchTrace.mspPairId)) continue;
+      if (donorTrace.mspPairId === branchTrace.mspPairId) continue;
+      if (donorTrace.globalConnNetId !== branchTrace.globalConnNetId) continue;
+      const candidatePath = getAlignedBranchPath({ donorTrace, branchTrace });
+      if (!candidatePath) continue;
+      const candidateTrace = { ...branchTrace, tracePath: candidatePath };
+      const originalPair = [donorTrace, branchTrace];
+      const candidatePair = [donorTrace, candidateTrace];
+      const removesVisibleSegment = getVisibleTraceSegmentCount(candidatePair) < getVisibleTraceSegmentCount(originalPair);
+      const shortensVisibleTrace = getVisibleTraceLength(candidatePair) < getVisibleTraceLength(originalPair) && !nearlyEqual(
+        getVisibleTraceLength(candidatePair),
+        getVisibleTraceLength(originalPair)
+      );
+      if (!removesVisibleSegment && !shortensVisibleTrace) {
+        continue;
+      }
+      if (!candidateIsClear({
+        candidateTrace,
+        traces: outputTraces,
+        inputProblem,
+        netLabelPlacements
+      })) {
+        continue;
+      }
+      outputTraces = outputTraces.map((trace) => {
+        if (trace.mspPairId === branchTrace.mspPairId) return candidateTrace;
+        return trace;
+      });
+      alignedBranchTraceIds.add(branchTrace.mspPairId);
+      alignedJunctionCount++;
+    }
+  }
+  return { traces: outputTraces, alignedJunctionCount };
+};
+
+// lib/solvers/SameNetJunctionAlignmentSolver/SameNetJunctionAlignmentSolver.ts
+var SameNetJunctionAlignmentSolver = class extends BaseSolver {
+  input;
+  outputTraces;
+  constructor(input) {
+    super();
+    this.input = input;
+    this.outputTraces = input.traces;
+  }
+  _step() {
+    const result = alignSameNetJunctions(this.input);
+    this.outputTraces = result.traces;
+    this.stats.alignedJunctionCount = result.alignedJunctionCount;
+    this.solved = true;
+  }
+  getOutput() {
+    return {
+      traces: this.outputTraces,
+      netLabelPlacements: this.input.netLabelPlacements
+    };
+  }
+  visualize() {
+    const graphics = visualizeInputProblem(this.input.inputProblem);
+    graphics.lines ??= [];
+    graphics.rects ??= [];
+    graphics.points ??= [];
+    for (const trace of this.outputTraces) {
+      graphics.lines.push({
+        points: trace.tracePath,
+        strokeColor: "purple"
+      });
+    }
+    for (const label of this.input.netLabelPlacements) {
+      const labelRect = {
+        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.rects.push(labelRect);
+      graphics.points.push({
+        x: label.anchorPoint.x,
+        y: label.anchorPoint.y,
+        color: getColorFromString(label.globalConnNetId, 0.9),
+        label: `anchorPoint
+orientation: ${label.orientation}`
+      });
+    }
+    return graphics;
+  }
+};
+
 // lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts
 function definePipelineStep(solverName, solverClass, getConstructorParams, opts = {}) {
   return {
@@ -10747,6 +11013,7 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
   netLabelTraceCollisionSolver;
   traceCleanupSolver2;
   netLabelNetLabelCollisionSolver;
+  sameNetJunctionAlignmentSolver;
   startTimeOfPhase;
   endTimeOfPhase;
   timeSpentOnPhase;
@@ -11019,6 +11286,20 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
           netLabelPlacements: instance.netLabelTraceCollisionSolver.getOutput().netLabelPlacements
         }
       ]
+    ),
+    definePipelineStep(
+      "sameNetJunctionAlignmentSolver",
+      SameNetJunctionAlignmentSolver,
+      (instance) => {
+        const collisionOutput = instance.netLabelNetLabelCollisionSolver.getOutput();
+        return [
+          {
+            inputProblem: instance.inputProblem,
+            traces: instance.netLabelNetLabelCollisionSolver.traces,
+            netLabelPlacements: collisionOutput.netLabelPlacements
+          }
+        ];
+      }
     )
   ];
   constructor(inputProblem, opts) {

package/lib/solvers/AvailableNetOrientationSolver/AvailableNetOrientationSolver.ts

@@ -110,6 +110,52 @@ export class AvailableNetOrientationSolver extends BaseSolver {
       }
     }
 
+    const blockedStandaloneLabelIndex = indices.find((index) => {
+      const label = this.outputNetLabelPlacements[index]!
+      const orientations = this.getAvailableOrientations(label)
+      return (
+        this.isPortOnlyLabel(label) &&
+        this.isStandaloneSinglePinNetLabel(label) &&
+        orientations.length === 1 &&
+        isYOrientation(orientations[0]!) &&
+        this.labelIntersectsDifferentNetTrace(label)
+      )
+    })
+    if (blockedStandaloneLabelIndex === undefined) return indices
+
+    const blockedLabel =
+      this.outputNetLabelPlacements[blockedStandaloneLabelIndex]!
+    const requiredOrientation = this.getAvailableOrientations(blockedLabel)[0]!
+    const chipSide = this.getChipSideForPoint(blockedLabel.anchorPoint)
+    const affectedSlots: number[] = []
+    const labelsToOrder: number[] = []
+
+    for (let slot = 0; slot < indices.length; slot++) {
+      const index = indices[slot]!
+      const label = this.outputNetLabelPlacements[index]!
+      const orientations = this.getAvailableOrientations(label)
+      if (
+        this.getChipSideForPoint(label.anchorPoint) === chipSide &&
+        orientations.length === 1 &&
+        orientations[0] === requiredOrientation
+      ) {
+        affectedSlots.push(slot)
+        labelsToOrder.push(index)
+      }
+    }
+
+    // Place vertical labels on the same chip side from the outward end inward.
+    // The standalone label is corrected first, then a lower neighbor yields
+    // space during its own placement, keeping the standalone connector direct.
+    labelsToOrder.sort((a, b) => {
+      const aY = this.outputNetLabelPlacements[a]!.anchorPoint.y
+      const bY = this.outputNetLabelPlacements[b]!.anchorPoint.y
+      return requiredOrientation === "y+" ? bY - aY : aY - bY
+    })
+    for (let i = 0; i < affectedSlots.length; i++) {
+      indices[affectedSlots[i]!] = labelsToOrder[i]!
+    }
+
     return indices
   }
 
@@ -551,6 +597,35 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     )
   }
 
+  private isStandaloneSinglePinNetLabel(label: NetLabelPlacement) {
+    return this.inputProblem.netConnections.some(
+      (connection) =>
+        connection.netId === label.netId &&
+        connection.pinIds.length === 1 &&
+        connection.pinIds[0] === label.pinIds[0],
+    )
+  }
+
+  private labelIntersectsDifferentNetTrace(label: NetLabelPlacement) {
+    const { width, height } = getDimsForOrientation({
+      orientation: label.orientation,
+      netLabelWidth: this.getNetLabelWidth(label),
+      netLabelHeight: this.getNetLabelHeight(label),
+    })
+    const center = getCenterFromAnchor(
+      label.anchorPoint,
+      label.orientation,
+      width,
+      height,
+    )
+    const bounds = getRectBounds(center, width, height)
+    return Object.values(this.traceMap).some(
+      (trace) =>
+        trace.globalConnNetId !== label.globalConnNetId &&
+        tracePathIntersectsBounds(trace.tracePath, bounds),
+    )
+  }
+
   private getSearchStartAnchor(
     label: NetLabelPlacement,
     orientation: FacingDirection,

package/lib/solvers/SameNetJunctionAlignmentSolver/SameNetJunctionAlignmentSolver.ts

@@ -0,0 +1,71 @@
+import type { GraphicsObject, Rect } from "graphics-debug"
+import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
+import type { InputProblem } from "lib/types/InputProblem"
+import { getColorFromString } from "lib/utils/getColorFromString"
+import { alignSameNetJunctions } from "./alignSameNetJunctions"
+
+interface SameNetJunctionAlignmentSolverInput {
+  inputProblem: InputProblem
+  traces: SolvedTracePath[]
+  netLabelPlacements: NetLabelPlacement[]
+}
+
+/** Turns separate same-net load traces into one shared rail with short junction branches. */
+export class SameNetJunctionAlignmentSolver extends BaseSolver {
+  private input: SameNetJunctionAlignmentSolverInput
+  outputTraces: SolvedTracePath[]
+
+  constructor(input: SameNetJunctionAlignmentSolverInput) {
+    super()
+    this.input = input
+    this.outputTraces = input.traces
+  }
+
+  override _step() {
+    const result = alignSameNetJunctions(this.input)
+    this.outputTraces = result.traces
+    this.stats.alignedJunctionCount = result.alignedJunctionCount
+    this.solved = true
+  }
+
+  getOutput() {
+    return {
+      traces: this.outputTraces,
+      netLabelPlacements: this.input.netLabelPlacements,
+    }
+  }
+
+  override visualize(): GraphicsObject {
+    const graphics = visualizeInputProblem(this.input.inputProblem)
+    graphics.lines ??= []
+    graphics.rects ??= []
+    graphics.points ??= []
+    for (const trace of this.outputTraces) {
+      graphics.lines.push({
+        points: trace.tracePath,
+        strokeColor: "purple",
+      })
+    }
+    for (const label of this.input.netLabelPlacements) {
+      const labelRect: Rect & { strokeColor: string } = {
+        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}\nglobalConnNetId: ${label.globalConnNetId}`,
+      }
+      graphics.rects.push(labelRect)
+      graphics.points.push({
+        x: label.anchorPoint.x,
+        y: label.anchorPoint.y,
+        color: getColorFromString(label.globalConnNetId, 0.9),
+        label: `anchorPoint\norientation: ${label.orientation}`,
+      })
+    }
+    return graphics
+  }
+}