@tscircuit/capacity-autorouter 0.0.7 → 0.0.9

package/dist/index.js

@@ -4287,6 +4287,66 @@ var NetToPointPairsSolver = class extends BaseSolver {
   }
 };
 
+// lib/utils/convertHdRouteToSimplifiedRoute.ts
+var convertHdRouteToSimplifiedRoute = (hdRoute, layerCount) => {
+  const result = [];
+  if (hdRoute.route.length === 0) return result;
+  const mapZToLayerName = (z) => {
+    if (z < 0 || z >= layerCount) {
+      throw new Error(`Invalid z "${z}" for layer count: ${layerCount}`);
+    }
+    if (z === 0) return "top";
+    if (z === layerCount - 1) return "bottom";
+    return `inner${z}`;
+  };
+  let currentLayerPoints = [];
+  let currentZ = hdRoute.route[0].z;
+  for (let i = 0; i < hdRoute.route.length; i++) {
+    const point = hdRoute.route[i];
+    if (point.z !== currentZ) {
+      const layerName2 = mapZToLayerName(currentZ);
+      for (const layerPoint of currentLayerPoints) {
+        result.push({
+          route_type: "wire",
+          x: layerPoint.x,
+          y: layerPoint.y,
+          width: hdRoute.traceThickness,
+          layer: layerName2
+        });
+      }
+      const viaExists = hdRoute.vias.some(
+        (via) => Math.abs(via.x - point.x) < 1e-3 && Math.abs(via.y - point.y) < 1e-3
+      );
+      if (viaExists) {
+        const fromLayer = mapZToLayerName(point.z);
+        const toLayer = mapZToLayerName(point.z);
+        result.push({
+          route_type: "via",
+          x: point.x,
+          y: point.y,
+          from_layer: fromLayer,
+          to_layer: toLayer
+        });
+      }
+      currentLayerPoints = [point];
+      currentZ = point.z;
+    } else {
+      currentLayerPoints.push(point);
+    }
+  }
+  const layerName = mapZToLayerName(currentZ);
+  for (const layerPoint of currentLayerPoints) {
+    result.push({
+      route_type: "wire",
+      x: layerPoint.x,
+      y: layerPoint.y,
+      width: hdRoute.traceThickness,
+      layer: layerName
+    });
+  }
+  return result;
+};
+
 // lib/solvers/CapacityMeshSolver/CapacityMeshSolver.ts
 var CapacityMeshSolver = class extends BaseSolver {
   constructor(srj, opts = {}) {
@@ -4509,39 +4569,14 @@ var CapacityMeshSolver = class extends BaseSolver {
       throw new Error("Cannot get output before solving is complete");
     }
     const traces = [];
-    for (const route of this.highDensityRouteSolver.routes) {
-      const simplifiedRoute = this.simplifyRoute(route.route);
-      const originalConnectionName = this.getOriginalConnectionName(
-        route.connectionName
-      );
+    for (const hdRoute of this.highDensityRouteSolver.routes) {
+      const pointPairConnName = hdRoute.connectionName;
       const trace = {
         type: "pcb_trace",
-        pcb_trace_id: route.connectionName,
-        connection_name: originalConnectionName,
-        route: []
+        pcb_trace_id: pointPairConnName,
+        connection_name: this.getOriginalConnectionName(pointPairConnName),
+        route: convertHdRouteToSimplifiedRoute(hdRoute, 2)
       };
-      let currentLayer = simplifiedRoute[0]?.z.toString() || "0";
-      for (let i = 0; i < simplifiedRoute.length; i++) {
-        const point = simplifiedRoute[i];
-        const nextLayerStr = point.z.toString();
-        if (nextLayerStr !== currentLayer) {
-          trace.route.push({
-            route_type: "via",
-            x: point.x,
-            y: point.y,
-            from_layer: this.mapLayer(currentLayer),
-            to_layer: this.mapLayer(nextLayerStr)
-          });
-          currentLayer = nextLayerStr;
-        }
-        trace.route.push({
-          route_type: "wire",
-          x: point.x,
-          y: point.y,
-          width: route.traceThickness || this.highDensityRouteSolver.defaultTraceThickness,
-          layer: this.mapLayer(currentLayer)
-        });
-      }
       traces.push(trace);
     }
     return {