@tscircuit/schematic-trace-solver 0.0.165 → 0.0.167

package/dist/index.d.ts

@@ -141,7 +141,11 @@ interface InputDirectConnection {
 interface InputNetConnection {
     netId: string;
     pinIds: Array<PinId>;
-    /** True when the authoritative source net is electrical ground. */
+    /**
+     * Preserve explicitly wired islands on this ground net, joining the islands
+     * electrically through labels instead of routing between them. Nets without
+     * explicit traces, or without this hint, retain automatic bus routing.
+     */
     isGround?: boolean;
     /**
      * User-facing text to render for this net label. `netId` remains the stable

package/dist/index.js

@@ -369,10 +369,17 @@ var MAX_LOCAL_GROUND_BRANCH_OFFSET = 1;
 var getGroundConnectionPolicy = (inputProblem) => {
   const { netConnMap } = getConnectivityMapsFromInputProblem(inputProblem);
   const groundNetId = netConnMap.getNetConnectedToId("GND");
-  if (!groundNetId) return () => true;
   const physicalConnMap = new ConnectivityMap2({});
+  const explicitlyWiredGroundNetIds = /* @__PURE__ */ new Set();
   for (const connection of inputProblem.directConnections) {
     physicalConnMap.addConnections([connection.pinIds]);
+    const globalNetId = netConnMap.getNetConnectedToId(connection.pinIds[0]);
+    const isMarkedGround = inputProblem.netConnections.some(
+      (net) => net.isGround && netConnMap.getNetConnectedToId(net.netId) === globalNetId
+    );
+    if (globalNetId && isMarkedGround) {
+      explicitlyWiredGroundNetIds.add(globalNetId);
+    }
   }
   const pins = new Map(
     inputProblem.chips.flatMap(
@@ -388,13 +395,28 @@ var getGroundConnectionPolicy = (inputProblem) => {
       ({ pin: b }) => a.pinId !== b.pinId && Math.abs(a.y - b.y) < 1e-6 && Math.abs(a.x - b.x) > 1e-6 && physicalConnMap.getNetConnectedToId(b.pinId) === group
     );
   });
-  if (!hasExplicitParallelGroundRail) return () => true;
+  const areSeparateExplicitGroundIslands = (firstPinId, secondPinId) => {
+    const firstGlobalNetId = netConnMap.getNetConnectedToId(firstPinId);
+    const secondGlobalNetId = netConnMap.getNetConnectedToId(secondPinId);
+    if (!firstGlobalNetId || firstGlobalNetId !== secondGlobalNetId || !explicitlyWiredGroundNetIds.has(firstGlobalNetId)) {
+      return false;
+    }
+    const firstPhysicalGroup = physicalConnMap.getNetConnectedToId(firstPinId) ?? `pin:${firstPinId}`;
+    const secondPhysicalGroup = physicalConnMap.getNetConnectedToId(secondPinId) ?? `pin:${secondPinId}`;
+    return firstPhysicalGroup !== secondPhysicalGroup;
+  };
+  if (!hasExplicitParallelGroundRail) {
+    return (firstPinId, secondPinId) => !areSeparateExplicitGroundIslands(firstPinId, secondPinId);
+  }
   const isGroundFacingTerminal = (pinId) => {
     const entry = pins.get(pinId);
     return entry?.chip.pins.length === 2 && !physicalConnMap.getNetConnectedToId(pinId) && (entry.pin._facingDirection ?? getPinDirection(entry.pin, entry.chip)) === "y-";
   };
   return (firstPinId, secondPinId) => {
-    if (!groundNetId || netConnMap.getNetConnectedToId(firstPinId) !== groundNetId || netConnMap.getNetConnectedToId(secondPinId) !== groundNetId) {
+    const firstGlobalNetId = netConnMap.getNetConnectedToId(firstPinId);
+    const secondGlobalNetId = netConnMap.getNetConnectedToId(secondPinId);
+    if (areSeparateExplicitGroundIslands(firstPinId, secondPinId)) return false;
+    if (!groundNetId || firstGlobalNetId !== groundNetId || secondGlobalNetId !== groundNetId) {
       return true;
     }
     if (!isGroundFacingTerminal(firstPinId) && !isGroundFacingTerminal(secondPinId))
@@ -13009,6 +13031,214 @@ var alignSameNetJunctions = ({
   };
 };
 
+// lib/solvers/SameNetJunctionAlignmentSolver/collapseSameNetCycles.ts
+import { getSegmentIntersection as getSegmentIntersection4 } from "@tscircuit/math-utils/line-intersections";
+var TRACE_LENGTH_EPSILON = 1e-6;
+var getTracePathStartingAtPin = (trace, pin) => {
+  const pathStart = trace.tracePath[0];
+  const pathEnd = trace.tracePath.at(-1);
+  if (!pathStart || !pathEnd) return null;
+  if (pointsEqual(pathStart, pin)) return trace.tracePath;
+  if (pointsEqual(pathEnd, pin)) return [...trace.tracePath].reverse();
+  return null;
+};
+var getPerpendicularPathCrossings = (targetPath, donorPath) => {
+  const crossings = [];
+  const sharedEndpoint = targetPath[0];
+  for (let targetSegmentIndex = 0; targetSegmentIndex < targetPath.length - 1; targetSegmentIndex++) {
+    const targetStart = targetPath[targetSegmentIndex];
+    const targetEnd = targetPath[targetSegmentIndex + 1];
+    const targetOrientation = getRailOrientation(targetStart, targetEnd);
+    if (!targetOrientation) continue;
+    for (let donorSegmentIndex = 0; donorSegmentIndex < donorPath.length - 1; donorSegmentIndex++) {
+      const donorStart = donorPath[donorSegmentIndex];
+      const donorEnd = donorPath[donorSegmentIndex + 1];
+      const donorOrientation = getRailOrientation(donorStart, donorEnd);
+      if (!donorOrientation || donorOrientation === targetOrientation) continue;
+      const intersectionPoint = getSegmentIntersection4(
+        targetStart,
+        targetEnd,
+        donorStart,
+        donorEnd
+      );
+      if (!intersectionPoint || pointsEqual(intersectionPoint, sharedEndpoint)) {
+        continue;
+      }
+      crossings.push({
+        intersectionPoint,
+        targetSegmentIndex,
+        donorSegmentIndex
+      });
+    }
+  }
+  return crossings;
+};
+var buildCollapsedCyclePath = ({
+  targetTrace,
+  targetPath,
+  donorPath,
+  crossing
+}) => {
+  const pathFromSharedPin = simplifyPath([
+    ...donorPath.slice(0, crossing.donorSegmentIndex + 1),
+    crossing.intersectionPoint,
+    ...targetPath.slice(crossing.targetSegmentIndex + 1)
+  ]);
+  if (pointsEqual(targetTrace.tracePath[0], targetPath[0])) {
+    return pathFromSharedPin;
+  }
+  return pathFromSharedPin.reverse();
+};
+var getNetLabelPlacementsForCycleCollapse = ({
+  targetTrace,
+  tracePath,
+  netLabelPlacements
+}) => {
+  const candidateNetLabelPlacements = moveAttachedLabelsToReroutedTrace({
+    trace: targetTrace,
+    originalTracePath: targetTrace.tracePath,
+    reroutedTracePath: tracePath,
+    netLabelPlacements
+  });
+  for (let labelIndex = 0; labelIndex < netLabelPlacements.length; labelIndex++) {
+    const label = netLabelPlacements[labelIndex];
+    if (label.globalConnNetId !== targetTrace.globalConnNetId) continue;
+    if (!tracePathContainsPoint(targetTrace.tracePath, label.anchorPoint)) {
+      continue;
+    }
+    const candidateLabel = candidateNetLabelPlacements[labelIndex];
+    if (!tracePathContainsPoint(tracePath, candidateLabel.anchorPoint)) {
+      return null;
+    }
+  }
+  const otherNetLabelPlacements = candidateNetLabelPlacements.filter(
+    (label) => label.globalConnNetId !== targetTrace.globalConnNetId
+  );
+  if (pathIntersectsAnyNetLabel({
+    path: tracePath,
+    netLabelPlacements: otherNetLabelPlacements
+  })) {
+    return null;
+  }
+  const sameNetLabelPlacements = candidateNetLabelPlacements.filter(
+    (label) => label.globalConnNetId === targetTrace.globalConnNetId
+  );
+  if (pathEntersAnyNetLabel({
+    path: tracePath,
+    netLabelPlacements: sameNetLabelPlacements
+  })) {
+    return null;
+  }
+  return candidateNetLabelPlacements;
+};
+var candidateIsBetter = (candidate, bestCandidate) => {
+  if (!bestCandidate) return true;
+  const visibleLengthDelta = candidate.netVisibleLength - bestCandidate.netVisibleLength;
+  if (Math.abs(visibleLengthDelta) > TRACE_LENGTH_EPSILON) {
+    return visibleLengthDelta < 0;
+  }
+  return candidate.netVisibleSegmentCount < bestCandidate.netVisibleSegmentCount;
+};
+var getBestCycleCollapseCandidate = ({
+  targetTrace,
+  traces,
+  netLabelPlacements
+}) => {
+  const sameNetTraces = traces.filter(
+    (trace) => trace.globalConnNetId === targetTrace.globalConnNetId
+  );
+  const baselineNetVisibleLength = getVisibleTraceLength(sameNetTraces);
+  const baselineTargetVisibleLength = getVisibleTraceLength([targetTrace]);
+  let bestCandidate = null;
+  for (const donorTrace of sameNetTraces) {
+    if (donorTrace.mspPairId === targetTrace.mspPairId) continue;
+    const sharedPin = getSharedPin({
+      donorTrace,
+      branchTrace: targetTrace
+    });
+    if (!sharedPin) continue;
+    const targetPath = getTracePathStartingAtPin(targetTrace, sharedPin);
+    const donorPath = getTracePathStartingAtPin(donorTrace, sharedPin);
+    if (!targetPath || !donorPath) continue;
+    const crossings = getPerpendicularPathCrossings(targetPath, donorPath);
+    for (const crossing of crossings) {
+      const tracePath = buildCollapsedCyclePath({
+        targetTrace,
+        targetPath,
+        donorPath,
+        crossing
+      });
+      const candidateTrace = { ...targetTrace, tracePath };
+      const candidateTargetVisibleLength = getVisibleTraceLength([
+        candidateTrace
+      ]);
+      if (candidateTargetVisibleLength > baselineTargetVisibleLength + TRACE_LENGTH_EPSILON) {
+        continue;
+      }
+      const candidateNetLabelPlacements = getNetLabelPlacementsForCycleCollapse(
+        {
+          targetTrace,
+          tracePath,
+          netLabelPlacements
+        }
+      );
+      if (!candidateNetLabelPlacements) continue;
+      const candidateNetTraces = sameNetTraces.map((trace) => {
+        if (trace.mspPairId === targetTrace.mspPairId) return candidateTrace;
+        return trace;
+      });
+      const netVisibleLength = getVisibleTraceLength(candidateNetTraces);
+      if (netVisibleLength >= baselineNetVisibleLength - TRACE_LENGTH_EPSILON) {
+        continue;
+      }
+      const netVisibleSegmentCount = getVisibleTraceSegmentCount(candidateNetTraces);
+      const candidate = {
+        tracePath,
+        netLabelPlacements: candidateNetLabelPlacements,
+        netVisibleLength,
+        netVisibleSegmentCount
+      };
+      if (candidateIsBetter(candidate, bestCandidate)) {
+        bestCandidate = candidate;
+      }
+    }
+  }
+  return bestCandidate;
+};
+var collapseSameNetCycles = ({
+  traces,
+  netLabelPlacements
+}) => {
+  const outputTraces = [...traces];
+  let outputNetLabelPlacements = [...netLabelPlacements];
+  let collapsedCycleCount = 0;
+  let traceIndex = 0;
+  while (traceIndex < outputTraces.length) {
+    const targetTrace = outputTraces[traceIndex];
+    const candidate = getBestCycleCollapseCandidate({
+      targetTrace,
+      traces: outputTraces,
+      netLabelPlacements: outputNetLabelPlacements
+    });
+    if (!candidate) {
+      traceIndex++;
+      continue;
+    }
+    outputTraces[traceIndex] = {
+      ...targetTrace,
+      tracePath: candidate.tracePath
+    };
+    outputNetLabelPlacements = candidate.netLabelPlacements;
+    collapsedCycleCount++;
+    traceIndex = 0;
+  }
+  return {
+    traces: outputTraces,
+    netLabelPlacements: outputNetLabelPlacements,
+    collapsedCycleCount
+  };
+};
+
 // lib/solvers/SameNetJunctionAlignmentSolver/placeGroundRailLabelsAtOuterEnd.ts
 var placeGroundRailLabelsAtOuterEnd = ({
   inputProblem,
@@ -13090,14 +13320,19 @@ var SameNetJunctionAlignmentSolver = class extends BaseSolver {
     this.outputNetLabelPlacements = input.netLabelPlacements;
   }
   _step() {
-    const result = alignSameNetJunctions(this.input);
-    this.outputTraces = result.traces;
+    const alignment = alignSameNetJunctions(this.input);
+    const cycleCollapse = collapseSameNetCycles({
+      traces: alignment.traces,
+      netLabelPlacements: alignment.netLabelPlacements
+    });
+    this.outputTraces = cycleCollapse.traces;
     this.outputNetLabelPlacements = placeGroundRailLabelsAtOuterEnd({
       inputProblem: this.input.inputProblem,
-      traces: result.traces,
-      netLabelPlacements: result.netLabelPlacements
+      traces: cycleCollapse.traces,
+      netLabelPlacements: cycleCollapse.netLabelPlacements
     });
-    this.stats.alignedJunctionCount = result.alignedJunctionCount;
+    this.stats.alignedJunctionCount = alignment.alignedJunctionCount;
+    this.stats.collapsedCycleCount = cycleCollapse.collapsedCycleCount;
     this.solved = true;
   }
   getOutput() {

package/lib/solvers/MspConnectionPairSolver/getGroundConnectionPolicy.ts

@@ -11,12 +11,21 @@ const MAX_LOCAL_GROUND_BRANCH_OFFSET = 1
 export const getGroundConnectionPolicy = (inputProblem: InputProblem) => {
   const { netConnMap } = getConnectivityMapsFromInputProblem(inputProblem)
   const groundNetId = netConnMap.getNetConnectedToId("GND")
-  if (!groundNetId) return () => true
   // Net identifiers do not constitute physical edges: two separate direct
   // connections may have the same netId without requesting a wire between them.
   const physicalConnMap = new ConnectivityMap({})
+  const explicitlyWiredGroundNetIds = new Set<string>()
   for (const connection of inputProblem.directConnections) {
     physicalConnMap.addConnections([connection.pinIds])
+    const globalNetId = netConnMap.getNetConnectedToId(connection.pinIds[0])
+    const isMarkedGround = inputProblem.netConnections.some(
+      (net) =>
+        net.isGround &&
+        netConnMap.getNetConnectedToId(net.netId) === globalNetId,
+    )
+    if (globalNetId && isMarkedGround) {
+      explicitlyWiredGroundNetIds.add(globalNetId)
+    }
   }
   const pins = new Map(
     inputProblem.chips.flatMap((chip) =>
@@ -46,7 +55,29 @@ export const getGroundConnectionPolicy = (inputProblem: InputProblem) => {
       )
     )
   })
-  if (!hasExplicitParallelGroundRail) return () => true
+  const areSeparateExplicitGroundIslands = (
+    firstPinId: PinId,
+    secondPinId: PinId,
+  ) => {
+    const firstGlobalNetId = netConnMap.getNetConnectedToId(firstPinId)
+    const secondGlobalNetId = netConnMap.getNetConnectedToId(secondPinId)
+    if (
+      !firstGlobalNetId ||
+      firstGlobalNetId !== secondGlobalNetId ||
+      !explicitlyWiredGroundNetIds.has(firstGlobalNetId)
+    ) {
+      return false
+    }
+    const firstPhysicalGroup =
+      physicalConnMap.getNetConnectedToId(firstPinId) ?? `pin:${firstPinId}`
+    const secondPhysicalGroup =
+      physicalConnMap.getNetConnectedToId(secondPinId) ?? `pin:${secondPinId}`
+    return firstPhysicalGroup !== secondPhysicalGroup
+  }
+  if (!hasExplicitParallelGroundRail) {
+    return (firstPinId: PinId, secondPinId: PinId) =>
+      !areSeparateExplicitGroundIslands(firstPinId, secondPinId)
+  }
   const isGroundFacingTerminal = (pinId: PinId) => {
     const entry = pins.get(pinId)
     return (
@@ -58,10 +89,13 @@ export const getGroundConnectionPolicy = (inputProblem: InputProblem) => {
   }
 
   return (firstPinId: PinId, secondPinId: PinId): boolean => {
+    const firstGlobalNetId = netConnMap.getNetConnectedToId(firstPinId)
+    const secondGlobalNetId = netConnMap.getNetConnectedToId(secondPinId)
+    if (areSeparateExplicitGroundIslands(firstPinId, secondPinId)) return false
     if (
       !groundNetId ||
-      netConnMap.getNetConnectedToId(firstPinId) !== groundNetId ||
-      netConnMap.getNetConnectedToId(secondPinId) !== groundNetId
+      firstGlobalNetId !== groundNetId ||
+      secondGlobalNetId !== groundNetId
     ) {
       return true
     }

package/lib/solvers/SameNetJunctionAlignmentSolver/SameNetJunctionAlignmentSolver.ts

@@ -6,6 +6,7 @@ import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/
 import type { InputProblem } from "lib/types/InputProblem"
 import { getColorFromString } from "lib/utils/getColorFromString"
 import { alignSameNetJunctions } from "./alignSameNetJunctions"
+import { collapseSameNetCycles } from "./collapseSameNetCycles"
 import { placeGroundRailLabelsAtOuterEnd } from "./placeGroundRailLabelsAtOuterEnd"
 
 interface SameNetJunctionAlignmentSolverInput {
@@ -28,14 +29,19 @@ export class SameNetJunctionAlignmentSolver extends BaseSolver {
   }
 
   override _step() {
-    const result = alignSameNetJunctions(this.input)
-    this.outputTraces = result.traces
+    const alignment = alignSameNetJunctions(this.input)
+    const cycleCollapse = collapseSameNetCycles({
+      traces: alignment.traces,
+      netLabelPlacements: alignment.netLabelPlacements,
+    })
+    this.outputTraces = cycleCollapse.traces
     this.outputNetLabelPlacements = placeGroundRailLabelsAtOuterEnd({
       inputProblem: this.input.inputProblem,
-      traces: result.traces,
-      netLabelPlacements: result.netLabelPlacements,
+      traces: cycleCollapse.traces,
+      netLabelPlacements: cycleCollapse.netLabelPlacements,
     })
-    this.stats.alignedJunctionCount = result.alignedJunctionCount
+    this.stats.alignedJunctionCount = alignment.alignedJunctionCount
+    this.stats.collapsedCycleCount = cycleCollapse.collapsedCycleCount
     this.solved = true
   }
 

package/lib/solvers/SameNetJunctionAlignmentSolver/alignSameNetJunctions.ts

@@ -41,7 +41,7 @@ const MAX_SAME_NET_LABEL_BOUNDARY_RAIL_OFFSET = 0.2
 const MAX_SHARED_PIN_RAIL_OFFSET = 0.05
 const MIN_RETURN_STEM_LENGTH = 0.05
 
-const getSharedPin = ({
+export const getSharedPin = ({
   donorTrace,
   branchTrace,
 }: {