@tscircuit/schematic-trace-solver 0.0.21 → 0.0.22

package/.github/workflows/bun-pver-release.yml

@@ -4,6 +4,9 @@ on:
   push:
     branches:
       - main
+    paths:
+      - 'lib/**'
+  workflow_dispatch:
 jobs:
   publish:
     runs-on: ubuntu-latest

package/dist/index.d.ts

@@ -161,6 +161,7 @@ declare class SchematicTraceSingleLineSolver extends BaseSolver {
     chipMap: Record<string, InputChip>;
     movableSegments: Array<MovableSegment>;
     baseElbow: Point[];
+    allCandidatePaths: Array<Point[]>;
     queuedCandidatePaths: Array<Point[]>;
     chipObstacleSpatialIndex: ChipObstacleSpatialIndex;
     solvedTracePath: {

package/dist/index.js

@@ -6520,81 +6520,167 @@ var dir = (facingDirection) => {
 };
 
 // lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/generateElbowVariants.ts
-var generateElbowVariants = ({
-  baseElbow,
-  guidelines
-}) => {
-  const movableSegments = [];
-  for (let i = 1; i < baseElbow.length - 2; i++) {
-    const prev = baseElbow[i - 1];
-    const start = baseElbow[i];
-    const end = baseElbow[i + 1];
-    const isHorz = Math.abs(start.y - end.y) < 1e-6;
-    let freedom;
-    if (isHorz) {
-      freedom = prev.y <= start.y ? "y+" : "y-";
-    } else {
-      freedom = prev.x <= start.x ? "x+" : "x-";
+var EPS = 1e-6;
+var MIN_LEN = 1e-6;
+var isAxisAligned = (a, b) => Math.abs(a.x - b.x) < EPS || Math.abs(a.y - b.y) < EPS;
+var orientationOf = (a, b) => {
+  const dx = Math.abs(a.x - b.x);
+  const dy = Math.abs(a.y - b.y);
+  if (dx < EPS && dy >= EPS) return "vertical";
+  if (dy < EPS && dx >= EPS) return "horizontal";
+  throw new Error("Non-orthogonal or degenerate segment detected.");
+};
+var assertOrthogonalPolyline = (pts) => {
+  if (pts.length < 2) {
+    throw new Error("Polyline must have at least two points.");
+  }
+  for (let i = 0; i < pts.length - 1; i++) {
+    const a = pts[i];
+    const b = pts[i + 1];
+    if (!isAxisAligned(a, b)) {
+      throw new Error("Polyline contains a non-orthogonal segment.");
+    }
+    const manhattan = Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
+    if (manhattan < MIN_LEN) {
+      throw new Error("Polyline contains a near-zero length segment.");
     }
-    movableSegments.push({ start, end, freedom, dir: dir(freedom) });
   }
-  const segmentGuidelineOptions = [];
-  for (const segment of movableSegments) {
-    const relevantPositions = [];
-    if (segment.freedom === "x+" || segment.freedom === "x-") {
-      for (const guideline of guidelines) {
-        if (guideline.orientation === "vertical" && guideline.x !== void 0) {
-          relevantPositions.push(guideline.x);
-        }
+};
+var uniqSortedWithTol = (vals, tol = EPS) => {
+  const sorted = vals.slice().sort((a, b) => a - b);
+  const out = [];
+  for (const v of sorted) {
+    if (out.length === 0 || Math.abs(v - out[out.length - 1]) > tol) out.push(v);
+  }
+  return out;
+};
+var keyForPolyline = (pts, decimals = 9) => pts.map((p) => `${p.x.toFixed(decimals)},${p.y.toFixed(decimals)}`).join("|");
+var preprocessElbow = (pts, tol = MIN_LEN) => {
+  if (pts.length === 0) return [];
+  const out = [{ ...pts[0] }];
+  for (let i = 1; i < pts.length; i++) {
+    const p = pts[i];
+    const last = out[out.length - 1];
+    const manhattan = Math.abs(p.x - last.x) + Math.abs(p.y - last.y);
+    if (manhattan > tol) out.push({ ...p });
+  }
+  return out;
+};
+var collectAxisCandidates = (axis, guidelines, currentCoord) => {
+  const positions = [];
+  for (const g of guidelines) {
+    if (axis === "x") {
+      if (g.orientation === "vertical" && typeof g.x === "number") {
+        positions.push(g.x);
       }
-      relevantPositions.push(segment.start.x);
     } else {
-      for (const guideline of guidelines) {
-        if (guideline.orientation === "horizontal" && guideline.y !== void 0) {
-          relevantPositions.push(guideline.y);
-        }
+      if (g.orientation === "horizontal" && typeof g.y === "number") {
+        positions.push(g.y);
       }
-      relevantPositions.push(segment.start.y);
     }
-    segmentGuidelineOptions.push(
-      [...new Set(relevantPositions)].sort((a, b) => a - b)
-    );
   }
-  const generateCombinations = (options) => {
-    if (options.length === 0) return [[]];
-    if (options.length === 1) return options[0].map((pos) => [pos]);
-    const combinations = [];
-    const firstOptions = options[0];
-    const restCombinations = generateCombinations(options.slice(1));
-    for (const firstOption of firstOptions) {
-      for (const restCombination of restCombinations) {
-        combinations.push([firstOption, ...restCombination]);
+  positions.push(currentCoord);
+  return uniqSortedWithTol(positions);
+};
+var computeFreedom = (prev, start, end) => {
+  const orient = orientationOf(start, end);
+  if (orient === "horizontal") {
+    const facing = prev.y <= start.y ? "y+" : "y-";
+    return { axis: "y", facing };
+  } else {
+    const facing = prev.x <= start.x ? "x+" : "x-";
+    return { axis: "x", facing };
+  }
+};
+var cartesian = (arrays) => arrays.length === 0 ? [[]] : arrays.reduce(
+  (acc, curr) => acc.flatMap((a) => curr.map((c) => [...a, c])),
+  [[]]
+);
+var generateElbowVariants = ({
+  baseElbow,
+  guidelines
+}) => {
+  const elbow = preprocessElbow(baseElbow);
+  assertOrthogonalPolyline(elbow);
+  const nPts = elbow.length;
+  const nSegs = nPts - 1;
+  if (nSegs < 5) {
+    return {
+      elbowVariants: [elbow.map((p) => ({ ...p }))],
+      movableSegments: []
+    };
+  }
+  const firstMovableIndex = 2;
+  const lastMovableIndex = nPts - 4;
+  const movableSegments = [];
+  const movableIdx = [];
+  const axes = [];
+  const optionsPerSegment = [];
+  for (let i = firstMovableIndex; i <= lastMovableIndex; i++) {
+    const prev = elbow[i - 1];
+    const start = elbow[i];
+    const end = elbow[i + 1];
+    const next2 = elbow[i + 2];
+    const { axis, facing } = computeFreedom(prev, start, end);
+    movableSegments.push({
+      start: { ...start },
+      end: { ...end },
+      freedom: facing,
+      dir: dir(facing)
+    });
+    movableIdx.push(i);
+    axes.push(axis);
+    const currentCoord = axis === "x" ? start.x : start.y;
+    const rawCandidates = collectAxisCandidates(axis, guidelines, currentCoord);
+    const filtered = rawCandidates.filter((pos) => {
+      if (axis === "y") {
+        const lenPrev = Math.abs(prev.y - pos);
+        const lenNext = Math.abs(next2.y - pos);
+        return lenPrev > MIN_LEN && lenNext > MIN_LEN;
+      } else {
+        const lenPrev = Math.abs(prev.x - pos);
+        const lenNext = Math.abs(next2.x - pos);
+        return lenPrev > MIN_LEN && lenNext > MIN_LEN;
       }
-    }
-    return combinations;
-  };
-  const positionCombinations = generateCombinations(segmentGuidelineOptions);
+    });
+    optionsPerSegment.push(filtered);
+  }
+  const combos = cartesian(optionsPerSegment);
+  const seen = /* @__PURE__ */ new Set();
   const elbowVariants = [];
-  for (const combination of positionCombinations) {
-    const variant = [...baseElbow];
-    for (let segmentIndex = 0; segmentIndex < movableSegments.length; segmentIndex++) {
-      const segment = movableSegments[segmentIndex];
-      const newPosition = combination[segmentIndex];
-      const elbowIndex = segmentIndex + 1;
-      if (segment.freedom === "x+" || segment.freedom === "x-") {
-        variant[elbowIndex] = { ...variant[elbowIndex], x: newPosition };
-        variant[elbowIndex + 1] = { ...variant[elbowIndex + 1], x: newPosition };
+  {
+    const key = keyForPolyline(elbow);
+    seen.add(key);
+    elbowVariants.push(elbow.map((p) => ({ ...p })));
+  }
+  for (const combo of combos) {
+    if (combo.length === 0) continue;
+    const variant = elbow.map((p) => ({ ...p }));
+    for (let k = 0; k < movableIdx.length; k++) {
+      const segIndex = movableIdx[k];
+      const axis = axes[k];
+      const newPos = combo[k];
+      if (typeof newPos !== "number" || Number.isNaN(newPos)) continue;
+      if (axis === "y") {
+        variant[segIndex] = { ...variant[segIndex], y: newPos };
+        variant[segIndex + 1] = { ...variant[segIndex + 1], y: newPos };
       } else {
-        variant[elbowIndex] = { ...variant[elbowIndex], y: newPosition };
-        variant[elbowIndex + 1] = { ...variant[elbowIndex + 1], y: newPosition };
+        variant[segIndex] = { ...variant[segIndex], x: newPos };
+        variant[segIndex + 1] = { ...variant[segIndex + 1], x: newPos };
       }
     }
-    elbowVariants.push(variant);
+    try {
+      assertOrthogonalPolyline(variant);
+    } catch {
+      continue;
+    }
+    const key = keyForPolyline(variant);
+    if (!seen.has(key)) {
+      seen.add(key);
+      elbowVariants.push(variant);
+    }
   }
-  return {
-    elbowVariants,
-    movableSegments
-  };
+  return { elbowVariants, movableSegments };
 };
 
 // lib/solvers/GuidelinesSolver/visualizeGuidelines.ts
@@ -6642,6 +6728,7 @@ var SchematicTraceSingleLineSolver = class extends BaseSolver {
   chipMap;
   movableSegments;
   baseElbow;
+  allCandidatePaths;
   queuedCandidatePaths;
   chipObstacleSpatialIndex;
   solvedTracePath = null;
@@ -6691,7 +6778,8 @@ var SchematicTraceSingleLineSolver = class extends BaseSolver {
       }
       return len;
     };
-    this.queuedCandidatePaths = [this.baseElbow, ...elbowVariants].sort(
+    this.allCandidatePaths = [this.baseElbow, ...elbowVariants];
+    this.queuedCandidatePaths = [...this.allCandidatePaths].sort(
       (a, b) => getPathLength(a) - getPathLength(b)
     );
   }
@@ -6728,12 +6816,12 @@ var SchematicTraceSingleLineSolver = class extends BaseSolver {
           const bounds = getInputChipBounds(this.chipMap[startPin.chipId]);
           const dx = end.x - start.x;
           const dy = end.y - start.y;
-          const EPS = 1e-9;
+          const EPS2 = 1e-9;
           const onLeft = Math.abs(start.x - bounds.minX) < 1e-9;
           const onRight = Math.abs(start.x - bounds.maxX) < 1e-9;
           const onBottom = Math.abs(start.y - bounds.minY) < 1e-9;
           const onTop = Math.abs(start.y - bounds.maxY) < 1e-9;
-          const entersInterior = onLeft && dx > EPS || onRight && dx < -EPS || onBottom && dy > EPS || onTop && dy < -EPS;
+          const entersInterior = onLeft && dx > EPS2 || onRight && dx < -EPS2 || onBottom && dy > EPS2 || onTop && dy < -EPS2;
           if (entersInterior) return;
           if (!excludeChipIds.includes(startPin.chipId)) {
             excludeChipIds.push(startPin.chipId);
@@ -6748,12 +6836,12 @@ var SchematicTraceSingleLineSolver = class extends BaseSolver {
           const bounds = getInputChipBounds(this.chipMap[endPin.chipId]);
           const dx = start.x - end.x;
           const dy = start.y - end.y;
-          const EPS = 1e-9;
+          const EPS2 = 1e-9;
           const onLeft = Math.abs(end.x - bounds.minX) < 1e-9;
           const onRight = Math.abs(end.x - bounds.maxX) < 1e-9;
           const onBottom = Math.abs(end.y - bounds.minY) < 1e-9;
           const onTop = Math.abs(end.y - bounds.maxY) < 1e-9;
-          const entersInterior = onLeft && dx > EPS || onRight && dx < -EPS || onBottom && dy > EPS || onTop && dy < -EPS;
+          const entersInterior = onLeft && dx > EPS2 || onRight && dx < -EPS2 || onBottom && dy > EPS2 || onTop && dy < -EPS2;
           if (entersInterior) return;
           if (!excludeChipIds.includes(endPin.chipId)) {
             excludeChipIds.push(endPin.chipId);
@@ -6956,13 +7044,13 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
     }
   }
   _step() {
-    const EPS = 1e-6;
+    const EPS2 = 1e-6;
     const offsets = this.overlappingTraceSegments.map((_, idx) => {
       const n = Math.floor(idx / 2) + 1;
       const signed = idx % 2 === 0 ? -n : n;
       return signed * this.SHIFT_DISTANCE;
     });
-    const eq = (a, b) => Math.abs(a - b) < EPS;
+    const eq = (a, b) => Math.abs(a - b) < EPS2;
     const samePoint = (p, q) => !!p && !!q && eq(p.x, q.x) && eq(p.y, q.y);
     this.overlappingTraceSegments.forEach((group, gidx) => {
       const offset = offsets[gidx];
@@ -6985,8 +7073,8 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
           if (si === 0 || si === pts.length - 2) continue;
           const start = pts[si];
           const end = pts[si + 1];
-          const isVertical = Math.abs(start.x - end.x) < EPS;
-          const isHorizontal = Math.abs(start.y - end.y) < EPS;
+          const isVertical = Math.abs(start.x - end.x) < EPS2;
+          const isHorizontal = Math.abs(start.y - end.y) < EPS2;
           if (!isVertical && !isHorizontal) continue;
           if (isVertical) {
             if (!appliedX.has(si)) {
@@ -7095,7 +7183,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
     return islands;
   }
   findNextOverlapIssue() {
-    const EPS = 1e-6;
+    const EPS2 = 1e-6;
     const netIds = Object.keys(this.traceNetIslands);
     for (let i = 0; i < netIds.length; i++) {
       for (let j = i + 1; j < netIds.length; j++) {
@@ -7113,7 +7201,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
           const minB = Math.min(b1, b2);
           const maxB = Math.max(b1, b2);
           const overlap = Math.min(maxA, maxB) - Math.max(minA, minB);
-          return overlap > EPS;
+          return overlap > EPS2;
         };
         for (let pa = 0; pa < pathsA.length; pa++) {
           const pathA = pathsA[pa];
@@ -7121,8 +7209,8 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
           for (let sa = 0; sa < ptsA.length - 1; sa++) {
             const a1 = ptsA[sa];
             const a2 = ptsA[sa + 1];
-            const aVert = Math.abs(a1.x - a2.x) < EPS;
-            const aHorz = Math.abs(a1.y - a2.y) < EPS;
+            const aVert = Math.abs(a1.x - a2.x) < EPS2;
+            const aHorz = Math.abs(a1.y - a2.y) < EPS2;
             if (!aVert && !aHorz) continue;
             for (let pb = 0; pb < pathsB.length; pb++) {
               const pathB = pathsB[pb];
@@ -7130,11 +7218,11 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
               for (let sb = 0; sb < ptsB.length - 1; sb++) {
                 const b1 = ptsB[sb];
                 const b2 = ptsB[sb + 1];
-                const bVert = Math.abs(b1.x - b2.x) < EPS;
-                const bHorz = Math.abs(b1.y - b2.y) < EPS;
+                const bVert = Math.abs(b1.x - b2.x) < EPS2;
+                const bHorz = Math.abs(b1.y - b2.y) < EPS2;
                 if (!bVert && !bHorz) continue;
                 if (aVert && bVert) {
-                  if (Math.abs(a1.x - b1.x) < EPS) {
+                  if (Math.abs(a1.x - b1.x) < EPS2) {
                     if (overlaps1D(a1.y, a2.y, b1.y, b2.y)) {
                       const keyA = `${pa}:${sa}`;
                       const keyB = `${pb}:${sb}`;
@@ -7155,7 +7243,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
                     }
                   }
                 } else if (aHorz && bHorz) {
-                  if (Math.abs(a1.y - b1.y) < EPS) {
+                  if (Math.abs(a1.y - b1.y) < EPS2) {
                     if (overlaps1D(a1.x, a2.x, b1.x, b2.x)) {
                       const keyA = `${pa}:${sa}`;
                       const keyB = `${pb}:${sb}`;
@@ -7270,24 +7358,24 @@ function getRectBounds(center, w, h) {
 }
 
 // lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/collisions.ts
-function segmentIntersectsRect(p1, p2, rect, EPS = 1e-9) {
-  const isVert = Math.abs(p1.x - p2.x) < EPS;
-  const isHorz = Math.abs(p1.y - p2.y) < EPS;
+function segmentIntersectsRect(p1, p2, rect, EPS2 = 1e-9) {
+  const isVert = Math.abs(p1.x - p2.x) < EPS2;
+  const isHorz = Math.abs(p1.y - p2.y) < EPS2;
   if (!isVert && !isHorz) return false;
   if (isVert) {
     const x = p1.x;
-    if (x < rect.minX - EPS || x > rect.maxX + EPS) return false;
+    if (x < rect.minX - EPS2 || x > rect.maxX + EPS2) return false;
     const segMinY = Math.min(p1.y, p2.y);
     const segMaxY = Math.max(p1.y, p2.y);
     const overlap = Math.min(segMaxY, rect.maxY) - Math.max(segMinY, rect.minY);
-    return overlap > EPS;
+    return overlap > EPS2;
   } else {
     const y = p1.y;
-    if (y < rect.minY - EPS || y > rect.maxY + EPS) return false;
+    if (y < rect.minY - EPS2 || y > rect.maxY + EPS2) return false;
     const segMinX = Math.min(p1.x, p2.x);
     const segMaxX = Math.max(p1.x, p2.x);
     const overlap = Math.min(segMaxX, rect.maxX) - Math.max(segMinX, rect.minX);
-    return overlap > EPS;
+    return overlap > EPS2;
   }
 }
 function rectIntersectsAnyTrace(bounds, inputTraceMap, hostPathId, hostSegIndex) {
@@ -7612,14 +7700,14 @@ var SingleNetLabelPlacementSolver = class extends BaseSolver {
     };
     let bestCandidate = null;
     let bestScore = -Infinity;
-    const EPS = 1e-6;
+    const EPS2 = 1e-6;
     for (const curr of tracesToScan) {
       const pts = curr.tracePath.slice();
       for (let si = 0; si < pts.length - 1; si++) {
         const a = pts[si];
         const b = pts[si + 1];
-        const isH = Math.abs(a.y - b.y) < EPS;
-        const isV = Math.abs(a.x - b.x) < EPS;
+        const isH = Math.abs(a.y - b.y) < EPS2;
+        const isV = Math.abs(a.x - b.x) < EPS2;
         if (!isH && !isV) continue;
         const segmentAllowed = isH ? ["y+", "y-"] : ["x+", "x-"];
         const candidateOrients = orientations.filter(

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

@@ -24,6 +24,7 @@ export class SchematicTraceSingleLineSolver extends BaseSolver {
   movableSegments: Array<MovableSegment>
   baseElbow: Point[]
 
+  allCandidatePaths: Array<Point[]>
   queuedCandidatePaths: Array<Point[]>
 
   chipObstacleSpatialIndex: ChipObstacleSpatialIndex
@@ -91,7 +92,8 @@ export class SchematicTraceSingleLineSolver extends BaseSolver {
       return len
     }
 
-    this.queuedCandidatePaths = [this.baseElbow, ...elbowVariants].sort(
+    this.allCandidatePaths = [this.baseElbow, ...elbowVariants]
+    this.queuedCandidatePaths = [...this.allCandidatePaths].sort(
       (a, b) => getPathLength(a) - getPathLength(b),
     )
   }