@tscircuit/schematic-trace-solver 0.0.109 → 0.0.111

package/dist/index.js

@@ -3259,11 +3259,18 @@ var groupLabelsByChipAndOrientation = ({
   chips
 }) => {
   const groupedLabels = {};
+  const chipIdByPinId = new Map(
+    chips.flatMap(
+      (chip) => chip.pins.map((pin) => [pin.pinId, chip.chipId])
+    )
+  );
   for (const label of labels) {
     if (label.pinIds.length === 0) {
       continue;
     }
-    const chipId = label.pinIds[0].split(".")[0];
+    const pinId = label.pinIds[0];
+    const legacyChipId = pinId.includes(".") ? pinId.split(".")[0] : void 0;
+    const chipId = legacyChipId ?? chipIdByPinId.get(pinId);
     if (!chipId) {
       continue;
     }
@@ -8147,17 +8154,44 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     return Math.min(this.maxSearchDistance, labelLength * 2);
   }
   getLateralColumnMaxDistance(label, orientation, baseAnchor) {
-    const chipId = label.pinIds.map((pid) => this.pinMap[pid]?.chipId).find(Boolean);
-    const chip = chipId ? this.chipObstacleSpatialIndex.chips.find((c) => c.chipId === chipId) : null;
-    if (chip) {
-      if (orientation === "y-")
-        return Math.max(0, baseAnchor.y - chip.bounds.minY);
-      if (orientation === "y+")
-        return Math.max(0, chip.bounds.maxY - baseAnchor.y);
-      if (orientation === "x-")
-        return Math.max(0, baseAnchor.x - chip.bounds.minX);
-      if (orientation === "x+")
-        return Math.max(0, chip.bounds.maxX - baseAnchor.x);
+    const availableOrientations = this.getAvailableOrientations(label);
+    const isSingleVerticalOrientation = availableOrientations.length === 1 && isYOrientation(availableOrientations[0]);
+    const labelChipIds = new Set(
+      label.pinIds.map((pinId) => this.pinMap[pinId]?.chipId).filter((chipId) => Boolean(chipId))
+    );
+    const connectedChips = this.chipObstacleSpatialIndex.chips.filter(
+      (chip) => labelChipIds.has(chip.chipId)
+    );
+    const firstConnectedChipId = label.pinIds.map((pinId) => this.pinMap[pinId]?.chipId).find(Boolean);
+    const firstConnectedChip = connectedChips.find(
+      (chip) => chip.chipId === firstConnectedChipId
+    );
+    const labelChips = isSingleVerticalOrientation ? connectedChips : firstConnectedChip ? [firstConnectedChip] : [];
+    if (labelChips.length > 0) {
+      if (orientation === "y-") {
+        return Math.max(
+          0,
+          ...labelChips.map((chip) => baseAnchor.y - chip.bounds.minY)
+        );
+      }
+      if (orientation === "y+") {
+        return Math.max(
+          0,
+          ...labelChips.map((chip) => chip.bounds.maxY - baseAnchor.y)
+        );
+      }
+      if (orientation === "x-") {
+        return Math.max(
+          0,
+          ...labelChips.map((chip) => baseAnchor.x - chip.bounds.minX)
+        );
+      }
+      if (orientation === "x+") {
+        return Math.max(
+          0,
+          ...labelChips.map((chip) => chip.bounds.maxX - baseAnchor.x)
+        );
+      }
     }
     return this.getSearchDistanceLimit(label, orientation);
   }

package/lib/solvers/AvailableNetOrientationSolver/AvailableNetOrientationSolver.ts

@@ -640,22 +640,61 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     orientation: FacingDirection,
     baseAnchor: Point,
   ) {
-    const chipId = label.pinIds
-      .map((pid) => this.pinMap[pid]?.chipId)
+    const availableOrientations = this.getAvailableOrientations(label)
+    const isSingleVerticalOrientation =
+      availableOrientations.length === 1 &&
+      isYOrientation(availableOrientations[0]!)
+
+    // A vertical rail between components may need to branch laterally and then
+    // search past either connected component before it can use its required
+    // orientation. Keep other labels scoped to their first connected component
+    // so an orientation correction does not move a signal label across the
+    // entire connection.
+    const labelChipIds = new Set(
+      label.pinIds
+        .map((pinId) => this.pinMap[pinId]?.chipId)
+        .filter((chipId): chipId is string => Boolean(chipId)),
+    )
+    const connectedChips = this.chipObstacleSpatialIndex.chips.filter((chip) =>
+      labelChipIds.has(chip.chipId),
+    )
+    const firstConnectedChipId = label.pinIds
+      .map((pinId) => this.pinMap[pinId]?.chipId)
       .find(Boolean)
-    const chip = chipId
-      ? this.chipObstacleSpatialIndex.chips.find((c) => c.chipId === chipId)
-      : null
-
-    if (chip) {
-      if (orientation === "y-")
-        return Math.max(0, baseAnchor.y - chip.bounds.minY)
-      if (orientation === "y+")
-        return Math.max(0, chip.bounds.maxY - baseAnchor.y)
-      if (orientation === "x-")
-        return Math.max(0, baseAnchor.x - chip.bounds.minX)
-      if (orientation === "x+")
-        return Math.max(0, chip.bounds.maxX - baseAnchor.x)
+    const firstConnectedChip = connectedChips.find(
+      (chip) => chip.chipId === firstConnectedChipId,
+    )
+    const labelChips = isSingleVerticalOrientation
+      ? connectedChips
+      : firstConnectedChip
+        ? [firstConnectedChip]
+        : []
+
+    if (labelChips.length > 0) {
+      if (orientation === "y-") {
+        return Math.max(
+          0,
+          ...labelChips.map((chip) => baseAnchor.y - chip.bounds.minY),
+        )
+      }
+      if (orientation === "y+") {
+        return Math.max(
+          0,
+          ...labelChips.map((chip) => chip.bounds.maxY - baseAnchor.y),
+        )
+      }
+      if (orientation === "x-") {
+        return Math.max(
+          0,
+          ...labelChips.map((chip) => baseAnchor.x - chip.bounds.minX),
+        )
+      }
+      if (orientation === "x+") {
+        return Math.max(
+          0,
+          ...labelChips.map((chip) => chip.bounds.maxX - baseAnchor.x),
+        )
+      }
     }
 
     return this.getSearchDistanceLimit(label, orientation)

package/lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/LabelMergingSolver/groupLabelsByChipAndOrientation.ts

@@ -7,7 +7,8 @@ import type { InputProblem } from "lib/types/InputProblem"
  * with the same orientation relative to that chip.
  *
  * @param labels An array of NetLabelPlacement objects to be grouped.
- * @param chips An array of Chip objects from the InputProblem. (Currently not directly used for grouping logic, but part of the signature).
+ * @param chips Chips from the input problem, used to resolve opaque pin IDs to
+ * their owning component.
  * @returns A record where keys are in the format "chipId-orientation" (e.g., "U1-left")
  *          and values are arrays of NetLabelPlacement objects belonging to that group.
  */
@@ -19,6 +20,11 @@ export const groupLabelsByChipAndOrientation = ({
   chips: InputProblem["chips"]
 }): Record<string, NetLabelPlacement[]> => {
   const groupedLabels: Record<string, NetLabelPlacement[]> = {}
+  const chipIdByPinId = new Map(
+    chips.flatMap((chip) =>
+      chip.pins.map((pin) => [pin.pinId, chip.chipId] as const),
+    ),
+  )
 
   for (const label of labels) {
     if (label.pinIds.length === 0) {
@@ -26,10 +32,12 @@ export const groupLabelsByChipAndOrientation = ({
       continue
     }
 
-    // Extract chipId from the first pinId (e.g., "U1.1" -> "U1")
-    const chipId = label.pinIds[0].split(".")[0]
+    const pinId = label.pinIds[0]!
+    // Preserve historical group IDs for component-qualified pins while using
+    // the input's pin ownership for opaque IDs such as schematic_port_123.
+    const legacyChipId = pinId.includes(".") ? pinId.split(".")[0] : undefined
+    const chipId = legacyChipId ?? chipIdByPinId.get(pinId)
     if (!chipId) {
-      // Should not happen if pinIds are well-formed, but good to guard
       continue
     }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/schematic-trace-solver",
   "main": "dist/index.js",
-  "version": "0.0.109",
+  "version": "0.0.111",
   "type": "module",
   "scripts": {
     "start": "cosmos",

package/tests/repros/__snapshots__/repro84-stacked-gnd-label-orientation.snap.svg

@@ -0,0 +1,48 @@
+<svg width="640" height="640" viewBox="0 0 640 640" xmlns="http://www.w3.org/2000/svg"><rect width="100%" height="100%" fill="white"/><g><polyline data-points="0.2,0.3 -0.2,-0.3999999999999999" data-type="line" data-label="" points="315.05882352941177,281.5686274509804 271.13725490196083,358.4313725490196" fill="none" stroke="hsl(157, 100%, 50%, 0.8)" stroke-width="1px" stroke-dasharray="4 2"/></g><g><polyline data-points="0.2,0.30000000000000004 0.2,-0.04999999999999993 -0.2,-0.04999999999999993 -0.2,-0.3999999999999999" data-type="line" data-label="" points="315.05882352941177,281.5686274509804 315.05882352941177,320 271.13725490196083,320 271.13725490196083,358.4313725490196" fill="none" stroke="purple" stroke-width="1px"/></g><g><polyline data-points="0.2,-0.04999999999999993 0.2,6.938893903907228e-17 0.65,6.938893903907228e-17 0.65,-0.10099999999999994" data-type="line" data-label="" points="315.05882352941177,320 315.05882352941177,314.5098039215686 364.47058823529414,314.5098039215686 364.47058823529414,325.59999999999997" fill="none" stroke="purple" stroke-width="1px"/></g><g><rect data-type="rect" data-label="TOP" data-x="0" data-y="1.4" x="249.1764705882353" y="40" width="87.84313725490199" height="241.5686274509804" fill="hsl(93, 100%, 50%, 0.8)" stroke="black" stroke-width="0.009107142857142857"/></g><g><rect data-type="rect" data-label="BOTTOM" data-x="0" data-y="-1.5" x="249.1764705882353" y="358.43137254901967" width="87.84313725490199" height="241.5686274509804" fill="hsl(259, 100%, 50%, 0.8)" stroke="black" stroke-width="0.009107142857142857"/></g><g><rect data-type="rect" data-label="netId: GND
+globalConnNetId: connectivity_net0" data-x="0.65" data-y="-0.31099999999999994" x="338.11764705882354" y="325.59999999999997" width="52.70588235294122" height="46.117647058823536" fill="#00000066" stroke="#000000" stroke-width="0.009107142857142857"/></g><g><circle data-type="point" data-label="TOP.GND
+y-" data-x="0.2" data-y="0.3" cx="315.05882352941177" cy="281.5686274509804" r="3" fill="hsl(116, 100%, 50%, 0.8)"/></g><g><circle data-type="point" data-label="BOTTOM.GND
+y+" data-x="-0.2" data-y="-0.3999999999999999" cx="271.13725490196083" cy="358.4313725490196" r="3" fill="hsl(42, 100%, 50%, 0.8)"/></g><g><circle data-type="point" data-label="anchorPoint
+orientation: y-" data-x="0.65" data-y="-0.10099999999999994" cx="364.47058823529414" cy="325.59999999999997" r="3" fill="hsl(40, 100%, 50%, 0.9)"/></g><g id="crosshair" style="display: none"><line id="crosshair-h" y1="0" y2="640" stroke="#666" stroke-width="0.5"/><line id="crosshair-v" x1="0" x2="640" stroke="#666" stroke-width="0.5"/><text id="coordinates" font-family="monospace" font-size="12" fill="#666"></text></g><script><![CDATA[
+              document.currentScript.parentElement.addEventListener('mousemove', (e) => {
+                const svg = e.currentTarget;
+                const rect = svg.getBoundingClientRect();
+                const x = e.clientX - rect.left;
+                const y = e.clientY - rect.top;
+                const crosshair = svg.getElementById('crosshair');
+                const h = svg.getElementById('crosshair-h');
+                const v = svg.getElementById('crosshair-v');
+                const coords = svg.getElementById('coordinates');
+
+                crosshair.style.display = 'block';
+                h.setAttribute('x1', '0');
+                h.setAttribute('x2', '640');
+                h.setAttribute('y1', y);
+                h.setAttribute('y2', y);
+                v.setAttribute('x1', x);
+                v.setAttribute('x2', x);
+                v.setAttribute('y1', '0');
+                v.setAttribute('y2', '640');
+
+                // Calculate real coordinates using inverse transformation
+                const matrix = {"a":109.80392156862746,"c":0,"e":293.0980392156863,"b":0,"d":-109.80392156862746,"f":314.5098039215686};
+                // Manually invert and apply the affine transform
+                // Since we only use translate and scale, we can directly compute:
+                // x' = (x - tx) / sx
+                // y' = (y - ty) / sy
+                const sx = matrix.a;
+                const sy = matrix.d;
+                const tx = matrix.e;
+                const ty = matrix.f;
+                const realPoint = {
+                  x: (x - tx) / sx,
+                  y: (y - ty) / sy // Flip y back since we used negative scale
+                }
+
+                coords.textContent = `(${realPoint.x.toFixed(2)}, ${realPoint.y.toFixed(2)})`;
+                coords.setAttribute('x', (x + 5).toString());
+                coords.setAttribute('y', (y - 5).toString());
+              });
+              document.currentScript.parentElement.addEventListener('mouseleave', () => {
+                document.currentScript.parentElement.getElementById('crosshair').style.display = 'none';
+              });
+            ]]></script></svg>

package/tests/repros/repro84-stacked-gnd-label-orientation.test.ts

@@ -0,0 +1,69 @@
+import { expect, test } from "bun:test"
+import { SchematicTracePipelineSolver } from "lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver"
+import type { InputProblem } from "lib/types/InputProblem"
+import "tests/fixtures/matcher"
+
+const inputProblem: InputProblem = {
+  chips: [
+    {
+      chipId: "TOP",
+      center: { x: 0, y: 1.4 },
+      width: 0.8,
+      height: 1.4,
+      pins: [
+        {
+          pinId: "TOP.GND",
+          x: 0.2,
+          y: 0.3,
+          _facingDirection: "y-",
+        },
+      ],
+    },
+    {
+      chipId: "BOTTOM",
+      center: { x: 0, y: -1.5 },
+      width: 0.8,
+      height: 1.4,
+      pins: [
+        {
+          pinId: "BOTTOM.GND",
+          x: -0.2,
+          y: -0.4,
+          _facingDirection: "y+",
+        },
+      ],
+    },
+  ],
+  directConnections: [],
+  netConnections: [
+    {
+      netId: "GND",
+      pinIds: ["TOP.GND", "BOTTOM.GND"],
+      netLabelWidth: 0.42,
+      netLabelHeight: 0.48,
+    },
+  ],
+  textBoxes: [],
+  availableNetLabelOrientations: { GND: ["y-"] },
+  maxMspPairDistance: 2.4,
+}
+
+test("repro84 restores GND orientation between stacked components", () => {
+  const solver = new SchematicTracePipelineSolver(inputProblem)
+
+  solver.solve()
+
+  const initialGndLabel = solver.netLabelPlacementSolver!.netLabelPlacements[0]
+  const finalGndLabel =
+    solver.netLabelNetLabelCollisionSolver!.getOutput().netLabelPlacements[0]
+  const traces = solver.netLabelTraceCollisionSolver!.getOutput().traces
+
+  expect(initialGndLabel?.orientation).toBe("x+")
+  expect(finalGndLabel?.orientation).toBe("y-")
+  expect(
+    traces.some((trace) =>
+      trace.mspPairId.startsWith("available-net-orientation"),
+    ),
+  ).toBe(true)
+  expect(solver).toMatchSolverSnapshot(import.meta.path)
+})