@tscircuit/curvy-trace-solver 0.0.6 → 0.0.8

package/dist/index.d.ts

@@ -45,9 +45,13 @@ declare class CurvyTraceSolver extends BaseSolver {
     private initializeTraces;
     private updateSampledTraces;
     private updateSingleTraceSample;
+    private updateControlPointsFromDistances;
     private updateCollisionPairs;
     private computeTotalCost;
     private computeCostForTrace;
+    private tracesIntersect;
+    private findIntersectingPairs;
+    private resolveIntersections;
     private optimizeStep;
     private buildOutputTraces;
     _step(): void;

package/dist/index.js

@@ -932,16 +932,27 @@ function getPerimeterT(p, bounds) {
   if (Math.abs(p.x - minX) < eps) return 2 * W + H + (p.y - minY);
   return 0;
 }
-function getPerimeterPoint(t, bounds) {
+function getInwardPerpendicular(p, bounds) {
   const { minX, maxX, minY, maxY } = bounds;
-  const W = maxX - minX;
-  const H = maxY - minY;
-  const perimeter = 2 * W + 2 * H;
-  t = (t % perimeter + perimeter) % perimeter;
-  if (t <= W) return { x: minX + t, y: maxY };
-  if (t <= W + H) return { x: maxX, y: maxY - (t - W) };
-  if (t <= 2 * W + H) return { x: maxX - (t - W - H), y: minY };
-  return { x: minX, y: minY + (t - 2 * W - H) };
+  const eps = 1e-6;
+  const onTop = Math.abs(p.y - maxY) < eps;
+  const onBottom = Math.abs(p.y - minY) < eps;
+  const onRight = Math.abs(p.x - maxX) < eps;
+  const onLeft = Math.abs(p.x - minX) < eps;
+  if (onTop && onRight) return { x: -Math.SQRT1_2, y: -Math.SQRT1_2 };
+  if (onTop && onLeft) return { x: Math.SQRT1_2, y: -Math.SQRT1_2 };
+  if (onBottom && onRight) return { x: -Math.SQRT1_2, y: Math.SQRT1_2 };
+  if (onBottom && onLeft) return { x: Math.SQRT1_2, y: Math.SQRT1_2 };
+  if (onTop) return { x: 0, y: -1 };
+  if (onBottom) return { x: 0, y: 1 };
+  if (onRight) return { x: -1, y: 0 };
+  if (onLeft) return { x: 1, y: 0 };
+  const cx = (minX + maxX) / 2;
+  const cy = (minY + maxY) / 2;
+  const dx = cx - p.x;
+  const dy = cy - p.y;
+  const len = Math.hypot(dx, dy);
+  return len > 0 ? { x: dx / len, y: dy / len } : { x: 0, y: -1 };
 }
 function sampleCubicBezierInline(p0x, p0y, p1x, p1y, p2x, p2y, p3x, p3y, points, numSamples) {
   for (let i = 0; i <= numSamples; i++) {
@@ -1003,6 +1014,13 @@ function segmentDistSq(a1x, a1y, a2x, a2y, b1x, b1y, b2x, b2y) {
     ptSegDistSq(b2x, b2y, a1x, a1y, a2x, a2y)
   );
 }
+function segmentsIntersect(a1x, a1y, a2x, a2y, b1x, b1y, b2x, b2y) {
+  const d1 = (b2x - b1x) * (a1y - b1y) - (b2y - b1y) * (a1x - b1x);
+  const d2 = (b2x - b1x) * (a2y - b1y) - (b2y - b1y) * (a2x - b1x);
+  const d3 = (a2x - a1x) * (b1y - a1y) - (a2y - a1y) * (b1x - a1x);
+  const d4 = (a2x - a1x) * (b2y - a1y) - (a2y - a1y) * (b2x - a1x);
+  return (d1 > 0 && d2 < 0 || d1 < 0 && d2 > 0) && (d3 > 0 && d4 < 0 || d3 < 0 && d4 > 0);
+}
 function chordContains(aT1, aT2, bT1, bT2, perimeter) {
   const normalize = (t) => (t % perimeter + perimeter) % perimeter;
   const a1 = normalize(aT1), a2 = normalize(aT2);
@@ -1091,33 +1109,32 @@ var CurvyTraceSolver = class extends BaseSolver {
       t2: getPerimeterT(pair.end, bounds),
       idx
     }));
-    const nestingDepth = /* @__PURE__ */ new Map();
+    const containedBy = tracesWithT.map(() => []);
+    const contains = tracesWithT.map(() => []);
     for (const trace of tracesWithT) {
-      let depth = 0;
       for (const other of tracesWithT) {
-        if (trace.idx !== other.idx && chordContains(other.t1, other.t2, trace.t1, trace.t2, perimeter)) {
-          depth++;
+        if (trace.idx !== other.idx) {
+          if (trace.pair.networkId && other.pair.networkId && trace.pair.networkId === other.pair.networkId) {
+            continue;
+          }
+          if (chordContains(other.t1, other.t2, trace.t1, trace.t2, perimeter)) {
+            containedBy[trace.idx].push(other.idx);
+            contains[other.idx].push(trace.idx);
+          }
         }
       }
-      nestingDepth.set(trace.idx, depth);
     }
-    const maxDepth = Math.max(...Array.from(nestingDepth.values()), 1);
+    const nestingDepth = containedBy.map((arr) => arr.length);
+    const maxDepth = Math.max(...nestingDepth, 1);
     this.traces = tracesWithT.map(({ pair, t1, t2, idx }) => {
-      let dt = t2 - t1;
-      if (dt > perimeter / 2) dt -= perimeter;
-      if (dt < -perimeter / 2) dt += perimeter;
-      const tCtrl1 = t1 + dt * 0.33;
-      const tCtrl2 = t1 + dt * 0.67;
-      const pPerim1 = getPerimeterPoint(tCtrl1, bounds);
-      const pPerim2 = getPerimeterPoint(tCtrl2, bounds);
-      const pLinear1 = {
-        x: pair.start.x + (pair.end.x - pair.start.x) * 0.33,
-        y: pair.start.y + (pair.end.y - pair.start.y) * 0.33
-      };
-      const pLinear2 = {
-        x: pair.start.x + (pair.end.x - pair.start.x) * 0.67,
-        y: pair.start.y + (pair.end.y - pair.start.y) * 0.67
-      };
+      const perpDir1 = getInwardPerpendicular(pair.start, bounds);
+      const perpDir2 = getInwardPerpendicular(pair.end, bounds);
+      const chordLength = Math.hypot(
+        pair.end.x - pair.start.x,
+        pair.end.y - pair.start.y
+      );
+      const depth = nestingDepth[idx];
+      const normalizedDepth = depth / maxDepth;
       const midPoint = {
         x: (pair.start.x + pair.end.x) / 2,
         y: (pair.start.y + pair.end.y) / 2
@@ -1128,23 +1145,33 @@ var CurvyTraceSolver = class extends BaseSolver {
       );
       const maxDist = Math.hypot(W / 2, H / 2);
       const spatialDepth = 1 - distToCenter / maxDist;
-      const depth = nestingDepth.get(idx) || 0;
-      const normalizedDepth = depth / maxDepth;
-      const basePull = 0.3 + spatialDepth * 0.4;
-      const pullAmount = Math.max(0.05, basePull - normalizedDepth * 0.2);
+      const baseFactor = 0.25 + spatialDepth * 0.15;
+      const depthAdjustment = 1 - normalizedDepth * 0.3;
+      const initialDist = chordLength * baseFactor * depthAdjustment;
+      const minDist = Math.min(W, H) * 0.05;
+      const d1 = Math.max(minDist, initialDist);
+      const d2 = Math.max(minDist, initialDist);
+      const ctrl1 = {
+        x: pair.start.x + d1 * perpDir1.x,
+        y: pair.start.y + d1 * perpDir1.y
+      };
+      const ctrl2 = {
+        x: pair.end.x + d2 * perpDir2.x,
+        y: pair.end.y + d2 * perpDir2.y
+      };
       return {
         waypointPair: pair,
-        ctrl1: {
-          x: pLinear1.x * (1 - pullAmount) + pPerim1.x * pullAmount,
-          y: pLinear1.y * (1 - pullAmount) + pPerim1.y * pullAmount
-        },
-        ctrl2: {
-          x: pLinear2.x * (1 - pullAmount) + pPerim2.x * pullAmount,
-          y: pLinear2.y * (1 - pullAmount) + pPerim2.y * pullAmount
-        },
+        ctrl1,
+        ctrl2,
         networkId: pair.networkId,
         t1,
-        t2
+        t2,
+        perpDir1,
+        perpDir2,
+        d1,
+        d2,
+        containedBy: containedBy[idx],
+        contains: contains[idx]
       };
     });
     this.sampledPoints = this.traces.map(
@@ -1199,6 +1226,14 @@ var CurvyTraceSolver = class extends BaseSolver {
       OPT_SAMPLES + 1
     );
   }
+  // Update control points from perpendicular distances
+  updateControlPointsFromDistances(i) {
+    const trace = this.traces[i];
+    trace.ctrl1.x = trace.waypointPair.start.x + trace.d1 * trace.perpDir1.x;
+    trace.ctrl1.y = trace.waypointPair.start.y + trace.d1 * trace.perpDir1.y;
+    trace.ctrl2.x = trace.waypointPair.end.x + trace.d2 * trace.perpDir2.x;
+    trace.ctrl2.y = trace.waypointPair.end.y + trace.d2 * trace.perpDir2.y;
+  }
   // Determine which trace pairs could possibly collide based on bounding boxes
   updateCollisionPairs() {
     const { preferredTraceToTraceSpacing: preferredSpacing } = this.problem;
@@ -1324,12 +1359,213 @@ var CurvyTraceSolver = class extends BaseSolver {
     }
     return cost;
   }
+  // Check if two traces intersect or are very close (potential intersection)
+  // Uses higher resolution sampling for accuracy
+  tracesIntersect(i, j) {
+    const trace1 = this.traces[i];
+    const trace2 = this.traces[j];
+    const INTERSECT_SAMPLES = 15;
+    const p1 = new Float64Array((INTERSECT_SAMPLES + 1) * 2);
+    const p2 = new Float64Array((INTERSECT_SAMPLES + 1) * 2);
+    sampleCubicBezierInline(
+      trace1.waypointPair.start.x,
+      trace1.waypointPair.start.y,
+      trace1.ctrl1.x,
+      trace1.ctrl1.y,
+      trace1.ctrl2.x,
+      trace1.ctrl2.y,
+      trace1.waypointPair.end.x,
+      trace1.waypointPair.end.y,
+      p1,
+      INTERSECT_SAMPLES
+    );
+    sampleCubicBezierInline(
+      trace2.waypointPair.start.x,
+      trace2.waypointPair.start.y,
+      trace2.ctrl1.x,
+      trace2.ctrl1.y,
+      trace2.ctrl2.x,
+      trace2.ctrl2.y,
+      trace2.waypointPair.end.x,
+      trace2.waypointPair.end.y,
+      p2,
+      INTERSECT_SAMPLES
+    );
+    for (let a = 0; a < INTERSECT_SAMPLES; a++) {
+      const a1x = p1[a * 2];
+      const a1y = p1[a * 2 + 1];
+      const a2x = p1[(a + 1) * 2];
+      const a2y = p1[(a + 1) * 2 + 1];
+      for (let b = 0; b < INTERSECT_SAMPLES; b++) {
+        const b1x = p2[b * 2];
+        const b1y = p2[b * 2 + 1];
+        const b2x = p2[(b + 1) * 2];
+        const b2y = p2[(b + 1) * 2 + 1];
+        if (segmentsIntersect(a1x, a1y, a2x, a2y, b1x, b1y, b2x, b2y)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  // Find all pairs of traces that currently intersect
+  findIntersectingPairs() {
+    const intersecting = [];
+    for (let i = 0; i < this.traces.length; i++) {
+      for (let j = i + 1; j < this.traces.length; j++) {
+        const ti = this.traces[i];
+        const tj = this.traces[j];
+        if (ti.networkId && tj.networkId && ti.networkId === tj.networkId) {
+          continue;
+        }
+        const bi = this.traceBounds[i];
+        const bj = this.traceBounds[j];
+        if (bi.maxX < bj.minX || bj.maxX < bi.minX || bi.maxY < bj.minY || bj.maxY < bi.minY) {
+          continue;
+        }
+        if (this.tracesIntersect(i, j)) {
+          intersecting.push([i, j]);
+        }
+      }
+    }
+    return intersecting;
+  }
+  // Resolve intersections by separating traces in depth
+  // Only keeps changes if they improve overall cost
+  resolveIntersections() {
+    const { bounds, preferredTraceToTraceSpacing } = this.problem;
+    const { minX, maxX, minY, maxY } = bounds;
+    const minDim = Math.min(maxX - minX, maxY - minY);
+    const minDist = minDim * 0.02;
+    const maxDist = minDim * 1.5;
+    const intersecting = this.findIntersectingPairs();
+    if (intersecting.length === 0) return 0;
+    let resolved = 0;
+    for (const [i, j] of intersecting) {
+      const ti = this.traces[i];
+      const tj = this.traces[j];
+      if (!this.tracesIntersect(i, j)) continue;
+      let outerIdx;
+      let innerIdx;
+      if (ti.containedBy.includes(j)) {
+        outerIdx = j;
+        innerIdx = i;
+      } else if (tj.containedBy.includes(i)) {
+        outerIdx = i;
+        innerIdx = j;
+      } else {
+        const avgDi = (ti.d1 + ti.d2) / 2;
+        const avgDj = (tj.d1 + tj.d2) / 2;
+        if (avgDi < avgDj) {
+          outerIdx = i;
+          innerIdx = j;
+        } else {
+          outerIdx = j;
+          innerIdx = i;
+        }
+      }
+      const outerTrace = this.traces[outerIdx];
+      const innerTrace = this.traces[innerIdx];
+      const origOuterD1 = outerTrace.d1;
+      const origOuterD2 = outerTrace.d2;
+      const origInnerD1 = innerTrace.d1;
+      const origInnerD2 = innerTrace.d2;
+      const costBeforeThis = this.computeTotalCost();
+      const separation = preferredTraceToTraceSpacing * 2;
+      const strategies = [
+        // Strategy 1: Small increase for inner
+        { innerMult: 1, outerMult: 0 },
+        // Strategy 2: Small decrease for outer
+        { innerMult: 0, outerMult: 1 },
+        // Strategy 3: Both directions
+        { innerMult: 0.5, outerMult: 0.5 },
+        // Strategy 4: Larger increase for inner
+        { innerMult: 2, outerMult: 0 },
+        // Strategy 5: Both larger
+        { innerMult: 1, outerMult: 1 },
+        // More aggressive
+        { innerMult: 3, outerMult: 0 },
+        { innerMult: 2, outerMult: 1 },
+        { innerMult: 4, outerMult: 0 }
+      ];
+      let bestCost = costBeforeThis;
+      let bestStrategy = null;
+      for (const strategy of strategies) {
+        outerTrace.d1 = origOuterD1;
+        outerTrace.d2 = origOuterD2;
+        innerTrace.d1 = origInnerD1;
+        innerTrace.d2 = origInnerD2;
+        innerTrace.d1 = Math.min(
+          maxDist,
+          origInnerD1 + separation * strategy.innerMult
+        );
+        innerTrace.d2 = Math.min(
+          maxDist,
+          origInnerD2 + separation * strategy.innerMult
+        );
+        outerTrace.d1 = Math.max(
+          minDist,
+          origOuterD1 - separation * strategy.outerMult
+        );
+        outerTrace.d2 = Math.max(
+          minDist,
+          origOuterD2 - separation * strategy.outerMult
+        );
+        this.updateControlPointsFromDistances(innerIdx);
+        this.updateControlPointsFromDistances(outerIdx);
+        this.updateSingleTraceSample(innerIdx);
+        this.updateSingleTraceSample(outerIdx);
+        if (!this.tracesIntersect(outerIdx, innerIdx)) {
+          const newCost = this.computeTotalCost();
+          if (bestStrategy === null || newCost < bestCost) {
+            bestCost = newCost;
+            bestStrategy = strategy;
+          }
+        }
+      }
+      if (bestStrategy) {
+        innerTrace.d1 = Math.min(
+          maxDist,
+          origInnerD1 + separation * bestStrategy.innerMult
+        );
+        innerTrace.d2 = Math.min(
+          maxDist,
+          origInnerD2 + separation * bestStrategy.innerMult
+        );
+        outerTrace.d1 = Math.max(
+          minDist,
+          origOuterD1 - separation * bestStrategy.outerMult
+        );
+        outerTrace.d2 = Math.max(
+          minDist,
+          origOuterD2 - separation * bestStrategy.outerMult
+        );
+        this.updateControlPointsFromDistances(innerIdx);
+        this.updateControlPointsFromDistances(outerIdx);
+        this.updateSingleTraceSample(innerIdx);
+        this.updateSingleTraceSample(outerIdx);
+        resolved++;
+      } else {
+        outerTrace.d1 = origOuterD1;
+        outerTrace.d2 = origOuterD2;
+        innerTrace.d1 = origInnerD1;
+        innerTrace.d2 = origInnerD2;
+        this.updateControlPointsFromDistances(outerIdx);
+        this.updateControlPointsFromDistances(innerIdx);
+        this.updateSingleTraceSample(outerIdx);
+        this.updateSingleTraceSample(innerIdx);
+      }
+    }
+    return resolved;
+  }
   optimizeStep() {
-    const { bounds } = this.problem;
+    const { bounds, preferredTraceToTraceSpacing } = this.problem;
     const { minX, maxX, minY, maxY } = bounds;
+    const minDim = Math.min(maxX - minX, maxY - minY);
     const progress = this.optimizationStep / this.maxOptimizationSteps;
-    const baseStep = 3.5 * (1 - progress) + 0.5;
-    const SQRT1_2 = Math.SQRT1_2;
+    const baseStep = 4 * (1 - progress) + 0.5;
+    const minDist = minDim * 0.02;
+    const maxDist = minDim * 1.5;
     const traceCosts = [];
     for (let i = 0; i < this.traces.length; i++) {
       traceCosts.push({ idx: i, cost: this.computeCostForTrace(i) });
@@ -1338,76 +1574,77 @@ var CurvyTraceSolver = class extends BaseSolver {
     for (const { idx: i, cost: currentCost } of traceCosts) {
       if (currentCost === 0) continue;
       const trace = this.traces[i];
-      const steps = [baseStep, baseStep * 1.5, baseStep * 0.5];
+      const costMultiplier = currentCost > 100 ? 2 : 1;
+      const steps = [baseStep * costMultiplier, baseStep * 1.5 * costMultiplier, baseStep * 0.5];
       for (const step of steps) {
-        const directions = [
-          { dx: step, dy: 0 },
-          { dx: -step, dy: 0 },
-          { dx: 0, dy: step },
-          { dx: 0, dy: -step },
-          { dx: step * SQRT1_2, dy: step * SQRT1_2 },
-          { dx: -step * SQRT1_2, dy: -step * SQRT1_2 },
-          { dx: step * SQRT1_2, dy: -step * SQRT1_2 },
-          { dx: -step * SQRT1_2, dy: step * SQRT1_2 }
-        ];
+        const deltas = currentCost > 100 ? [
+          step,
+          -step,
+          step * 2,
+          -step * 2,
+          step * 3,
+          -step * 3,
+          preferredTraceToTraceSpacing * 2,
+          -preferredTraceToTraceSpacing * 2
+        ] : [step, -step, step * 2, -step * 2];
         let bestCost = this.computeCostForTrace(i);
-        let bestCtrl1x = trace.ctrl1.x;
-        let bestCtrl1y = trace.ctrl1.y;
-        let bestCtrl2x = trace.ctrl2.x;
-        let bestCtrl2y = trace.ctrl2.y;
-        const origCtrl1x = trace.ctrl1.x;
-        const origCtrl1y = trace.ctrl1.y;
-        const origCtrl2x = trace.ctrl2.x;
-        const origCtrl2y = trace.ctrl2.y;
-        for (const dir of directions) {
-          trace.ctrl1.x = Math.max(minX, Math.min(maxX, origCtrl1x + dir.dx));
-          trace.ctrl1.y = Math.max(minY, Math.min(maxY, origCtrl1y + dir.dy));
+        let bestD1 = trace.d1;
+        let bestD2 = trace.d2;
+        const origD1 = trace.d1;
+        const origD2 = trace.d2;
+        for (const delta of deltas) {
+          trace.d1 = Math.max(minDist, Math.min(maxDist, origD1 + delta));
+          this.updateControlPointsFromDistances(i);
           this.updateSingleTraceSample(i);
           const cost1 = this.computeCostForTrace(i);
           if (cost1 < bestCost) {
             bestCost = cost1;
-            bestCtrl1x = trace.ctrl1.x;
-            bestCtrl1y = trace.ctrl1.y;
-            bestCtrl2x = origCtrl2x;
-            bestCtrl2y = origCtrl2y;
+            bestD1 = trace.d1;
+            bestD2 = origD2;
           }
-          trace.ctrl1.x = origCtrl1x;
-          trace.ctrl1.y = origCtrl1y;
-          trace.ctrl2.x = Math.max(minX, Math.min(maxX, origCtrl2x + dir.dx));
-          trace.ctrl2.y = Math.max(minY, Math.min(maxY, origCtrl2y + dir.dy));
+          trace.d1 = origD1;
+          this.updateControlPointsFromDistances(i);
+          trace.d2 = Math.max(minDist, Math.min(maxDist, origD2 + delta));
+          this.updateControlPointsFromDistances(i);
           this.updateSingleTraceSample(i);
           const cost2 = this.computeCostForTrace(i);
           if (cost2 < bestCost) {
             bestCost = cost2;
-            bestCtrl1x = origCtrl1x;
-            bestCtrl1y = origCtrl1y;
-            bestCtrl2x = trace.ctrl2.x;
-            bestCtrl2y = trace.ctrl2.y;
+            bestD1 = origD1;
+            bestD2 = trace.d2;
           }
-          trace.ctrl2.x = origCtrl2x;
-          trace.ctrl2.y = origCtrl2y;
-          trace.ctrl1.x = Math.max(minX, Math.min(maxX, origCtrl1x + dir.dx));
-          trace.ctrl1.y = Math.max(minY, Math.min(maxY, origCtrl1y + dir.dy));
-          trace.ctrl2.x = Math.max(minX, Math.min(maxX, origCtrl2x + dir.dx));
-          trace.ctrl2.y = Math.max(minY, Math.min(maxY, origCtrl2y + dir.dy));
+          trace.d2 = origD2;
+          this.updateControlPointsFromDistances(i);
+          trace.d1 = Math.max(minDist, Math.min(maxDist, origD1 + delta));
+          trace.d2 = Math.max(minDist, Math.min(maxDist, origD2 + delta));
+          this.updateControlPointsFromDistances(i);
           this.updateSingleTraceSample(i);
           const cost3 = this.computeCostForTrace(i);
           if (cost3 < bestCost) {
             bestCost = cost3;
-            bestCtrl1x = trace.ctrl1.x;
-            bestCtrl1y = trace.ctrl1.y;
-            bestCtrl2x = trace.ctrl2.x;
-            bestCtrl2y = trace.ctrl2.y;
+            bestD1 = trace.d1;
+            bestD2 = trace.d2;
+          }
+          trace.d1 = origD1;
+          trace.d2 = origD2;
+          this.updateControlPointsFromDistances(i);
+          trace.d1 = Math.max(minDist, Math.min(maxDist, origD1 + delta));
+          trace.d2 = Math.max(minDist, Math.min(maxDist, origD2 - delta));
+          this.updateControlPointsFromDistances(i);
+          this.updateSingleTraceSample(i);
+          const cost4 = this.computeCostForTrace(i);
+          if (cost4 < bestCost) {
+            bestCost = cost4;
+            bestD1 = trace.d1;
+            bestD2 = trace.d2;
           }
-          trace.ctrl1.x = origCtrl1x;
-          trace.ctrl1.y = origCtrl1y;
-          trace.ctrl2.x = origCtrl2x;
-          trace.ctrl2.y = origCtrl2y;
+          trace.d1 = origD1;
+          trace.d2 = origD2;
+          this.updateControlPointsFromDistances(i);
         }
-        trace.ctrl1.x = bestCtrl1x;
-        trace.ctrl1.y = bestCtrl1y;
-        trace.ctrl2.x = bestCtrl2x;
-        trace.ctrl2.y = bestCtrl2y;
+        trace.d1 = bestD1;
+        trace.d2 = bestD2;
+        this.updateControlPointsFromDistances(i);
         this.updateSingleTraceSample(i);
         if (bestCost < currentCost * 0.9) break;
       }
@@ -1438,13 +1675,25 @@ var CurvyTraceSolver = class extends BaseSolver {
     if (this.optimizationStep < this.maxOptimizationSteps) {
       this.optimizeStep();
       this.optimizationStep++;
+      if (this.optimizationStep % 10 === 0) {
+        const resolved = this.resolveIntersections();
+        if (resolved > 0) {
+          this.updateCollisionPairs();
+        }
+      }
       const currentCost = this.computeTotalCost();
       if (currentCost === 0) {
         this.optimizationStep = this.maxOptimizationSteps;
       } else if (currentCost >= this.lastCost * 0.99) {
         this.stagnantSteps++;
-        if (this.stagnantSteps > 15) {
-          this.optimizationStep = this.maxOptimizationSteps;
+        if (this.stagnantSteps > 10) {
+          const resolved = this.resolveIntersections();
+          if (resolved > 0) {
+            this.updateCollisionPairs();
+            this.stagnantSteps = 0;
+          } else if (this.stagnantSteps > 15) {
+            this.optimizationStep = this.maxOptimizationSteps;
+          }
         }
       } else {
         this.stagnantSteps = 0;
@@ -1452,6 +1701,7 @@ var CurvyTraceSolver = class extends BaseSolver {
       this.lastCost = currentCost;
     }
     if (this.optimizationStep >= this.maxOptimizationSteps) {
+      this.resolveIntersections();
       this.buildOutputTraces();
       this.solved = true;
     }

package/package.json

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