@tscircuit/cli 0.1.1904 → 0.1.1905

package/dist/cli/main.js

@@ -135442,7 +135442,7 @@ var import_perfect_cli = __toESM2(require_dist2(), 1);
 // lib/getVersion.ts
 import { createRequire as createRequire2 } from "node:module";
 // package.json
-var version = "0.1.1901";
+var version = "0.1.1904";
 var package_default = {
   name: "@tscircuit/cli",
   version,
@@ -135456,7 +135456,7 @@ var package_default = {
     "@biomejs/biome": "^1.9.4",
     "@tscircuit/check-shorts": "https://jscdn.tscircuit.com/@tscircuit/check-shorts/0.0.19.tgz",
     "@tscircuit/circuit-json-placement-analysis": "^0.0.9",
-    "@tscircuit/circuit-json-routing-analysis": "^0.0.7",
+    "@tscircuit/circuit-json-routing-analysis": "^0.0.8",
     "@tscircuit/circuit-json-schematic-placement-analysis": "github:tscircuit/circuit-json-schematic-placement-analysis#bb0b41d80c9714695b498e182c2a558f1e0ceb2d",
     "@tscircuit/circuit-json-util": "^0.0.105",
     "@tscircuit/eval": "^0.0.1016",
@@ -178518,6 +178518,29 @@ var getBoundsFromNode = (node) => ({
 var getBoundsWidth = (bounds) => bounds.maxX - bounds.minX;
 var getBoundsHeight = (bounds) => bounds.maxY - bounds.minY;
 var doBoundsIntersect = (a2, b22) => !(a2.maxX < b22.minX || a2.minX > b22.maxX || a2.maxY < b22.minY || a2.minY > b22.maxY);
+var getEdgeDistanceBetweenBounds = (a2, b22) => {
+  const dx2 = Math.max(a2.minX - b22.maxX, b22.minX - a2.maxX, 0);
+  const dy2 = Math.max(a2.minY - b22.maxY, b22.minY - a2.maxY, 0);
+  return Math.hypot(dx2, dy2);
+};
+var getBoundsComparisonTolerance = (...bounds) => {
+  const coordinateScale = Math.max(1, ...bounds.flatMap((bound) => [
+    Math.abs(bound.minX),
+    Math.abs(bound.maxX),
+    Math.abs(bound.minY),
+    Math.abs(bound.maxY)
+  ]));
+  return Number.EPSILON * coordinateScale * 16;
+};
+var getOverlapDepthBetweenBounds = (a2, b22) => {
+  const overlapWidth = Math.min(a2.maxX, b22.maxX) - Math.max(a2.minX, b22.minX);
+  const overlapHeight = Math.min(a2.maxY, b22.maxY) - Math.max(a2.minY, b22.minY);
+  const comparisonTolerance = getBoundsComparisonTolerance(a2, b22);
+  if (overlapWidth <= comparisonTolerance || overlapHeight <= comparisonTolerance) {
+    return 0;
+  }
+  return Math.min(overlapWidth, overlapHeight);
+};
 var isContainedWithinBounds = (componentBounds, regionBounds) => componentBounds.minX >= regionBounds.minX && componentBounds.maxX <= regionBounds.maxX && componentBounds.minY >= regionBounds.minY && componentBounds.maxY <= regionBounds.maxY;
 var doesRegionFitWithinComponent = (componentBounds, regionBounds) => regionBounds.minX >= componentBounds.minX && regionBounds.maxX <= componentBounds.maxX && regionBounds.minY >= componentBounds.minY && regionBounds.maxY <= componentBounds.maxY;
 var translateBounds = (bounds, direction2, distance50) => {
@@ -179005,10 +179028,10 @@ var hasCollisionAtDistance = (spatialIndex, componentIndex, direction2, distance
 };
 var getFreeSpaceForDirection = (spatialIndex, componentIndex, direction2) => {
   if (hasCollisionAtDistance(spatialIndex, componentIndex, direction2, 0)) {
-    return "0.0mm";
+    return { distanceMm: 0, isAtLeast: false };
   }
   if (!hasCollisionAtDistance(spatialIndex, componentIndex, direction2, MAX_FREE_SPACE_MM)) {
-    return ">5mm";
+    return { distanceMm: MAX_FREE_SPACE_MM, isAtLeast: true };
   }
   let low = 0;
   let high = MAX_FREE_SPACE_MM;
@@ -179020,7 +179043,7 @@ var getFreeSpaceForDirection = (spatialIndex, componentIndex, direction2) => {
       low = mid;
     }
   }
-  return `${low.toFixed(1)}mm`;
+  return { distanceMm: low, isAtLeast: false };
 };
 var getDirectionalFreeSpace = (spatialIndex, componentIndex, directions) => {
   const freeSpaceByDirection = {};
@@ -179029,8 +179052,7 @@ var getDirectionalFreeSpace = (spatialIndex, componentIndex, directions) => {
   }
   return freeSpaceByDirection;
 };
-var fmtMm3 = (value) => `${value.toFixed(1)}mm`;
-var roundsToZeroMm = (value) => Math.abs(value) < 0.05;
+var DEFAULT_MAX_NEARBY_COMPONENT_DISTANCE_MM = 5;
 var toNumber3 = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
 var getPcbComponentBounds = (element) => {
   const center2 = typeof element.center === "object" && element.center ? element.center : null;
@@ -179073,44 +179095,48 @@ var getPlacedComponents = (circuitJson) => {
   }
   return placedComponents;
 };
-var getOffsetFromTopOfRegion = (componentBounds, regionBounds) => fmtMm3(regionBounds.maxY - componentBounds.maxY);
-var getOffsetFromBottomOfRegion = (componentBounds, regionBounds) => fmtMm3(componentBounds.minY - regionBounds.minY);
-var getOffsetFromLeftOfRegion = (componentBounds, regionBounds) => fmtMm3(componentBounds.minX - regionBounds.minX);
-var getOffsetFromRightOfRegion = (componentBounds, regionBounds) => fmtMm3(regionBounds.maxX - componentBounds.maxX);
-var addEdgeAlignedOffsets = (nearbyComponent, componentBounds, regionBounds) => {
-  if (nearbyComponent.onLeftEdgeOfRegion || nearbyComponent.onRightEdgeOfRegion) {
-    nearbyComponent.distToTopOfRegion = getOffsetFromTopOfRegion(componentBounds, regionBounds);
-    nearbyComponent.distToBottomOfRegion = getOffsetFromBottomOfRegion(componentBounds, regionBounds);
-  }
-  if (nearbyComponent.onTopEdgeOfRegion || nearbyComponent.onBottomEdgeOfRegion) {
-    nearbyComponent.distToLeftEdgeOfRegion = getOffsetFromLeftOfRegion(componentBounds, regionBounds);
-    nearbyComponent.distToRightEdgeOfRegion = getOffsetFromRightOfRegion(componentBounds, regionBounds);
-  }
-  return nearbyComponent;
-};
-var getDirectionsToExclude = (component) => {
+var getOutsideDirections = (componentBounds, regionBounds) => {
   const directions = [];
-  const hasHorizontalEdge = component.onLeftEdgeOfRegion || component.onRightEdgeOfRegion;
-  const hasVerticalEdge = component.onTopEdgeOfRegion || component.onBottomEdgeOfRegion;
-  if (component.onLeftEdgeOfRegion) {
+  const tolerance = getBoundsComparisonTolerance(componentBounds, regionBounds);
+  if (componentBounds.maxX <= regionBounds.minX + tolerance)
+    directions.push("left");
+  if (componentBounds.minX >= regionBounds.maxX - tolerance)
     directions.push("right");
-  } else if (component.onRightEdgeOfRegion) {
+  if (componentBounds.maxY <= regionBounds.minY + tolerance)
+    directions.push("bottom");
+  if (componentBounds.minY >= regionBounds.maxY - tolerance)
+    directions.push("top");
+  return directions;
+};
+var getOverlapDirections = (componentBounds, regionBounds) => {
+  const directions = [];
+  if (componentBounds.minX <= regionBounds.minX)
     directions.push("left");
-  } else if (!hasVerticalEdge) {
-    if (component.distToLeftEdgeOfRegion)
-      directions.push("right");
-    if (component.distToRightEdgeOfRegion)
-      directions.push("left");
-  }
-  if (component.onTopEdgeOfRegion) {
+  if (componentBounds.maxX >= regionBounds.maxX)
+    directions.push("right");
+  if (componentBounds.minY <= regionBounds.minY)
     directions.push("bottom");
-  } else if (component.onBottomEdgeOfRegion) {
+  if (componentBounds.maxY >= regionBounds.maxY)
     directions.push("top");
-  } else if (!hasHorizontalEdge) {
-    if (component.distToTopOfRegion)
-      directions.push("bottom");
-    if (component.distToBottomOfRegion)
-      directions.push("top");
+  return directions;
+};
+var getDirectionsToExclude = (component) => {
+  const directions = [];
+  for (const direction2 of component.directions) {
+    switch (direction2) {
+      case "left":
+        directions.push("right");
+        break;
+      case "right":
+        directions.push("left");
+        break;
+      case "top":
+        directions.push("bottom");
+        break;
+      case "bottom":
+        directions.push("top");
+        break;
+    }
   }
   return directions;
 };
@@ -179122,174 +179148,37 @@ var addFreeSpace = (nearbyComponent, componentIndex, spatialIndex) => {
       continue;
     directionsToCheck.push(direction2);
   }
-  const freeSpaceByDirection = getDirectionalFreeSpace(spatialIndex, componentIndex, directionsToCheck);
-  if (freeSpaceByDirection.left)
-    nearbyComponent.freeSpaceOnLeft = freeSpaceByDirection.left;
-  if (freeSpaceByDirection.right)
-    nearbyComponent.freeSpaceOnRight = freeSpaceByDirection.right;
-  if (freeSpaceByDirection.top)
-    nearbyComponent.freeSpaceAbove = freeSpaceByDirection.top;
-  if (freeSpaceByDirection.bottom)
-    nearbyComponent.freeSpaceBelow = freeSpaceByDirection.bottom;
-  return nearbyComponent;
-};
-var createOverlappingNearbyComponent = (component, componentIndex, regionBounds, spatialIndex) => {
+  return {
+    ...nearbyComponent,
+    freeSpaceByDirection: getDirectionalFreeSpace(spatialIndex, componentIndex, directionsToCheck)
+  };
+};
+var createNearbyComponent = (component, componentIndex, regionBounds, spatialIndex) => {
+  const edgeDistanceMm = getEdgeDistanceBetweenBounds(component.bounds, regionBounds);
+  const overlapDepthMm = getOverlapDepthBetweenBounds(component.bounds, regionBounds);
+  const overlapsRegion = overlapDepthMm > 0;
   const nearbyComponent = {
     name: component.name,
-    minX: component.bounds.minX,
-    maxX: component.bounds.maxX,
-    minY: component.bounds.minY,
-    maxY: component.bounds.maxY
+    bounds: component.bounds,
+    edgeDistanceMm,
+    directions: overlapsRegion ? getOverlapDirections(component.bounds, regionBounds) : getOutsideDirections(component.bounds, regionBounds),
+    ...overlapsRegion ? { overlapDepthMm } : {}
   };
-  if (isContainedWithinBounds(component.bounds, regionBounds)) {
+  if (overlapsRegion && isContainedWithinBounds(component.bounds, regionBounds)) {
     nearbyComponent.containedWithinBounds = true;
-  } else if (doesRegionFitWithinComponent(component.bounds, regionBounds)) {
+  } else if (overlapsRegion && doesRegionFitWithinComponent(component.bounds, regionBounds)) {
     nearbyComponent.regionWithinComponent = true;
-  } else {
-    if (component.bounds.minX <= regionBounds.minX) {
-      nearbyComponent.onLeftEdgeOfRegion = true;
-    }
-    if (component.bounds.maxX >= regionBounds.maxX) {
-      nearbyComponent.onRightEdgeOfRegion = true;
-    }
-    if (component.bounds.maxY >= regionBounds.maxY) {
-      nearbyComponent.onTopEdgeOfRegion = true;
-    }
-    if (component.bounds.minY <= regionBounds.minY) {
-      nearbyComponent.onBottomEdgeOfRegion = true;
-    }
-    addEdgeAlignedOffsets(nearbyComponent, component.bounds, regionBounds);
   }
   return addFreeSpace(nearbyComponent, componentIndex, spatialIndex);
 };
-var getOutsideComponentCandidate = (component, componentIndex, regionBounds) => {
-  if (doBoundsIntersect(component.bounds, regionBounds))
-    return null;
-  const candidates = [];
-  if (component.bounds.maxX < regionBounds.minX) {
-    candidates.push({
-      direction: "left",
-      distance: regionBounds.minX - component.bounds.maxX
-    });
-  }
-  if (component.bounds.minX > regionBounds.maxX) {
-    candidates.push({
-      direction: "right",
-      distance: component.bounds.minX - regionBounds.maxX
-    });
-  }
-  if (component.bounds.maxY < regionBounds.minY) {
-    candidates.push({
-      direction: "bottom",
-      distance: regionBounds.minY - component.bounds.maxY
-    });
+var getNearbyComponents = (circuitJson, regionBounds, options = {}) => {
+  const maxDistanceMm = options.maxDistanceMm ?? DEFAULT_MAX_NEARBY_COMPONENT_DISTANCE_MM;
+  if (!Number.isFinite(maxDistanceMm) || maxDistanceMm < 0) {
+    throw new RangeError("maxDistanceMm must be a non-negative finite number");
   }
-  if (component.bounds.minY > regionBounds.maxY) {
-    candidates.push({
-      direction: "top",
-      distance: component.bounds.minY - regionBounds.maxY
-    });
-  }
-  if (candidates.length === 0)
-    return null;
-  const closestCandidates = candidates.sort((a2, b22) => a2.distance - b22.distance).slice(0, 2);
-  const nearbyComponentCandidate = {
-    componentIndex,
-    name: component.name,
-    score: closestCandidates.reduce((smallestDistance, candidate) => Math.min(smallestDistance, candidate.distance), Number.POSITIVE_INFINITY),
-    minX: component.bounds.minX,
-    maxX: component.bounds.maxX,
-    minY: component.bounds.minY,
-    maxY: component.bounds.maxY
-  };
-  for (const candidate of closestCandidates) {
-    switch (candidate.direction) {
-      case "left":
-        if (roundsToZeroMm(candidate.distance)) {
-          nearbyComponentCandidate.onLeftEdgeOfRegion = true;
-        } else {
-          nearbyComponentCandidate.distToLeftEdgeOfRegion = fmtMm3(candidate.distance);
-        }
-        break;
-      case "right":
-        if (roundsToZeroMm(candidate.distance)) {
-          nearbyComponentCandidate.onRightEdgeOfRegion = true;
-        } else {
-          nearbyComponentCandidate.distToRightEdgeOfRegion = fmtMm3(candidate.distance);
-        }
-        break;
-      case "top":
-        if (roundsToZeroMm(candidate.distance)) {
-          nearbyComponentCandidate.onTopEdgeOfRegion = true;
-        } else {
-          nearbyComponentCandidate.distToTopOfRegion = fmtMm3(candidate.distance);
-        }
-        break;
-      case "bottom":
-        if (roundsToZeroMm(candidate.distance)) {
-          nearbyComponentCandidate.onBottomEdgeOfRegion = true;
-        } else {
-          nearbyComponentCandidate.distToBottomOfRegion = fmtMm3(candidate.distance);
-        }
-        break;
-    }
-  }
-  const nearbyComponent = addEdgeAlignedOffsets({
-    name: nearbyComponentCandidate.name,
-    minX: nearbyComponentCandidate.minX,
-    maxX: nearbyComponentCandidate.maxX,
-    minY: nearbyComponentCandidate.minY,
-    maxY: nearbyComponentCandidate.maxY,
-    ...nearbyComponentCandidate.onLeftEdgeOfRegion ? { onLeftEdgeOfRegion: true } : {},
-    ...nearbyComponentCandidate.onRightEdgeOfRegion ? { onRightEdgeOfRegion: true } : {},
-    ...nearbyComponentCandidate.onTopEdgeOfRegion ? { onTopEdgeOfRegion: true } : {},
-    ...nearbyComponentCandidate.onBottomEdgeOfRegion ? { onBottomEdgeOfRegion: true } : {},
-    ...nearbyComponentCandidate.distToLeftEdgeOfRegion ? {
-      distToLeftEdgeOfRegion: nearbyComponentCandidate.distToLeftEdgeOfRegion
-    } : {},
-    ...nearbyComponentCandidate.distToRightEdgeOfRegion ? {
-      distToRightEdgeOfRegion: nearbyComponentCandidate.distToRightEdgeOfRegion
-    } : {},
-    ...nearbyComponentCandidate.distToTopOfRegion ? {
-      distToTopOfRegion: nearbyComponentCandidate.distToTopOfRegion
-    } : {},
-    ...nearbyComponentCandidate.distToBottomOfRegion ? {
-      distToBottomOfRegion: nearbyComponentCandidate.distToBottomOfRegion
-    } : {}
-  }, component.bounds, regionBounds);
-  return {
-    ...nearbyComponentCandidate,
-    ...nearbyComponent
-  };
-};
-var getNearbyComponents = (circuitJson, regionBounds) => {
   const placedComponents = getPlacedComponents(circuitJson);
   const spatialIndex = buildComponentSpatialIndex(placedComponents);
-  const overlappingComponents = placedComponents.map((component, componentIndex) => {
-    if (!doBoundsIntersect(component.bounds, regionBounds))
-      return null;
-    return createOverlappingNearbyComponent(component, componentIndex, regionBounds, spatialIndex);
-  }).filter((component) => component !== null).sort((a2, b22) => a2.name.localeCompare(b22.name));
-  const outsideComponents = placedComponents.map((component, componentIndex) => getOutsideComponentCandidate(component, componentIndex, regionBounds)).filter((component) => component !== null).sort((a2, b22) => a2.score - b22.score || a2.name.localeCompare(b22.name)).slice(0, 3).map((component) => addFreeSpace({
-    name: component.name,
-    minX: component.minX,
-    maxX: component.maxX,
-    minY: component.minY,
-    maxY: component.maxY,
-    ...component.onLeftEdgeOfRegion ? { onLeftEdgeOfRegion: true } : {},
-    ...component.onRightEdgeOfRegion ? { onRightEdgeOfRegion: true } : {},
-    ...component.onTopEdgeOfRegion ? { onTopEdgeOfRegion: true } : {},
-    ...component.onBottomEdgeOfRegion ? { onBottomEdgeOfRegion: true } : {},
-    ...component.distToLeftEdgeOfRegion ? {
-      distToLeftEdgeOfRegion: component.distToLeftEdgeOfRegion
-    } : {},
-    ...component.distToRightEdgeOfRegion ? {
-      distToRightEdgeOfRegion: component.distToRightEdgeOfRegion
-    } : {},
-    ...component.distToTopOfRegion ? { distToTopOfRegion: component.distToTopOfRegion } : {},
-    ...component.distToBottomOfRegion ? { distToBottomOfRegion: component.distToBottomOfRegion } : {}
-  }, component.componentIndex, spatialIndex));
-  return [...overlappingComponents, ...outsideComponents];
+  return placedComponents.map((component, componentIndex) => createNearbyComponent(component, componentIndex, regionBounds, spatialIndex)).filter((component) => component.overlapDepthMm !== undefined || component.edgeDistanceMm <= maxDistanceMm).sort((a2, b22) => a2.edgeDistanceMm - b22.edgeDistanceMm || (b22.overlapDepthMm ?? 0) - (a2.overlapDepthMm ?? 0) || a2.name.localeCompare(b22.name));
 };
 var getBoundsArea = (bounds) => Math.max(0, bounds.maxX - bounds.minX) * Math.max(0, bounds.maxY - bounds.minY);
 var getIntersectionArea = (a2, b22) => {
@@ -300825,8 +300714,10 @@ var fmtNumber3 = (value) => {
     return String(value);
   return value.toFixed(3).replace(/\.0+$/, "").replace(/(\.\d*?)0+$/, "$1");
 };
-var fmtMm22 = (value) => `${value.toFixed(1)}mm`;
+var fmtMm3 = (value) => `${value.toFixed(1)}mm`;
+var fmtMeasurementMm = (value) => `${fmtNumber3(value)}mm`;
 var fmtPercent2 = (value) => `${fmtNumber3(value * 100)}%`;
+var xmlEscape = (value) => value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
 var isCrampedPortPoint = (portPointId) => portPointId?.includes("_cramped") ?? false;
 var clamp012 = (value) => Math.max(0, Math.min(1, value));
 var roundProbability = (value) => Number.parseFloat(value.toFixed(3));
@@ -300843,51 +300734,38 @@ var getProbabilityOfFailure = (node, maxDensity, maxPortPointCount) => {
   return roundProbability(clamp012((crampedRatio * 0.7 + densityScore * 0.3) * trafficScore));
 };
 var nearbyComponentToString = (component) => {
-  const attrs = [`name="${component.name}"`];
+  const attrs = [
+    `name="${xmlEscape(component.name)}"`,
+    `edgeDistance="${fmtMeasurementMm(component.edgeDistanceMm)}"`
+  ];
+  if (component.overlapDepthMm !== undefined) {
+    attrs.push(`overlapDepth="${fmtMeasurementMm(component.overlapDepthMm)}"`);
+  }
+  if (component.directions.length > 0) {
+    attrs.push(`directions="${component.directions.join(",")}"`);
+  }
   if (component.containedWithinBounds)
     attrs.push("containedWithinBounds");
   if (component.regionWithinComponent)
     attrs.push("regionWithinComponent");
-  if (component.onLeftEdgeOfRegion)
-    attrs.push("onLeftEdgeOfRegion");
-  if (component.onRightEdgeOfRegion)
-    attrs.push("onRightEdgeOfRegion");
-  if (component.onTopEdgeOfRegion)
-    attrs.push("onTopEdgeOfRegion");
-  if (component.onBottomEdgeOfRegion)
-    attrs.push("onBottomEdgeOfRegion");
-  if (component.distToLeftEdgeOfRegion) {
-    attrs.push(`distToLeftEdgeOfRegion="${component.distToLeftEdgeOfRegion}"`);
-  }
-  if (component.distToRightEdgeOfRegion) {
-    attrs.push(`distToRightEdgeOfRegion="${component.distToRightEdgeOfRegion}"`);
-  }
-  if (component.distToTopOfRegion) {
-    attrs.push(`distToTopOfRegion="${component.distToTopOfRegion}"`);
-  }
-  if (component.distToBottomOfRegion) {
-    attrs.push(`distToBottomOfRegion="${component.distToBottomOfRegion}"`);
-  }
-  if (component.freeSpaceOnLeft) {
-    attrs.push(`freeSpaceOnLeft="${component.freeSpaceOnLeft}"`);
-  }
-  if (component.freeSpaceOnRight) {
-    attrs.push(`freeSpaceOnRight="${component.freeSpaceOnRight}"`);
-  }
-  if (component.freeSpaceAbove) {
-    attrs.push(`freeSpaceAbove="${component.freeSpaceAbove}"`);
-  }
-  if (component.freeSpaceBelow) {
-    attrs.push(`freeSpaceBelow="${component.freeSpaceBelow}"`);
-  }
-  attrs.push(`left="${fmtMm22(component.minX)}"`, `right="${fmtMm22(component.maxX)}"`, `bottom="${fmtMm22(component.minY)}"`, `top="${fmtMm22(component.maxY)}"`);
+  const addFreeSpaceAttribute = (direction2, attributeName) => {
+    const freeSpace = component.freeSpaceByDirection[direction2];
+    if (!freeSpace)
+      return;
+    attrs.push(`${attributeName}="${freeSpace.isAtLeast ? ">" : ""}${fmtMm3(freeSpace.distanceMm)}"`);
+  };
+  addFreeSpaceAttribute("left", "freeSpaceOnLeft");
+  addFreeSpaceAttribute("right", "freeSpaceOnRight");
+  addFreeSpaceAttribute("top", "freeSpaceAbove");
+  addFreeSpaceAttribute("bottom", "freeSpaceBelow");
+  attrs.push(`left="${fmtMm3(component.bounds.minX)}"`, `right="${fmtMm3(component.bounds.maxX)}"`, `bottom="${fmtMm3(component.bounds.minY)}"`, `top="${fmtMm3(component.bounds.maxY)}"`);
   return `    <NearbyComponent ${attrs.join(" ")} />`;
 };
 var lineItemToString2 = (lineItem) => {
   switch (lineItem.lineItemType) {
     case "CongestedRegion":
       return [
-        `<CongestedRegion probabilityOfFailure="${lineItem.probabilityOfFailure}" left="${fmtMm22(lineItem.bounds.minX)}" right="${fmtMm22(lineItem.bounds.maxX)}" bottom="${fmtMm22(lineItem.bounds.minY)}" top="${fmtMm22(lineItem.bounds.maxY)}" width="${fmtMm22(lineItem.width)}" height="${fmtMm22(lineItem.height)}">`,
+        `<CongestedRegion probabilityOfFailure="${lineItem.probabilityOfFailure}" left="${fmtMm3(lineItem.bounds.minX)}" right="${fmtMm3(lineItem.bounds.maxX)}" bottom="${fmtMm3(lineItem.bounds.minY)}" top="${fmtMm3(lineItem.bounds.maxY)}" width="${fmtMm3(lineItem.width)}" height="${fmtMm3(lineItem.height)}">`,
         ...lineItem.nearbyComponents.map(nearbyComponentToString),
         "</CongestedRegion>"
       ].join(`

package/dist/lib/index.js

@@ -65757,7 +65757,7 @@ var getNodeHandler = (winterSpec, { port, middleware = [] }) => {
   }));
 };
 // package.json
-var version = "0.1.1901";
+var version = "0.1.1904";
 var package_default = {
   name: "@tscircuit/cli",
   version,
@@ -65771,7 +65771,7 @@ var package_default = {
     "@biomejs/biome": "^1.9.4",
     "@tscircuit/check-shorts": "https://jscdn.tscircuit.com/@tscircuit/check-shorts/0.0.19.tgz",
     "@tscircuit/circuit-json-placement-analysis": "^0.0.9",
-    "@tscircuit/circuit-json-routing-analysis": "^0.0.7",
+    "@tscircuit/circuit-json-routing-analysis": "^0.0.8",
     "@tscircuit/circuit-json-schematic-placement-analysis": "github:tscircuit/circuit-json-schematic-placement-analysis#bb0b41d80c9714695b498e182c2a558f1e0ceb2d",
     "@tscircuit/circuit-json-util": "^0.0.105",
     "@tscircuit/eval": "^0.0.1016",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/cli",
-  "version": "0.1.1904",
+  "version": "0.1.1905",
   "main": "dist/cli/main.js",
   "exports": {
     ".": "./dist/cli/main.js",
@@ -11,7 +11,7 @@
     "@biomejs/biome": "^1.9.4",
     "@tscircuit/check-shorts": "https://jscdn.tscircuit.com/@tscircuit/check-shorts/0.0.19.tgz",
     "@tscircuit/circuit-json-placement-analysis": "^0.0.9",
-    "@tscircuit/circuit-json-routing-analysis": "^0.0.7",
+    "@tscircuit/circuit-json-routing-analysis": "^0.0.8",
     "@tscircuit/circuit-json-schematic-placement-analysis": "github:tscircuit/circuit-json-schematic-placement-analysis#bb0b41d80c9714695b498e182c2a558f1e0ceb2d",
     "@tscircuit/circuit-json-util": "^0.0.105",
     "@tscircuit/eval": "^0.0.1016",