@tscircuit/schematic-trace-solver 0.0.14 → 0.0.16

package/dist/index.d.ts

@@ -347,6 +347,19 @@ type OverlappingSameNetTraceGroup = {
 interface NetLabelPlacement {
     globalConnNetId: string;
     dcConnNetId?: string;
+    /**
+     * Optional user-provided net identifier (if present in the input problem).
+     */
+    netId?: string;
+    /**
+     * MSP pair ids that the label is associated with. Port-only labels use [].
+     */
+    mspConnectionPairIds: MspConnectionPairId[];
+    /**
+     * Pin ids relevant to this label. For a host trace, the two pins of that pair;
+     * for a port-only label, the single port pin id.
+     */
+    pinIds: PinId[];
     orientation: FacingDirection;
     /**
      * The anchor point is the point on the trace where the net label connects
@@ -410,6 +423,7 @@ declare class SchematicTracePipelineSolver extends BaseSolver {
     inputProblem: InputProblem;
     pipelineDef: (PipelineStep<typeof MspConnectionPairSolver> | PipelineStep<typeof GuidelinesSolver> | PipelineStep<typeof SchematicTraceLinesSolver> | PipelineStep<typeof TraceOverlapShiftSolver> | PipelineStep<typeof NetLabelPlacementSolver>)[];
     constructor(inputProblem: InputProblem);
+    getConstructorParams(): ConstructorParameters<typeof SchematicTracePipelineSolver>[0];
     currentPipelineStepIndex: number;
     private cloneAndCorrectInputProblem;
     _step(): void;

package/dist/index.js

@@ -6162,6 +6162,8 @@ var calculateElbowBends = (p1, p2, overshootAmount) => {
     const last = result[result.length - 1];
     if (last.x !== pt.x || last.y !== pt.y) result.push(pt);
   };
+  const yAligned = Math.abs(p1.y - p2.y) <= Math.max(1e-6, overshootAmount * 0.1);
+  const xAligned = Math.abs(p1.x - p2.x) <= Math.max(1e-6, overshootAmount * 0.1);
   if (startDir === "none" && endDir === "none") {
     push({
       x: midX,
@@ -6188,7 +6190,7 @@ var calculateElbowBends = (p1, p2, overshootAmount) => {
     x: p2.x,
     y: p1.y
   });
-  else if (p1.x === p2.x) {
+  else if (xAligned) {
     push({
       x: p1.x + overshootAmount,
       y: p1.y
@@ -6245,7 +6247,7 @@ var calculateElbowBends = (p1, p2, overshootAmount) => {
       y: (p1.y + p2.y) / 2
     });
   }
-  else if (startDir === "x+" && endDir === "x+" && p1.y !== p2.y) {
+  else if (startDir === "x+" && endDir === "x+" && !yAligned) {
     const commonX = Math.max(p1.x + overshootAmount, p2Target.x);
     push({
       x: commonX,
@@ -6255,7 +6257,7 @@ var calculateElbowBends = (p1, p2, overshootAmount) => {
       x: commonX,
       y: p2.y
     });
-  } else if (startDir === "x+" && endDir === "x+" && p1.y === p2.y) {
+  } else if (startDir === "x+" && endDir === "x+" && yAligned) {
     push({
       x: p1.x + overshootAmount,
       y: p1.y
@@ -6272,7 +6274,7 @@ var calculateElbowBends = (p1, p2, overshootAmount) => {
       x: p2.x + overshootAmount,
       y: p2.y
     });
-  } else if (startDir === "x+" && endDir === "y-") if (p1.x === p2.x && p1.y <= p2.y) {
+  } else if (startDir === "x+" && endDir === "y-") if (xAligned && p1.y <= p2.y) {
     push({
       x: p1.x + overshootAmount,
       y: p1.y
@@ -6285,7 +6287,7 @@ var calculateElbowBends = (p1, p2, overshootAmount) => {
       x: p2.x,
       y: midY
     });
-  } else if (p1.x === p2.x && p1.y > p2.y) {
+  } else if (xAligned && p1.y > p2.y) {
     push({
       x: p1.x + overshootAmount,
       y: p1.y
@@ -6675,6 +6677,7 @@ var SchematicTraceSingleLineSolver = class extends BaseSolver {
         overshoot: 0.2
       }
     );
+    console.log("baseElbow", this.baseElbow);
     const { elbowVariants, movableSegments } = generateElbowVariants({
       baseElbow: this.baseElbow,
       guidelines: this.guidelines
@@ -7431,6 +7434,9 @@ function solveNetLabelPlacementForPortOnlyPin(params) {
     const placement = {
       globalConnNetId: overlappingSameNetTraceGroup.globalConnNetId,
       dcConnNetId: void 0,
+      netId: overlappingSameNetTraceGroup.netId,
+      mspConnectionPairIds: [],
+      pinIds: [pinId],
       orientation,
       anchorPoint: anchor,
       width,
@@ -7664,7 +7670,9 @@ var SingleNetLabelPlacementSolver = class extends BaseSolver {
                   height,
                   center,
                   hostSegIndex: si,
-                  dcConnNetId: curr.dcConnNetId
+                  dcConnNetId: curr.dcConnNetId,
+                  mspPairId: curr.mspPairId,
+                  pinIds: [curr.pins[0].pinId, curr.pins[1].pinId]
                 };
               }
               continue;
@@ -7672,6 +7680,9 @@ var SingleNetLabelPlacementSolver = class extends BaseSolver {
             this.netLabelPlacement = {
               globalConnNetId: this.overlappingSameNetTraceGroup.globalConnNetId,
               dcConnNetId: curr.dcConnNetId,
+              netId: this.overlappingSameNetTraceGroup.netId,
+              mspConnectionPairIds: [curr.mspPairId],
+              pinIds: [curr.pins[0].pinId, curr.pins[1].pinId],
               orientation,
               anchorPoint: anchor,
               width,
@@ -7688,6 +7699,9 @@ var SingleNetLabelPlacementSolver = class extends BaseSolver {
       this.netLabelPlacement = {
         globalConnNetId: this.overlappingSameNetTraceGroup.globalConnNetId,
         dcConnNetId: bestCandidate.dcConnNetId,
+        netId: this.overlappingSameNetTraceGroup.netId,
+        mspConnectionPairIds: [bestCandidate.mspPairId],
+        pinIds: bestCandidate.pinIds,
         orientation: bestCandidate.orientation,
         anchorPoint: bestCandidate.anchor,
         width: bestCandidate.width,
@@ -8238,6 +8252,9 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
     this.timeSpentOnPhase = {};
     this.firstIterationOfPhase = {};
   }
+  getConstructorParams() {
+    return this.inputProblem;
+  }
   currentPipelineStepIndex = 0;
   cloneAndCorrectInputProblem(original) {
     const cloned = structuredClone({

package/lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver.ts

@@ -1,5 +1,5 @@
 import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
-import type { InputProblem } from "lib/types/InputProblem"
+import type { InputProblem, PinId } from "lib/types/InputProblem"
 import type { SolvedTracePath } from "../SchematicTraceLinesSolver/SchematicTraceLinesSolver"
 import type { MspConnectionPairId } from "../MspConnectionPairSolver/MspConnectionPairSolver"
 import { SingleNetLabelPlacementSolver } from "./SingleNetLabelPlacementSolver/SingleNetLabelPlacementSolver"
@@ -24,6 +24,19 @@ export type OverlappingSameNetTraceGroup = {
 export interface NetLabelPlacement {
   globalConnNetId: string
   dcConnNetId?: string
+  /**
+   * Optional user-provided net identifier (if present in the input problem).
+   */
+  netId?: string
+  /**
+   * MSP pair ids that the label is associated with. Port-only labels use [].
+   */
+  mspConnectionPairIds: MspConnectionPairId[]
+  /**
+   * Pin ids relevant to this label. For a host trace, the two pins of that pair;
+   * for a port-only label, the single port pin id.
+   */
+  pinIds: PinId[]
   orientation: FacingDirection
 
   /**

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

@@ -3,7 +3,7 @@ import type {
   NetLabelPlacement,
   OverlappingSameNetTraceGroup,
 } from "../NetLabelPlacementSolver"
-import type { InputProblem } from "lib/types/InputProblem"
+import type { InputProblem, PinId } from "lib/types/InputProblem"
 import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
 import type { MspConnectionPairId } from "lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver"
 import type { FacingDirection } from "lib/utils/dir"
@@ -172,6 +172,8 @@ export class SingleNetLabelPlacementSolver extends BaseSolver {
       center: { x: number; y: number }
       hostSegIndex: number
       dcConnNetId: string
+      mspPairId: MspConnectionPairId
+      pinIds: PinId[]
     } | null = null
     let bestScore = -Infinity
 
@@ -285,6 +287,8 @@ export class SingleNetLabelPlacementSolver extends BaseSolver {
                   center,
                   hostSegIndex: si,
                   dcConnNetId: curr.dcConnNetId,
+                  mspPairId: curr.mspPairId,
+                  pinIds: [curr.pins[0].pinId, curr.pins[1].pinId],
                 }
               }
               // Continue traversing to prioritize the furthest valid point
@@ -295,6 +299,9 @@ export class SingleNetLabelPlacementSolver extends BaseSolver {
               globalConnNetId:
                 this.overlappingSameNetTraceGroup.globalConnNetId,
               dcConnNetId: curr.dcConnNetId,
+              netId: this.overlappingSameNetTraceGroup.netId,
+              mspConnectionPairIds: [curr.mspPairId],
+              pinIds: [curr.pins[0].pinId, curr.pins[1].pinId],
               orientation,
               anchorPoint: anchor,
               width,
@@ -312,6 +319,9 @@ export class SingleNetLabelPlacementSolver extends BaseSolver {
       this.netLabelPlacement = {
         globalConnNetId: this.overlappingSameNetTraceGroup.globalConnNetId,
         dcConnNetId: bestCandidate.dcConnNetId,
+        netId: this.overlappingSameNetTraceGroup.netId,
+        mspConnectionPairIds: [bestCandidate.mspPairId],
+        pinIds: bestCandidate.pinIds,
         orientation: bestCandidate.orientation,
         anchorPoint: bestCandidate.anchor,
         width: bestCandidate.width,

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

@@ -159,6 +159,9 @@ export function solveNetLabelPlacementForPortOnlyPin(params: {
     const placement: NetLabelPlacement = {
       globalConnNetId: overlappingSameNetTraceGroup.globalConnNetId,
       dcConnNetId: undefined,
+      netId: overlappingSameNetTraceGroup.netId,
+      mspConnectionPairIds: [],
+      pinIds: [pinId],
       orientation,
       anchorPoint: anchor,
       width,

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/SchematicTraceSingleLineSolver.ts

@@ -73,6 +73,7 @@ export class SchematicTraceSingleLineSolver extends BaseSolver {
         overshoot: 0.2,
       },
     )
+    console.log("baseElbow", this.baseElbow)
 
     const { elbowVariants, movableSegments } = generateElbowVariants({
       baseElbow: this.baseElbow,

package/lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts

@@ -146,6 +146,12 @@ export class SchematicTracePipelineSolver extends BaseSolver {
     this.firstIterationOfPhase = {}
   }
 
+  override getConstructorParams(): ConstructorParameters<
+    typeof SchematicTracePipelineSolver
+  >[0] {
+    return this.inputProblem
+  }
+
   currentPipelineStepIndex = 0
 
   private cloneAndCorrectInputProblem(original: InputProblem): InputProblem {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/schematic-trace-solver",
   "main": "dist/index.js",
-  "version": "0.0.14",
+  "version": "0.0.16",
   "type": "module",
   "scripts": {
     "start": "cosmos",
@@ -14,7 +14,7 @@
     "@react-hook/resize-observer": "^2.0.2",
     "@tscircuit/math-utils": "^0.0.19",
     "@types/bun": "latest",
-    "calculate-elbow": "^0.0.10",
+    "calculate-elbow": "^0.0.11",
     "connectivity-map": "^1.0.0",
     "flatbush": "^4.5.0",
     "graphics-debug": "^0.0.62",
@@ -26,5 +26,8 @@
   "peerDependencies": {
     "typescript": "^5"
   },
-  "dependencies": {}
+  "dependencies": {
+    "react": "^19.1.1",
+    "react-dom": "^19.1.1"
+  }
 }

package/site/PasteInput.page.tsx

@@ -0,0 +1,83 @@
+import type { InputProblem } from "lib/types/InputProblem"
+import { PipelineDebugger } from "site/components/PipelineDebugger"
+import { useState } from "react"
+
+export default () => {
+  const [inputText, setInputText] = useState("")
+  const [inputProblem, setInputProblem] = useState<InputProblem | null>(null)
+  const [error, setError] = useState<string | null>(null)
+
+  const handleOpenDebugger = () => {
+    try {
+      setError(null)
+      let parsed: InputProblem
+
+      const trimmedInput = inputText.trim()
+      if (trimmedInput.startsWith("{") || trimmedInput.startsWith("[")) {
+        parsed = JSON.parse(trimmedInput)
+      } else {
+        parsed = eval(`(${trimmedInput})`)
+      }
+
+      setInputProblem(parsed)
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Invalid input format")
+    }
+  }
+
+  if (inputProblem) {
+    return <PipelineDebugger inputProblem={inputProblem} />
+  }
+
+  return (
+    <div style={{ padding: "20px", maxWidth: "800px", margin: "0 auto" }}>
+      <h1>Paste Input Problem</h1>
+      <p>Paste a JSON or JavaScript object representing an InputProblem:</p>
+
+      <textarea
+        value={inputText}
+        onChange={(e) => setInputText(e.target.value)}
+        placeholder="Paste your InputProblem here..."
+        style={{
+          width: "100%",
+          height: "400px",
+          fontFamily: "monospace",
+          padding: "10px",
+          border: "1px solid #ccc",
+          borderRadius: "4px",
+          marginBottom: "10px",
+        }}
+      />
+
+      {error && (
+        <div
+          style={{
+            color: "red",
+            marginBottom: "10px",
+            padding: "10px",
+            backgroundColor: "#fee",
+            borderRadius: "4px",
+          }}
+        >
+          Error: {error}
+        </div>
+      )}
+
+      <button
+        onClick={handleOpenDebugger}
+        disabled={!inputText.trim()}
+        style={{
+          padding: "10px 20px",
+          backgroundColor: inputText.trim() ? "#007bff" : "#ccc",
+          color: "white",
+          border: "none",
+          borderRadius: "4px",
+          cursor: inputText.trim() ? "pointer" : "not-allowed",
+          fontSize: "16px",
+        }}
+      >
+        Open Debugger
+      </button>
+    </div>
+  )
+}

package/site/components/DownloadDropdown.tsx

@@ -0,0 +1,172 @@
+import { useState, useRef, useEffect } from "react"
+import type { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
+
+interface DownloadDropdownProps {
+  solver: BaseSolver
+  className?: string
+}
+
+export const DownloadDropdown = ({
+  solver,
+  className = "",
+}: DownloadDropdownProps) => {
+  const [isOpen, setIsOpen] = useState(false)
+  const dropdownRef = useRef<HTMLDivElement>(null)
+
+  useEffect(() => {
+    const handleClickOutside = (event: MouseEvent) => {
+      if (
+        dropdownRef.current &&
+        !dropdownRef.current.contains(event.target as Node)
+      ) {
+        setIsOpen(false)
+      }
+    }
+
+    document.addEventListener("mousedown", handleClickOutside)
+    return () => document.removeEventListener("mousedown", handleClickOutside)
+  }, [])
+
+  const downloadJSON = () => {
+    try {
+      if (typeof solver.getConstructorParams !== "function") {
+        alert(
+          `getConstructorParams() is not implemented for ${solver.constructor.name}`,
+        )
+        return
+      }
+
+      const params = solver.getConstructorParams()
+      const blob = new Blob([JSON.stringify(params, null, 2)], {
+        type: "application/json",
+      })
+      const url = URL.createObjectURL(blob)
+      const a = document.createElement("a")
+      a.href = url
+      a.download = `${solver.constructor.name}_params.json`
+      a.click()
+      URL.revokeObjectURL(url)
+    } catch (error) {
+      alert(
+        `Error downloading params for ${solver.constructor.name}: ${error instanceof Error ? error.message : String(error)}`,
+      )
+    }
+    setIsOpen(false)
+  }
+
+  const downloadPageTsx = () => {
+    try {
+      const params = solver.getConstructorParams()
+      const solverName = solver.constructor.name
+      const isSchematicTracePipelineSolver =
+        solverName === "SchematicTracePipelineSolver"
+
+      let content: string
+
+      if (isSchematicTracePipelineSolver) {
+        content = `import { PipelineDebugger } from "site/components/PipelineDebugger"
+import type { InputProblem } from "lib/types/InputProblem"
+
+const inputProblem: InputProblem = ${JSON.stringify(params, null, 2)}
+
+export default () => <PipelineDebugger inputProblem={inputProblem} />
+`
+      } else {
+        content = `import { useMemo } from "react"
+import { GenericSolverDebugger } from "../components/GenericSolverDebugger"
+import { ${solverName} } from "lib/solvers/${solverName}/${solverName}"
+
+const input = ${JSON.stringify(params, null, 2)}
+
+export default () => {
+  const solver = useMemo(() => {
+    return new ${solverName}(input as any)
+  }, [])
+  return <GenericSolverDebugger solver={solver} />
+}
+`
+      }
+
+      const blob = new Blob([content], { type: "text/plain" })
+      const url = URL.createObjectURL(blob)
+      const a = document.createElement("a")
+      a.href = url
+      a.download = `${solverName}.page.tsx`
+      a.click()
+      URL.revokeObjectURL(url)
+    } catch (error) {
+      alert(
+        `Error generating page.tsx for ${solver.constructor.name}: ${error instanceof Error ? error.message : String(error)}`,
+      )
+    }
+    setIsOpen(false)
+  }
+
+  const downloadTestTs = () => {
+    try {
+      const params = solver.getConstructorParams()
+      const solverName = solver.constructor.name
+
+      const content = `import { ${solverName} } from "lib/solvers/${solverName}/${solverName}"
+
+test("${solverName} should solve problem correctly", () => {
+  const input = ${JSON.stringify(params, null, 2)}
+  
+  const solver = new ${solverName}(input as any)
+  const result = solver.solve()
+  
+  expect(result).toBeDefined()
+  // Add more specific assertions based on expected output
+})
+`
+
+      const blob = new Blob([content], { type: "text/plain" })
+      const url = URL.createObjectURL(blob)
+      const a = document.createElement("a")
+      a.href = url
+      a.download = `${solverName}.test.ts`
+      a.click()
+      URL.revokeObjectURL(url)
+    } catch (error) {
+      alert(
+        `Error generating test.ts for ${solver.constructor.name}: ${error instanceof Error ? error.message : String(error)}`,
+      )
+    }
+    setIsOpen(false)
+  }
+
+  return (
+    <div className={`relative ${className}`} ref={dropdownRef}>
+      <button
+        className="px-2 py-1 rounded text-xs cursor-pointer"
+        onClick={() => setIsOpen(!isOpen)}
+        title={`Download options for ${solver.constructor.name}`}
+      >
+        {solver.constructor.name}
+      </button>
+
+      {isOpen && (
+        <div className="absolute top-full left-0 mt-1 bg-white border border-gray-300 rounded shadow-lg z-10 min-w-[150px]">
+          <button
+            className="w-full text-left px-3 py-2 hover:bg-gray-100 text-xs"
+            onClick={downloadJSON}
+          >
+            Download JSON
+          </button>
+          <button
+            className="w-full text-left px-3 py-2 hover:bg-gray-100 text-xs"
+            onClick={downloadPageTsx}
+          >
+            Download page.tsx
+          </button>
+          <button
+            className="w-full text-left px-3 py-2 hover:bg-gray-100 text-xs"
+            onClick={downloadTestTs}
+          >
+            Download test.ts
+          </button>
+        </div>
+      )}
+    </div>
+  )
+}

package/site/components/SolverBreadcrumbInputDownloader.tsx

@@ -1,4 +1,5 @@
 import type { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
+import { DownloadDropdown } from "./DownloadDropdown"
 
 export const getSolverChain = (solver: BaseSolver): BaseSolver[] => {
   if (!solver.activeSubSolver) {
@@ -17,44 +18,12 @@ export const SolverBreadcrumbInputDownloader = ({
 }) => {
   const solverChain = getSolverChain(solver)
 
-  const downloadSolverParams = (s: BaseSolver) => {
-    try {
-      if (typeof s.getConstructorParams !== "function") {
-        alert(
-          `getConstructorParams() is not implemented for ${s.constructor.name}`,
-        )
-        return
-      }
-
-      const params = s.getConstructorParams()
-      const blob = new Blob([JSON.stringify(params, null, 2)], {
-        type: "application/json",
-      })
-      const url = URL.createObjectURL(blob)
-      const a = document.createElement("a")
-      a.href = url
-      a.download = `${s.constructor.name}_params.json`
-      a.click()
-      URL.revokeObjectURL(url)
-    } catch (error) {
-      alert(
-        `Error downloading params for ${s.constructor.name}: ${error instanceof Error ? error.message : String(error)}`,
-      )
-    }
-  }
-
   return (
     <div className="flex gap-1 items-center text-sm pt-1">
       {solverChain.map((s, index) => (
         <div key={s.constructor.name} className="flex items-center">
           {index > 0 && <span className="text-gray-400 mx-1">→</span>}
-          <button
-            className="px-2 py-1 rounded text-xs cursor-pointer"
-            onClick={() => downloadSolverParams(s)}
-            title={`Download constructor params for ${s.constructor.name}`}
-          >
-            {s.constructor.name}
-          </button>
+          <DownloadDropdown solver={s} />
         </div>
       ))}
     </div>

package/site/examples/example06.page.tsx

@@ -0,0 +1,60 @@
+import { PipelineDebugger } from "site/components/PipelineDebugger"
+import type { InputProblem } from "lib/types/InputProblem"
+
+const inputProblem: InputProblem = {
+  chips: [
+    {
+      chipId: "schematic_component_0",
+      center: {
+        x: -3,
+        y: 0,
+      },
+      width: 1.102581400000001,
+      height: 0.388910699999999,
+      pins: [
+        {
+          pinId: "R1.1",
+          x: -3.5512907000000005,
+          y: 0.0002732499999993365,
+        },
+        {
+          pinId: "R1.2",
+          x: -2.4487092999999995,
+          y: -0.0002732499999993365,
+        },
+      ],
+    },
+    {
+      chipId: "schematic_component_1",
+      center: {
+        x: 3,
+        y: 0,
+      },
+      width: 1.102418600000001,
+      height: 0.8400173000000031,
+      pins: [
+        {
+          pinId: "C1.1",
+          x: 2.4487906999999995,
+          y: -0.00027334999999961695,
+        },
+        {
+          pinId: "C1.2",
+          x: 3.5512093000000005,
+          y: 0.00027334999999961695,
+        },
+      ],
+    },
+  ],
+  directConnections: [
+    {
+      pinIds: ["R1.1", "C1.1"],
+      netId: ".R1 > .pin1 to .C1 > .pin1",
+    },
+  ],
+  netConnections: [],
+  availableNetLabelOrientations: {},
+  maxMspPairDistance: 2,
+}
+
+export default () => <PipelineDebugger inputProblem={inputProblem} />