@tscircuit/schematic-trace-solver 0.0.166 → 0.0.168

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))
@@ -11560,10 +11582,10 @@ function isPointOnPath(point, path) {
 }
 function buildMergedObstacleLabel(seedLabel, allLabels) {
   const TOUCH_MARGIN = 0.01;
-  const getBounds4 = (l) => getRectBounds(l.center, l.width, l.height);
+  const getBounds3 = (l) => getRectBounds(l.center, l.width, l.height);
   const touches = (a, b) => {
-    const ba = getBounds4(a);
-    const bb = getBounds4(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]);
@@ -11580,7 +11602,7 @@ function buildMergedObstacleLabel(seedLabel, allLabels) {
   }
   let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
   for (const l of group) {
-    const b = getBounds4(l);
+    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;
@@ -13814,12 +13836,28 @@ var getAxisAlignedSegments = (path, epsilon = 1e-6) => {
   return segments.sort((a, b) => b.length - a.length);
 };
 
+// lib/solvers/InlineNetLabelSolver/getAnchoredNetLabelRenderedBounds.ts
+var getAnchoredNetLabelRenderedBounds = (placement) => {
+  if (placement.orientation !== "x-" && placement.orientation !== "x+") {
+    return getRectBounds(placement.center, placement.width, placement.height);
+  }
+  const width = Math.max(placement.width, placement.height);
+  const height = NET_LABEL_HORIZONTAL_HEIGHT;
+  const center = getCenterFromAnchor(
+    placement.anchorPoint,
+    placement.orientation,
+    width,
+    height
+  );
+  return getRectBounds(center, width, height);
+};
+
 // lib/solvers/InlineNetLabelSolver/pushAnchoredNetLabelsAwayFromInlineLabels.ts
 var LABEL_CLEARANCE2 = 0.05;
 var POINT_EPSILON = 1e-6;
 var CONTIGUOUS_LABEL_GAP = 0.01;
 var MAX_OUTWARD_DISTANCE = 5;
-var getBounds3 = (placement) => {
+var getInlineBounds = (placement) => {
   const renderedWidth = placement.axis === "y" ? placement.height : placement.width;
   const renderedHeight = placement.axis === "y" ? placement.width : placement.height;
   return {
@@ -13861,7 +13899,7 @@ var isPointOnPath2 = (point, path) => {
   return false;
 };
 var getRequiredOutwardDistance = (label, inlineBounds) => {
-  const labelBounds = getBounds3(label);
+  const labelBounds = getAnchoredNetLabelRenderedBounds(label);
   if (label.orientation === "x-" || label.orientation === "x+") {
     const nearby2 = inlineBounds.filter(
       (bounds) => labelBounds.minY < bounds.maxY && labelBounds.maxY > bounds.minY
@@ -13988,8 +14026,8 @@ var getContiguousLabelGroup = ({
       if (group.has(labelIndex)) continue;
       if ([...group].some(
         (memberIndex) => boundsGapOnPerpendicularAxis(
-          getBounds3(labels[memberIndex]),
-          getBounds3(label),
+          getAnchoredNetLabelRenderedBounds(labels[memberIndex]),
+          getAnchoredNetLabelRenderedBounds(label),
           trigger.orientation
         ) <= CONTIGUOUS_LABEL_GAP
       )) {
@@ -14011,7 +14049,7 @@ var pushAnchoredNetLabelsAwayFromInlineLabels = ({
     tracePath: trace.tracePath.map((point) => ({ ...point }))
   }));
   const outputLabels = netLabelPlacements.map((label) => ({ ...label }));
-  const inlineBounds = inlineNetLabelPlacements.map(getBounds3);
+  const inlineBounds = inlineNetLabelPlacements.map(getInlineBounds);
   const pinMap = getPinMap(inputProblem);
   const chipIdByPinId = /* @__PURE__ */ new Map();
   for (const chip of inputProblem.chips) {
@@ -14034,7 +14072,7 @@ var pushAnchoredNetLabelsAwayFromInlineLabels = ({
     for (let iteration = 0; iteration < outputLabels.length; iteration++) {
       let adjustedObstacle = false;
       for (const [movingIndex, movingDistance] of distances) {
-        const movingBounds = getBounds3(
+        const movingBounds = getAnchoredNetLabelRenderedBounds(
           moveLabel(
             outputLabels[movingIndex],
             trigger.orientation,
@@ -14045,7 +14083,7 @@ var pushAnchoredNetLabelsAwayFromInlineLabels = ({
           if (group.has(obstacleIndex)) continue;
           const obstacle = outputLabels[obstacleIndex];
           const existingObstacleDistance = distances.get(obstacleIndex) ?? 0;
-          const obstacleBounds = getBounds3(
+          const obstacleBounds = getAnchoredNetLabelRenderedBounds(
             moveLabel(obstacle, trigger.orientation, existingObstacleDistance)
           );
           if (!boundsOverlap(movingBounds, obstacleBounds)) continue;
@@ -14054,7 +14092,7 @@ var pushAnchoredNetLabelsAwayFromInlineLabels = ({
             break;
           }
           const shoveDistance = getDistanceToShoveBoundsPast(
-            getBounds3(obstacle),
+            getAnchoredNetLabelRenderedBounds(obstacle),
             movingBounds,
             trigger.orientation
           );
@@ -14083,7 +14121,7 @@ var pushAnchoredNetLabelsAwayFromInlineLabels = ({
     }
     const finalLabelAt = (labelIndex) => proposals.get(labelIndex) ?? outputLabels[labelIndex];
     for (const [labelIndex, movedLabel] of proposals) {
-      const movedBounds = getBounds3(movedLabel);
+      const movedBounds = getAnchoredNetLabelRenderedBounds(movedLabel);
       if (inlineBounds.some((bounds) => boundsOverlap(movedBounds, bounds))) {
         failed = true;
         break;
@@ -14102,7 +14140,10 @@ var pushAnchoredNetLabelsAwayFromInlineLabels = ({
         break;
       }
       if (outputLabels.some(
-        (_, otherIndex) => otherIndex !== labelIndex && boundsOverlap(movedBounds, getBounds3(finalLabelAt(otherIndex)))
+        (_, otherIndex) => otherIndex !== labelIndex && boundsOverlap(
+          movedBounds,
+          getAnchoredNetLabelRenderedBounds(finalLabelAt(otherIndex))
+        )
       )) {
         failed = true;
         break;
@@ -14147,7 +14188,7 @@ var pushAnchoredNetLabelsAwayFromInlineLabels = ({
       ) || outputLabels.some(
         (_, otherIndex) => otherIndex !== labelIndex && pathIntersectsBounds(
           connector.tracePath,
-          getBounds3(finalLabelAt(otherIndex))
+          getAnchoredNetLabelRenderedBounds(finalLabelAt(otherIndex))
         )
       );
       if (connectorObstructed) {
@@ -14183,7 +14224,7 @@ var getStubDirection2 = (path) => {
   }
   return end.y >= start.y ? "y+" : "y-";
 };
-var getLabelBounds3 = (placement) => {
+var getInlineLabelBounds = (placement) => {
   const renderedWidth = placement.axis === "y" ? placement.height : placement.width;
   const renderedHeight = placement.axis === "y" ? placement.width : placement.height;
   return {
@@ -14283,12 +14324,12 @@ var pushInlineTerminalLabelsAwayFromAnchoredLabels = ({
           direction,
           distance7
         );
-        const shiftedBounds = getLabelBounds3(shiftedPlacement);
+        const shiftedBounds = getInlineLabelBounds(shiftedPlacement);
         for (const anchoredPlacement of anchoredNetLabelPlacements) {
           if (anchoredPlacement.globalConnNetId === placement.globalConnNetId) {
             continue;
           }
-          const anchoredBounds = getLabelBounds3(anchoredPlacement);
+          const anchoredBounds = getAnchoredNetLabelRenderedBounds(anchoredPlacement);
           if (!boundsOverlap(shiftedBounds, anchoredBounds)) continue;
           requiredAdditionalDistance = Math.max(
             requiredAdditionalDistance,
@@ -14312,13 +14353,13 @@ var pushInlineTerminalLabelsAwayFromAnchoredLabels = ({
       const originalEnd = originalPlacement.stubTracePath[1];
       const shiftedEnd = proposal.stubTracePath[1];
       const addedStubSegment = [originalEnd, shiftedEnd];
-      const labelBounds = getLabelBounds3(proposal);
+      const labelBounds = getInlineLabelBounds(proposal);
       const ownerChipId = group[proposalIndex].ownerChipId;
       if (anchoredNetLabelPlacements.some((anchoredPlacement) => {
         if (anchoredPlacement.globalConnNetId === proposal.globalConnNetId) {
           return false;
         }
-        const anchoredBounds = getLabelBounds3(anchoredPlacement);
+        const anchoredBounds = getAnchoredNetLabelRenderedBounds(anchoredPlacement);
         return boundsOverlap(labelBounds, anchoredBounds) || doesPathIntersectBounds2(addedStubSegment, anchoredBounds);
       })) {
         return true;
@@ -14351,7 +14392,7 @@ var pushInlineTerminalLabelsAwayFromAnchoredLabels = ({
         }
       }
       for (const fixedPlacement of fixedInlinePlacements) {
-        const fixedBounds = getLabelBounds3(fixedPlacement);
+        const fixedBounds = getInlineLabelBounds(fixedPlacement);
         if (boundsOverlap(labelBounds, fixedBounds) || doesPathIntersectBounds2(addedStubSegment, fixedBounds) || fixedPlacement.stubTracePath && doesPathIntersectBounds2(fixedPlacement.stubTracePath, labelBounds)) {
           return true;
         }
@@ -14398,12 +14439,6 @@ var getInlinePlacementBounds = (placement) => {
     maxY: placement.center.y + renderedHeight / 2
   };
 };
-var getAnchoredPlacementBounds = (placement) => ({
-  minX: placement.center.x - placement.width / 2,
-  maxX: placement.center.x + placement.width / 2,
-  minY: placement.center.y - placement.height / 2,
-  maxY: placement.center.y + placement.height / 2
-});
 var InlineNetLabelSolver = class extends BaseSolver {
   inputProblem;
   traces;
@@ -14973,7 +15008,7 @@ var InlineNetLabelSolver = class extends BaseSolver {
         if (anchoredPlacement.globalConnNetId === inlinePlacement.globalConnNetId) {
           continue;
         }
-        const anchoredBounds = getAnchoredPlacementBounds(anchoredPlacement);
+        const anchoredBounds = getAnchoredNetLabelRenderedBounds(anchoredPlacement);
         if (boundsOverlap(inlineBounds, anchoredBounds) || inlinePlacement.stubTracePath && doesPathIntersectBounds3(
           inlinePlacement.stubTracePath,
           anchoredBounds

package/lib/solvers/InlineNetLabelSolver/InlineNetLabelSolver.ts

@@ -21,6 +21,7 @@ import {
   type AxisAlignedSegment,
   getAxisAlignedSegments,
 } from "./getAxisAlignedSegments"
+import { getAnchoredNetLabelRenderedBounds } from "./getAnchoredNetLabelRenderedBounds"
 import { pushAnchoredNetLabelsAwayFromInlineLabels } from "./pushAnchoredNetLabelsAwayFromInlineLabels"
 import { pushInlineTerminalLabelsAwayFromAnchoredLabels } from "./pushInlineTerminalLabelsAwayFromAnchoredLabels"
 
@@ -157,13 +158,6 @@ const getInlinePlacementBounds = (
   }
 }
 
-const getAnchoredPlacementBounds = (placement: NetLabelPlacement): Bounds => ({
-  minX: placement.center.x - placement.width / 2,
-  maxX: placement.center.x + placement.width / 2,
-  minY: placement.center.y - placement.height / 2,
-  maxY: placement.center.y + placement.height / 2,
-})
-
 /**
  * Places "inline net labels" - net names drawn alongside the trace they belong
  * to - for connections that opted in via `allowInlineNetLabel`.
@@ -1007,7 +1001,8 @@ export class InlineNetLabelSolver extends BaseSolver {
         ) {
           continue
         }
-        const anchoredBounds = getAnchoredPlacementBounds(anchoredPlacement)
+        const anchoredBounds =
+          getAnchoredNetLabelRenderedBounds(anchoredPlacement)
         if (
           boundsOverlap(inlineBounds, anchoredBounds) ||
           (inlinePlacement.stubTracePath &&

package/lib/solvers/InlineNetLabelSolver/getAnchoredNetLabelRenderedBounds.ts

@@ -0,0 +1,34 @@
+import type { Bounds } from "@tscircuit/math-utils"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import {
+  getCenterFromAnchor,
+  getRectBounds,
+  NET_LABEL_HORIZONTAL_HEIGHT,
+} from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
+
+/**
+ * Returns the visible schematic-world bounds of a conventional net label.
+ *
+ * Horizontal labels render as tags whose text remains horizontal. Rail inputs
+ * encode their vertical-symbol dimensions in width/height, so a rail label
+ * that later falls back to an x-facing tag can have those extents transposed.
+ * Normalize that tag to the renderer's horizontal envelope before using it as
+ * an obstacle.
+ */
+export const getAnchoredNetLabelRenderedBounds = (
+  placement: NetLabelPlacement,
+): Bounds => {
+  if (placement.orientation !== "x-" && placement.orientation !== "x+") {
+    return getRectBounds(placement.center, placement.width, placement.height)
+  }
+
+  const width = Math.max(placement.width, placement.height)
+  const height = NET_LABEL_HORIZONTAL_HEIGHT
+  const center = getCenterFromAnchor(
+    placement.anchorPoint,
+    placement.orientation,
+    width,
+    height,
+  )
+  return getRectBounds(center, width, height)
+}

package/lib/solvers/InlineNetLabelSolver/pushAnchoredNetLabelsAwayFromInlineLabels.ts

@@ -8,6 +8,7 @@ import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/Sche
 import type { InputProblem } from "lib/types/InputProblem"
 import { dir, type FacingDirection } from "lib/utils/dir"
 import { boundsOverlap, getTextBoxBounds } from "lib/utils/textBoxBounds"
+import { getAnchoredNetLabelRenderedBounds } from "./getAnchoredNetLabelRenderedBounds"
 import type { InlineNetLabelPlacement } from "./InlineNetLabelSolver"
 
 const LABEL_CLEARANCE = 0.05
@@ -15,12 +16,7 @@ const POINT_EPSILON = 1e-6
 const CONTIGUOUS_LABEL_GAP = 0.01
 const MAX_OUTWARD_DISTANCE = 5
 
-const getBounds = (placement: {
-  center: Point
-  width: number
-  height: number
-  axis?: "x" | "y"
-}): Bounds => {
+const getInlineBounds = (placement: InlineNetLabelPlacement): Bounds => {
   const renderedWidth =
     placement.axis === "y" ? placement.height : placement.width
   const renderedHeight =
@@ -79,7 +75,7 @@ const getRequiredOutwardDistance = (
   label: NetLabelPlacement,
   inlineBounds: Bounds[],
 ) => {
-  const labelBounds = getBounds(label)
+  const labelBounds = getAnchoredNetLabelRenderedBounds(label)
 
   if (label.orientation === "x-" || label.orientation === "x+") {
     const nearby = inlineBounds.filter(
@@ -272,8 +268,8 @@ const getContiguousLabelGroup = ({
         [...group].some(
           (memberIndex) =>
             boundsGapOnPerpendicularAxis(
-              getBounds(labels[memberIndex]!),
-              getBounds(label),
+              getAnchoredNetLabelRenderedBounds(labels[memberIndex]!),
+              getAnchoredNetLabelRenderedBounds(label),
               trigger.orientation,
             ) <= CONTIGUOUS_LABEL_GAP,
         )
@@ -316,7 +312,7 @@ export const pushAnchoredNetLabelsAwayFromInlineLabels = ({
     tracePath: trace.tracePath.map((point) => ({ ...point })),
   }))
   const outputLabels = netLabelPlacements.map((label) => ({ ...label }))
-  const inlineBounds = inlineNetLabelPlacements.map(getBounds)
+  const inlineBounds = inlineNetLabelPlacements.map(getInlineBounds)
   const pinMap = getPinMap(inputProblem)
   const chipIdByPinId = new Map<string, string>()
   for (const chip of inputProblem.chips) {
@@ -346,7 +342,7 @@ export const pushAnchoredNetLabelsAwayFromInlineLabels = ({
     for (let iteration = 0; iteration < outputLabels.length; iteration++) {
       let adjustedObstacle = false
       for (const [movingIndex, movingDistance] of distances) {
-        const movingBounds = getBounds(
+        const movingBounds = getAnchoredNetLabelRenderedBounds(
           moveLabel(
             outputLabels[movingIndex]!,
             trigger.orientation,
@@ -361,7 +357,7 @@ export const pushAnchoredNetLabelsAwayFromInlineLabels = ({
           if (group.has(obstacleIndex)) continue
           const obstacle = outputLabels[obstacleIndex]!
           const existingObstacleDistance = distances.get(obstacleIndex) ?? 0
-          const obstacleBounds = getBounds(
+          const obstacleBounds = getAnchoredNetLabelRenderedBounds(
             moveLabel(obstacle, trigger.orientation, existingObstacleDistance),
           )
           if (!boundsOverlap(movingBounds, obstacleBounds)) continue
@@ -374,7 +370,7 @@ export const pushAnchoredNetLabelsAwayFromInlineLabels = ({
             break
           }
           const shoveDistance = getDistanceToShoveBoundsPast(
-            getBounds(obstacle),
+            getAnchoredNetLabelRenderedBounds(obstacle),
             movingBounds,
             trigger.orientation,
           )
@@ -409,7 +405,7 @@ export const pushAnchoredNetLabelsAwayFromInlineLabels = ({
     const finalLabelAt = (labelIndex: number) =>
       proposals.get(labelIndex) ?? outputLabels[labelIndex]!
     for (const [labelIndex, movedLabel] of proposals) {
-      const movedBounds = getBounds(movedLabel)
+      const movedBounds = getAnchoredNetLabelRenderedBounds(movedLabel)
       if (inlineBounds.some((bounds) => boundsOverlap(movedBounds, bounds))) {
         failed = true
         break
@@ -434,7 +430,10 @@ export const pushAnchoredNetLabelsAwayFromInlineLabels = ({
         outputLabels.some(
           (_, otherIndex) =>
             otherIndex !== labelIndex &&
-            boundsOverlap(movedBounds, getBounds(finalLabelAt(otherIndex))),
+            boundsOverlap(
+              movedBounds,
+              getAnchoredNetLabelRenderedBounds(finalLabelAt(otherIndex)),
+            ),
         )
       ) {
         failed = true
@@ -503,7 +502,7 @@ export const pushAnchoredNetLabelsAwayFromInlineLabels = ({
             otherIndex !== labelIndex &&
             pathIntersectsBounds(
               connector.tracePath,
-              getBounds(finalLabelAt(otherIndex)),
+              getAnchoredNetLabelRenderedBounds(finalLabelAt(otherIndex)),
             ),
         )
       if (connectorObstructed) {

package/lib/solvers/InlineNetLabelSolver/pushInlineTerminalLabelsAwayFromAnchoredLabels.ts

@@ -3,6 +3,7 @@ import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetL
 import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
 import type { InputProblem } from "lib/types/InputProblem"
 import { boundsOverlap, getTextBoxBounds } from "lib/utils/textBoxBounds"
+import { getAnchoredNetLabelRenderedBounds } from "./getAnchoredNetLabelRenderedBounds"
 import type { InlineNetLabelPlacement } from "./InlineNetLabelSolver"
 
 type StubDirection = "x+" | "x-" | "y+" | "y-"
@@ -18,12 +19,7 @@ const getStubDirection = (path: [Point, Point]): StubDirection => {
   return end.y >= start.y ? "y+" : "y-"
 }
 
-const getLabelBounds = (placement: {
-  center: Point
-  width: number
-  height: number
-  axis?: "x" | "y"
-}): Bounds => {
+const getInlineLabelBounds = (placement: InlineNetLabelPlacement): Bounds => {
   const renderedWidth =
     placement.axis === "y" ? placement.height : placement.width
   const renderedHeight =
@@ -178,12 +174,13 @@ export const pushInlineTerminalLabelsAwayFromAnchoredLabels = ({
           direction,
           distance,
         )
-        const shiftedBounds = getLabelBounds(shiftedPlacement)
+        const shiftedBounds = getInlineLabelBounds(shiftedPlacement)
         for (const anchoredPlacement of anchoredNetLabelPlacements) {
           if (anchoredPlacement.globalConnNetId === placement.globalConnNetId) {
             continue
           }
-          const anchoredBounds = getLabelBounds(anchoredPlacement)
+          const anchoredBounds =
+            getAnchoredNetLabelRenderedBounds(anchoredPlacement)
           if (!boundsOverlap(shiftedBounds, anchoredBounds)) continue
           requiredAdditionalDistance = Math.max(
             requiredAdditionalDistance,
@@ -209,7 +206,7 @@ export const pushInlineTerminalLabelsAwayFromAnchoredLabels = ({
       const originalEnd = originalPlacement.stubTracePath![1]
       const shiftedEnd = proposal.stubTracePath![1]
       const addedStubSegment: [Point, Point] = [originalEnd, shiftedEnd]
-      const labelBounds = getLabelBounds(proposal)
+      const labelBounds = getInlineLabelBounds(proposal)
       const ownerChipId = group[proposalIndex]!.ownerChipId
 
       if (
@@ -217,7 +214,8 @@ export const pushInlineTerminalLabelsAwayFromAnchoredLabels = ({
           if (anchoredPlacement.globalConnNetId === proposal.globalConnNetId) {
             return false
           }
-          const anchoredBounds = getLabelBounds(anchoredPlacement)
+          const anchoredBounds =
+            getAnchoredNetLabelRenderedBounds(anchoredPlacement)
           return (
             boundsOverlap(labelBounds, anchoredBounds) ||
             doesPathIntersectBounds(addedStubSegment, anchoredBounds)
@@ -267,7 +265,7 @@ export const pushInlineTerminalLabelsAwayFromAnchoredLabels = ({
       }
 
       for (const fixedPlacement of fixedInlinePlacements) {
-        const fixedBounds = getLabelBounds(fixedPlacement)
+        const fixedBounds = getInlineLabelBounds(fixedPlacement)
         if (
           boundsOverlap(labelBounds, fixedBounds) ||
           doesPathIntersectBounds(addedStubSegment, fixedBounds) ||

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/types/InputProblem.ts

@@ -98,7 +98,11 @@ export 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
 
   /**

package/package.json

@@ -5,7 +5,7 @@
     "url": "https://github.com/tscircuit/schematic-trace-solver.git"
   },
   "main": "dist/index.js",
-  "version": "0.0.166",
+  "version": "0.0.168",
   "type": "module",
   "scripts": {
     "start": "cosmos",