@tscircuit/capacity-autorouter 0.0.8 → 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 = {}) {
@@ -4508,60 +4568,15 @@ var CapacityMeshSolver = class extends BaseSolver {
     if (!this.solved || !this.highDensityRouteSolver) {
       throw new Error("Cannot get output before solving is complete");
     }
-    const traceIdToRoutes = {};
-    for (const route of this.highDensityRouteSolver.routes) {
-      const traceId = route.connectionName;
-      if (!traceIdToRoutes[traceId]) {
-        traceIdToRoutes[traceId] = [];
-      }
-      traceIdToRoutes[traceId].push(route);
-    }
     const traces = [];
-    for (const [traceId, routes] of Object.entries(traceIdToRoutes)) {
-      if (routes.length === 0) continue;
-      const originalConnectionName = this.getOriginalConnectionName(traceId);
+    for (const hdRoute of this.highDensityRouteSolver.routes) {
+      const pointPairConnName = hdRoute.connectionName;
       const trace = {
         type: "pcb_trace",
-        pcb_trace_id: traceId,
-        connection_name: originalConnectionName,
-        route: []
+        pcb_trace_id: pointPairConnName,
+        connection_name: this.getOriginalConnectionName(pointPairConnName),
+        route: convertHdRouteToSimplifiedRoute(hdRoute, 2)
       };
-      const traceThickness = routes[0].traceThickness || this.highDensityRouteSolver.defaultTraceThickness;
-      const allPoints = [];
-      routes.forEach((route, routeIndex) => {
-        const simplifiedRoute = this.simplifyRoute(route.route);
-        simplifiedRoute.forEach((point, pointIndex) => {
-          allPoints.push({ ...point, routeIndex, pointIndex });
-        });
-      });
-      if (allPoints.length === 0) continue;
-      allPoints.sort((a, b) => {
-        if (a.z !== b.z) return a.z - b.z;
-        if (a.x !== b.x) return a.x - b.x;
-        return a.y - b.y;
-      });
-      let currentLayer = allPoints[0].z.toString();
-      for (let i = 0; i < allPoints.length; i++) {
-        const point = allPoints[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: traceThickness,
-          layer: this.mapLayer(currentLayer)
-        });
-      }
       traces.push(trace);
     }
     return {