@tscircuit/schematic-trace-solver 0.0.5 → 0.0.7

package/dist/index.d.ts

@@ -409,6 +409,7 @@ declare class SchematicTracePipelineSolver extends BaseSolver {
     pipelineDef: (PipelineStep<typeof MspConnectionPairSolver> | PipelineStep<typeof GuidelinesSolver> | PipelineStep<typeof SchematicTraceLinesSolver> | PipelineStep<typeof TraceOverlapShiftSolver> | PipelineStep<typeof NetLabelPlacementSolver>)[];
     constructor(inputProblem: InputProblem);
     currentPipelineStepIndex: number;
+    private cloneAndCorrectInputProblem;
     _step(): void;
     solveUntilPhase(phase: string): void;
     getCurrentPhase(): string;

package/dist/index.js

@@ -7865,6 +7865,57 @@ var GuidelinesSolver = class extends BaseSolver {
   }
 };
 
+// lib/solvers/SchematicTracePipelineSolver/correctPinsInsideChip.ts
+var correctPinsInsideChips = (problem) => {
+  for (const chip of problem.chips) {
+    const bounds = getInputChipBounds(chip);
+    for (const pin of chip.pins) {
+      const isInside = pin.x > bounds.minX && pin.x < bounds.maxX && pin.y > bounds.minY && pin.y < bounds.maxY;
+      if (!isInside) continue;
+      const distLeft = pin.x - bounds.minX;
+      const distRight = bounds.maxX - pin.x;
+      const distBottom = pin.y - bounds.minY;
+      const distTop = bounds.maxY - pin.y;
+      const minDist = Math.min(distLeft, distRight, distBottom, distTop);
+      if (minDist === distLeft) {
+        pin.x = bounds.minX;
+      } else if (minDist === distRight) {
+        pin.x = bounds.maxX;
+      } else if (minDist === distBottom) {
+        pin.y = bounds.minY;
+      } else {
+        pin.y = bounds.maxY;
+      }
+      pin._facingDirection = void 0;
+    }
+  }
+};
+
+// lib/solvers/SchematicTracePipelineSolver/expandChipsToFitPins.ts
+var expandChipsToFitPins = (problem) => {
+  for (const chip of problem.chips) {
+    const halfWidth = chip.width / 2;
+    const halfHeight = chip.height / 2;
+    let maxDx = 0;
+    let maxDy = 0;
+    for (const pin of chip.pins) {
+      const dx = Math.abs(pin.x - chip.center.x);
+      const dy = Math.abs(pin.y - chip.center.y);
+      if (dx > maxDx) maxDx = dx;
+      if (dy > maxDy) maxDy = dy;
+    }
+    const newHalfWidth = Math.max(halfWidth, maxDx);
+    const newHalfHeight = Math.max(halfHeight, maxDy);
+    if (newHalfWidth > halfWidth || newHalfHeight > halfHeight) {
+      chip.width = newHalfWidth * 2;
+      chip.height = newHalfHeight * 2;
+      for (const pin of chip.pins) {
+        pin._facingDirection = void 0;
+      }
+    }
+  }
+};
+
 // lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts
 function definePipelineStep(solverName, solverClass, getConstructorParams, opts = {}) {
   return {
@@ -7963,7 +8014,7 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
   ];
   constructor(inputProblem) {
     super();
-    this.inputProblem = inputProblem;
+    this.inputProblem = this.cloneAndCorrectInputProblem(inputProblem);
     this.MAX_ITERATIONS = 1e6;
     this.startTimeOfPhase = {};
     this.endTimeOfPhase = {};
@@ -7971,6 +8022,15 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
     this.firstIterationOfPhase = {};
   }
   currentPipelineStepIndex = 0;
+  cloneAndCorrectInputProblem(original) {
+    const cloned = structuredClone({
+      ...original,
+      _chipObstacleSpatialIndex: void 0
+    });
+    expandChipsToFitPins(cloned);
+    correctPinsInsideChips(cloned);
+    return cloned;
+  }
   _step() {
     const pipelineStepDef = this.pipelineDef[this.currentPipelineStepIndex];
     if (!pipelineStepDef) {

package/lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts

@@ -12,6 +12,9 @@ import { TraceOverlapShiftSolver } from "../TraceOverlapShiftSolver/TraceOverlap
 import { NetLabelPlacementSolver } from "../NetLabelPlacementSolver/NetLabelPlacementSolver"
 import { visualizeInputProblem } from "./visualizeInputProblem"
 import { GuidelinesSolver } from "../GuidelinesSolver/GuidelinesSolver"
+import { getInputChipBounds } from "../GuidelinesSolver/getInputChipBounds"
+import { correctPinsInsideChips } from "./correctPinsInsideChip"
+import { expandChipsToFitPins } from "./expandChipsToFitPins"
 
 type PipelineStep<T extends new (...args: any[]) => BaseSolver> = {
   solverName: string
@@ -135,7 +138,7 @@ export class SchematicTracePipelineSolver extends BaseSolver {
 
   constructor(inputProblem: InputProblem) {
     super()
-    this.inputProblem = inputProblem
+    this.inputProblem = this.cloneAndCorrectInputProblem(inputProblem)
     this.MAX_ITERATIONS = 1e6
     this.startTimeOfPhase = {}
     this.endTimeOfPhase = {}
@@ -145,6 +148,20 @@ export class SchematicTracePipelineSolver extends BaseSolver {
 
   currentPipelineStepIndex = 0
 
+  private cloneAndCorrectInputProblem(original: InputProblem): InputProblem {
+    const cloned: InputProblem = structuredClone({
+      ...original,
+      _chipObstacleSpatialIndex: undefined,
+    })
+
+    // First, expand chips so existing pin coordinates sit on or within their edges without shrinking.
+    expandChipsToFitPins(cloned)
+    // Then, for any remaining pins that are still inside due to mixed extremes, snap them to the nearest edge.
+    correctPinsInsideChips(cloned)
+
+    return cloned
+  }
+
   override _step() {
     const pipelineStepDef = this.pipelineDef[this.currentPipelineStepIndex]
     if (!pipelineStepDef) {

package/lib/solvers/SchematicTracePipelineSolver/correctPinsInsideChip.ts

@@ -0,0 +1,37 @@
+import type { InputProblem } from "lib/types/InputProblem"
+import { getInputChipBounds } from "../GuidelinesSolver/getInputChipBounds"
+
+export const correctPinsInsideChips = (problem: InputProblem) => {
+  for (const chip of problem.chips) {
+    const bounds = getInputChipBounds(chip)
+    for (const pin of chip.pins) {
+      const isInside =
+        pin.x > bounds.minX &&
+        pin.x < bounds.maxX &&
+        pin.y > bounds.minY &&
+        pin.y < bounds.maxY
+
+      if (!isInside) continue
+
+      const distLeft = pin.x - bounds.minX
+      const distRight = bounds.maxX - pin.x
+      const distBottom = pin.y - bounds.minY
+      const distTop = bounds.maxY - pin.y
+
+      const minDist = Math.min(distLeft, distRight, distBottom, distTop)
+
+      if (minDist === distLeft) {
+        pin.x = bounds.minX
+      } else if (minDist === distRight) {
+        pin.x = bounds.maxX
+      } else if (minDist === distBottom) {
+        pin.y = bounds.minY
+      } else {
+        pin.y = bounds.maxY
+      }
+
+      // Clear any cached facing direction since geometry changed.
+      pin._facingDirection = undefined
+    }
+  }
+}

package/lib/solvers/SchematicTracePipelineSolver/expandChipsToFitPins.ts

@@ -0,0 +1,41 @@
+import type { InputProblem } from "lib/types/InputProblem"
+
+/**
+ * Expands chip width/height (never shrinks) so that all existing pin coordinates
+ * are inside or on the chip boundary, and any pin at the furthest extent in X/Y
+ * lies exactly on an edge.
+ *
+ * Notes:
+ * - Center is preserved.
+ * - Only increases dimensions as needed.
+ * - Clears cached _facingDirection on pins since geometry changed.
+ */
+export const expandChipsToFitPins = (problem: InputProblem) => {
+  for (const chip of problem.chips) {
+    const halfWidth = chip.width / 2
+    const halfHeight = chip.height / 2
+
+    let maxDx = 0
+    let maxDy = 0
+
+    for (const pin of chip.pins) {
+      const dx = Math.abs(pin.x - chip.center.x)
+      const dy = Math.abs(pin.y - chip.center.y)
+      if (dx > maxDx) maxDx = dx
+      if (dy > maxDy) maxDy = dy
+    }
+
+    const newHalfWidth = Math.max(halfWidth, maxDx)
+    const newHalfHeight = Math.max(halfHeight, maxDy)
+
+    if (newHalfWidth > halfWidth || newHalfHeight > halfHeight) {
+      chip.width = newHalfWidth * 2
+      chip.height = newHalfHeight * 2
+
+      // Clear any cached facing direction since geometry changed.
+      for (const pin of chip.pins) {
+        pin._facingDirection = undefined
+      }
+    }
+  }
+}

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@tscircuit/schematic-trace-solver",
   "main": "dist/index.js",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "type": "module",
   "scripts": {
     "start": "cosmos",
     "build": "tsup lib/index.ts --format esm --dts",
-    "format": "biome format --write ."
+    "format": "biome format --write .",
+    "format:check": "biome format ."
   },
   "devDependencies": {
     "@biomejs/biome": "^2.2.2",

package/site/examples/example03.page.tsx

@@ -0,0 +1,215 @@
+import type { InputProblem } from "lib/index"
+import { PipelineDebugger } from "site/components/PipelineDebugger"
+
+const inputProblem: InputProblem = {
+  chips: [
+    {
+      chipId: "schematic_component_0",
+      center: {
+        x: -3,
+        y: 1.5,
+      },
+      width: 1.0011537820000012,
+      height: 0.44923699999999833,
+      pins: [
+        {
+          pinId: "PIN1_PIN2.1",
+          x: -3.4724184500000006,
+          y: 1.4489565000000004,
+        },
+        {
+          pinId: "PIN1_PIN2.2",
+          x: -3.4724184500000006,
+          y: 1.4489565000000004,
+        },
+        {
+          pinId: "PIN1_PIN2.3",
+          x: -2.5275815499999994,
+          y: 1.4485175000000003,
+        },
+        {
+          pinId: "PIN1_PIN2.4",
+          x: -2.5275815499999994,
+          y: 1.4485175000000003,
+        },
+      ],
+    },
+    {
+      chipId: "schematic_component_1",
+      center: {
+        x: 0,
+        y: 1.5,
+      },
+      width: 1.0011537820000012,
+      height: 0.44923699999999833,
+      pins: [
+        {
+          pinId: "PIN1_PIN3.1",
+          x: -0.4724184500000006,
+          y: 1.4489565000000004,
+        },
+        {
+          pinId: "PIN1_PIN3.2",
+          x: -0.4724184500000006,
+          y: 1.4489565000000004,
+        },
+        {
+          pinId: "PIN1_PIN3.3",
+          x: 0.4724184500000006,
+          y: 1.4485175000000003,
+        },
+        {
+          pinId: "PIN1_PIN3.4",
+          x: 0.4724184500000006,
+          y: 1.4485175000000003,
+        },
+      ],
+    },
+    {
+      chipId: "schematic_component_2",
+      center: {
+        x: 3,
+        y: 1.5,
+      },
+      width: 1.0011537820000012,
+      height: 0.44923699999999833,
+      pins: [
+        {
+          pinId: "PIN1_PIN4.1",
+          x: 2.5275815499999994,
+          y: 1.4489565000000004,
+        },
+        {
+          pinId: "PIN1_PIN4.2",
+          x: 2.5275815499999994,
+          y: 1.4489565000000004,
+        },
+        {
+          pinId: "PIN1_PIN4.3",
+          x: 3.4724184500000006,
+          y: 1.4485175000000003,
+        },
+        {
+          pinId: "PIN1_PIN4.4",
+          x: 3.4724184500000006,
+          y: 1.4485175000000003,
+        },
+      ],
+    },
+    {
+      chipId: "schematic_component_3",
+      center: {
+        x: -3,
+        y: -1.5,
+      },
+      width: 1.0011537820000012,
+      height: 0.44923699999999833,
+      pins: [
+        {
+          pinId: "PIN2_PIN3.1",
+          x: -3.4724184500000006,
+          y: -1.5510434999999996,
+        },
+        {
+          pinId: "PIN2_PIN3.2",
+          x: -3.4724184500000006,
+          y: -1.5510434999999996,
+        },
+        {
+          pinId: "PIN2_PIN3.3",
+          x: -2.5275815499999994,
+          y: -1.5514824999999997,
+        },
+        {
+          pinId: "PIN2_PIN3.4",
+          x: -2.5275815499999994,
+          y: -1.5514824999999997,
+        },
+      ],
+    },
+    {
+      chipId: "schematic_component_4",
+      center: {
+        x: 0,
+        y: -1.5,
+      },
+      width: 1.0011537820000012,
+      height: 0.44923699999999833,
+      pins: [
+        {
+          pinId: "PIN2_PIN4.1",
+          x: -0.4724184500000006,
+          y: -1.5510434999999996,
+        },
+        {
+          pinId: "PIN2_PIN4.2",
+          x: -0.4724184500000006,
+          y: -1.5510434999999996,
+        },
+        {
+          pinId: "PIN2_PIN4.3",
+          x: 0.4724184500000006,
+          y: -1.5514824999999997,
+        },
+        {
+          pinId: "PIN2_PIN4.4",
+          x: 0.4724184500000006,
+          y: -1.5514824999999997,
+        },
+      ],
+    },
+    {
+      chipId: "schematic_component_5",
+      center: {
+        x: 3,
+        y: -1.5,
+      },
+      width: 1.0011537820000012,
+      height: 0.44923699999999833,
+      pins: [
+        {
+          pinId: "PIN3_PIN4.1",
+          x: 2.5275815499999994,
+          y: -1.5510434999999996,
+        },
+        {
+          pinId: "PIN3_PIN4.2",
+          x: 2.5275815499999994,
+          y: -1.5510434999999996,
+        },
+        {
+          pinId: "PIN3_PIN4.3",
+          x: 3.4724184500000006,
+          y: -1.5514824999999997,
+        },
+        {
+          pinId: "PIN3_PIN4.4",
+          x: 3.4724184500000006,
+          y: -1.5514824999999997,
+        },
+      ],
+    },
+  ],
+  directConnections: [],
+  netConnections: [
+    {
+      netId: "PIN1",
+      pinIds: ["PIN1_PIN2.1", "PIN1_PIN3.1", "PIN1_PIN4.1"],
+    },
+    {
+      netId: "PIN2",
+      pinIds: ["PIN1_PIN2.2", "PIN2_PIN3.2", "PIN2_PIN4.2"],
+    },
+    {
+      netId: "PIN3",
+      pinIds: ["PIN1_PIN3.3", "PIN2_PIN3.3", "PIN3_PIN4.3"],
+    },
+    {
+      netId: "PIN4",
+      pinIds: ["PIN1_PIN4.4", "PIN2_PIN4.4", "PIN3_PIN4.4"],
+    },
+  ],
+  availableNetLabelOrientations: {},
+}
+
+export default () => <PipelineDebugger inputProblem={inputProblem} />