@tscircuit/schematic-trace-solver 0.0.19 → 0.0.21

package/dist/index.d.ts

@@ -343,6 +343,7 @@ type OverlappingSameNetTraceGroup = {
     netId?: string;
     overlappingTraces?: SolvedTracePath;
     portOnlyPinId?: string;
+    mspConnectionPairIds?: MspConnectionPairId[];
 };
 interface NetLabelPlacement {
     globalConnNetId: string;

package/dist/index.js

@@ -7311,13 +7311,25 @@ function lengthOfTrace(path) {
   return sum;
 }
 function chooseHostTraceForGroup(params) {
-  const { inputProblem, inputTraceMap, globalConnNetId, fallbackTrace } = params;
+  const {
+    inputProblem,
+    inputTraceMap,
+    globalConnNetId,
+    fallbackTrace,
+    mspConnectionPairIds
+  } = params;
   const chipsById = Object.fromEntries(
     inputProblem.chips.map((c) => [c.chipId, c])
   );
-  const groupTraces = Object.values(inputTraceMap).filter(
+  let groupTraces = Object.values(inputTraceMap).filter(
     (t) => t.globalConnNetId === globalConnNetId
   );
+  if (mspConnectionPairIds && mspConnectionPairIds.length > 0) {
+    const idSet = new Set(mspConnectionPairIds);
+    groupTraces = groupTraces.filter(
+      (t) => t.mspConnectionPairIds.some((id) => idSet.has(id))
+    );
+  }
   const chipIdsInGroup = /* @__PURE__ */ new Set();
   for (const t of groupTraces) {
     chipIdsInGroup.add(t.pins[0].chipId);
@@ -7566,15 +7578,19 @@ var SingleNetLabelPlacementSolver = class extends BaseSolver {
       inputProblem: this.inputProblem,
       inputTraceMap: this.inputTraceMap,
       globalConnNetId: groupId,
-      fallbackTrace: this.overlappingSameNetTraceGroup.overlappingTraces
+      fallbackTrace: this.overlappingSameNetTraceGroup.overlappingTraces,
+      mspConnectionPairIds: this.overlappingSameNetTraceGroup.mspConnectionPairIds
     });
     if (!host) {
       this.failed = true;
       this.error = "No host trace found for net label placement";
       return;
     }
+    const traceIdSet = new Set(
+      this.overlappingSameNetTraceGroup.mspConnectionPairIds ?? []
+    );
     const tracesToScanBase = Object.values(this.inputTraceMap).filter(
-      (t) => t.globalConnNetId === groupId
+      (t) => t.globalConnNetId === groupId && (traceIdSet.size === 0 || t.mspConnectionPairIds.some((id) => traceIdSet.has(id)))
     );
     const tracesToScan = this.availableOrientations.length === 1 ? [
       host,
@@ -7831,10 +7847,18 @@ var NetLabelPlacementSolver = class extends BaseSolver {
               }
             }
           }
+          const mspConnectionPairIds = Array.from(
+            new Set(
+              compTraces.flatMap(
+                (t) => t.mspConnectionPairIds ?? [t.mspPairId]
+              )
+            )
+          );
           groups.push({
             globalConnNetId,
             netId: userNetId,
-            overlappingTraces: rep
+            overlappingTraces: rep,
+            mspConnectionPairIds
           });
         } else {
           for (const p of component) {

package/lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver.ts

@@ -19,6 +19,7 @@ export type OverlappingSameNetTraceGroup = {
   netId?: string
   overlappingTraces?: SolvedTracePath
   portOnlyPinId?: string
+  mspConnectionPairIds?: MspConnectionPairId[]
 }
 
 export interface NetLabelPlacement {
@@ -196,11 +197,19 @@ export class NetLabelPlacementSolver extends BaseSolver {
               }
             }
           }
+          const mspConnectionPairIds = Array.from(
+            new Set(
+              compTraces.flatMap(
+                (t) => t.mspConnectionPairIds ?? [t.mspPairId],
+              ),
+            ),
+          )
 
           groups.push({
             globalConnNetId,
             netId: userNetId,
             overlappingTraces: rep,
+            mspConnectionPairIds,
           })
         } else {
           // No traces in this component: place label at each pin that has a user net id

package/lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/SingleNetLabelPlacementSolver.ts

@@ -121,6 +121,8 @@ export class SingleNetLabelPlacementSolver extends BaseSolver {
       inputTraceMap: this.inputTraceMap,
       globalConnNetId: groupId,
       fallbackTrace: this.overlappingSameNetTraceGroup.overlappingTraces,
+      mspConnectionPairIds:
+        this.overlappingSameNetTraceGroup.mspConnectionPairIds,
     })
 
     if (!host) {
@@ -130,8 +132,14 @@ export class SingleNetLabelPlacementSolver extends BaseSolver {
     }
 
     // Ensure we traverse the host path starting at the segment attached to the largest chip's pin
+    const traceIdSet = new Set(
+      this.overlappingSameNetTraceGroup.mspConnectionPairIds ?? [],
+    )
     const tracesToScanBase = Object.values(this.inputTraceMap).filter(
-      (t) => t.globalConnNetId === groupId,
+      (t) =>
+        t.globalConnNetId === groupId &&
+        (traceIdSet.size === 0 ||
+          t.mspConnectionPairIds.some((id) => traceIdSet.has(id))),
     )
     const tracesToScan =
       this.availableOrientations.length === 1

package/lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/host.ts

@@ -17,17 +17,29 @@ export function chooseHostTraceForGroup(params: {
   inputTraceMap: Record<MspConnectionPairId, SolvedTracePath>
   globalConnNetId: string
   fallbackTrace?: SolvedTracePath
+  mspConnectionPairIds?: MspConnectionPairId[]
 }): SolvedTracePath | undefined {
-  const { inputProblem, inputTraceMap, globalConnNetId, fallbackTrace } = params
-
+  const {
+    inputProblem,
+    inputTraceMap,
+    globalConnNetId,
+    fallbackTrace,
+    mspConnectionPairIds,
+  } = params
   const chipsById: Record<string, InputChip> = Object.fromEntries(
     inputProblem.chips.map((c) => [c.chipId, c]),
   )
 
-  const groupTraces = Object.values(inputTraceMap).filter(
+  let groupTraces = Object.values(inputTraceMap).filter(
     (t) => t.globalConnNetId === globalConnNetId,
   )
 
+  if (mspConnectionPairIds && mspConnectionPairIds.length > 0) {
+    const idSet = new Set(mspConnectionPairIds)
+    groupTraces = groupTraces.filter((t) =>
+      t.mspConnectionPairIds.some((id) => idSet.has(id)),
+    )
+  }
   const chipIdsInGroup = new Set<string>()
   for (const t of groupTraces) {
     chipIdsInGroup.add(t.pins[0].chipId)

package/package.json

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

package/site/examples/example08.page.tsx

@@ -0,0 +1,94 @@
+import { PipelineDebugger } from "site/components/PipelineDebugger"
+import type { InputProblem } from "lib/types/InputProblem"
+
+const inputProblem: InputProblem = {
+  chips: [
+    {
+      chipId: "schematic_component_0",
+      center: {
+        x: 4,
+        y: 0,
+      },
+      width: 1.1025814,
+      height: 0.388910699999999,
+      pins: [
+        {
+          pinId: "R1.1",
+          x: 3.4487093,
+          y: 0.0002732499999993365,
+        },
+        {
+          pinId: "R1.2",
+          x: 4.5512907,
+          y: -0.0002732499999993365,
+        },
+      ],
+    },
+    {
+      chipId: "schematic_component_1",
+      center: {
+        x: 0,
+        y: 0,
+      },
+      width: 1.2000000000000002,
+      height: 1,
+      pins: [
+        {
+          pinId: "U1.1",
+          x: -0.6000000000000001,
+          y: 0.30000000000000004,
+        },
+        {
+          pinId: "U1.2",
+          x: -0.6000000000000001,
+          y: 0.10000000000000003,
+        },
+        {
+          pinId: "U1.3",
+          x: -0.6000000000000001,
+          y: -0.09999999999999998,
+        },
+        {
+          pinId: "U1.4",
+          x: -0.6000000000000001,
+          y: -0.30000000000000004,
+        },
+        {
+          pinId: "U1.5",
+          x: 0.6000000000000001,
+          y: -0.30000000000000004,
+        },
+        {
+          pinId: "U1.6",
+          x: 0.6000000000000001,
+          y: -0.10000000000000003,
+        },
+        {
+          pinId: "U1.7",
+          x: 0.6000000000000001,
+          y: 0.09999999999999998,
+        },
+        {
+          pinId: "U1.8",
+          x: 0.6000000000000001,
+          y: 0.30000000000000004,
+        },
+      ],
+    },
+  ],
+  directConnections: [
+    {
+      pinIds: ["U1.1", "R1.1"],
+      netId: "chip.U1 > port.pin1 to R1.1",
+    },
+    {
+      pinIds: ["U1.6", "R1.2"],
+      netId: "chip.U1 > port.pin6 to R1.2",
+    },
+  ],
+  netConnections: [],
+  availableNetLabelOrientations: {},
+  maxMspPairDistance: 2,
+}
+
+export default () => <PipelineDebugger inputProblem={inputProblem} />